diff --git a/.gitignore b/.gitignore index 9751f3f0..f48efcb0 100644 --- a/.gitignore +++ b/.gitignore @@ -23,5 +23,12 @@ # Go workspace file go.work -build - +build/ +distribution/ + +cmd/user_config.json +*.vmd +*.pmx +*.pprof +*.log +cmd/framebuffer_output.png diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 00000000..7bbc44e8 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,36 @@ +{ + // IntelliSense を使用して利用可能な属性を学べます。 + // 既存の属性の説明をホバーして表示します。 + // 詳細情報は次を確認してください: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": "Launch", + "type": "go", + "request": "launch", + "mode": "debug", + "program": "${workspaceFolder}/cmd/main.go", + "preLaunchTask": "go: mod tidy", + }, + { + "name": "[dev] Build", + "type": "debugpy", + "request": "launch", + "program": "${workspaceFolder}/.vscode/scripts/build_exe.py", + "env": { + "WORKSPACE_FOLDER": "${workspaceFolder}", + "ENV": "dev" + }, + }, + { + "name": "[prod] Build", + "type": "debugpy", + "request": "launch", + "program": "${workspaceFolder}/.vscode/scripts/build_exe.py", + "env": { + "WORKSPACE_FOLDER": "${workspaceFolder}", + "ENV": "prod" + }, + } + ] +} diff --git a/.vscode/scripts/build_exe.py b/.vscode/scripts/build_exe.py new file mode 100644 index 00000000..79e842e2 --- /dev/null +++ b/.vscode/scripts/build_exe.py @@ -0,0 +1,45 @@ +import json +import os +import winsound +# 環境変数 WORKSPACE_FOLDER の値を取得 +workspace_folder = os.environ.get('WORKSPACE_FOLDER') + +# 値を表示 +print(f"workspace_folder: {workspace_folder}") + +# Read app_config.json file +with open(f'{workspace_folder}/cmd/app/app_config.json', 'r', encoding='utf-8') as file: + config_data = json.load(file) + +# Convert JSON data to dictionary +config_dict = dict(config_data) + +app_name = config_dict.get('Name') +app_version = config_dict.get('Version') + +print(f"app_name: {app_name}") +print(f"app_version: {app_version}") + +all_rebuild = "" if os.environ.get('ENV') == 'dev' else "-a" +env_name = "dev" if os.environ.get('ENV') == 'dev' else "prod" + +# Build command +# -o 出力フォルダ +# -trimpath ビルドパスを削除 +# -v ビルドログを出力 +# -a 全ての依存関係を再ビルド +# -buildmode=exe 実行可能ファイルを生成 +# -ldflags "-s -w" バイナリサイズを小さくする +# -H=windowsgui コンソールを表示しない +# -linkmode external -extldflags '-static -Wl,cmd/app/app.res' リソースを埋め込む +build_command = f"go build -o {workspace_folder}/build/{app_name}_{app_version}.exe -trimpath " \ + f"-v {all_rebuild} -buildmode=exe -ldflags \"-s -w -H=windowsgui -X main.env={env_name} " \ + f"-linkmode external -extldflags '-static -Wl,{workspace_folder}/cmd/app/app.res'\" " \ + f" {workspace_folder}/cmd/main.go" + +print(f"build_command: {build_command}") + +os.system(build_command) + +# Play beep sound +winsound.PlaySound("SystemAsterisk", winsound.SND_ALIAS) diff --git a/.vscode/scripts/clear.bat b/.vscode/scripts/clear.bat new file mode 100644 index 00000000..c48a59f2 --- /dev/null +++ b/.vscode/scripts/clear.bat @@ -0,0 +1,3 @@ +go clean --modcache +go clean -cache +go clean -testcache diff --git a/.vscode/scripts/delete_pre_debug_exe.bat b/.vscode/scripts/delete_pre_debug_exe.bat new file mode 100644 index 00000000..b1091dc2 --- /dev/null +++ b/.vscode/scripts/delete_pre_debug_exe.bat @@ -0,0 +1,8 @@ +echo off + +echo workspaceFolder: %workspaceFolder% + +call del %workspaceFolder%\cmd\__debug_bin* +call del %workspaceFolder%\go\cmd\__debug_bin* + +exit 0 diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 00000000..28ca05fa --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,51 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "shell: delete pre debug exe", + "type": "shell", + "command": "cmd.exe", + "args": [ + "/c", + "set \"workspaceFolder=${workspaceFolder}\" && C:/MMD/mlib_go/.vscode/scripts/delete_pre_debug_exe.bat" + ], + "group": { + "kind": "none", + "isDefault": true + }, + "presentation": { + "echo": false, + "reveal": "silent", + "focus": false, + "panel": "shared", + "showReuseMessage": false, + "clear": true + } + }, + { + "label": "go: mod tidy", + "type": "shell", + "command": "go", + "args": [ + "mod", + "tidy" + ], + "group": { + "kind": "build", + "isDefault": true + }, + "presentation": { + "echo": false, + "reveal": "silent", + "focus": false, + "panel": "shared", + "showReuseMessage": false, + "clear": true + }, + "dependsOn": [ + "shell: delete pre debug exe" + ], + "problemMatcher": [] + } + ] +} \ No newline at end of file diff --git a/README.md b/README.md index a3cd43ed..f18ac93c 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,140 @@ # mlib_go -# 新規作成 +## 新規作成 ``` (mtool) C:\MMD\mlib_go\backend>go mod init github.com/miu200521358/mlib_go go: creating new go.mod: module github.com/miu200521358/mlib_go ``` + +## Clone Build + +- VSCode に go 拡張をいれる `golang.go` +- コマンドプロンプトで下記を実行（× Power Shell） +- https://jmeubank.github.io/tdm-gcc/download/ をインストール + - `Minimal online installer. ` (多分最初のexeボタン) + - PATH に TDM-GCC-64 までのパスを追加 +- go.mod の最後の3行(replaceのとこ)をコメントアウト + - 開発用にローカルのを参照しているため +- ライブラリインポート + - `set GOOS=windows` + - `set GOARCH=amd64` + - `set CGO_ENABLED=1` + - `go mod tidy` +- ビルドできるはず + - `set CGO_ENABLED=1` + - `go run main.go` + - `go build -o ../build/mlib.exe main.go` +- ビルドできたらVSCode再起動で run もできるようになってるはず + +## キャッシュクリア系 + +``` +go clean --modcache +go clean -cache +go clean -testcache +``` + +## フォーマット + +``` +go fmt ./... +``` + +## アイコンの組み込み + +1. .icoファイルを作成 +2. .rcファイルを作成 + - `IDI_ICON1 ICON DISCARDABLE "app.ico"` +3. .resファイルにコンパイル + - `windres -O coff -o app.res app.rc` +4. ビルドスクリプトで実行 + + +## プロファイル + +1. `go run crumb/profile.go` +2. `go tool pprof crumb\profile.go crumb\cpu.pprof` + - `go tool pprof -flat crumb\profile.go crumb\cpu.pprof` + - `go tool pprof -cum crumb\profile.go crumb\cpu.pprof` + - `go tool pprof -http=:8080 cpu.pprof` +3. `(pprof) top` +4. プロファイル: ISAOミク+Addiction + + +### プロファイルのビジュアライザ + +1. `go get github.com/goccy/go-graphviz/cmd/dot` +2. `go install github.com/goccy/go-graphviz` +4. `go tool pprof -http=:8081 mem.pprof` + + +## bullet + +1. swig インストール +https://rinatz.github.io/swigdoc/abstract.html + +2. 変換コード作成 + +``` +(mtool) C:\MMD\mlib_go\pkg\mbt>swig -c++ -go -cgo -I"C:\MMD\mlib_go\pkg\mbt\bullet\src" -I"C:\development\TDM-GCC-64\lib\gcc\x86_64-w64-mingw32\10.3.0\include\c++\x86_64-w64-mingw32" -I"C:\development\TDM-GCC-64\x86_64-w64-mingw32\include" -I"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include" -cpperraswarn -o "C:\MMD\mlib_go\pkg\mbt\mbt.cxx" "C:\MMD\mlib_go\pkg\mbt\bullet.i" +``` + +--------- + + +## fyne (没) + +``` +go get fyne.io/fyne/v2@latest +go install fyne.io/fyne/v2/cmd/fyne@latest +``` + +``` +C:\MMD\mlib_go>fyne bundle resources\MPLUS1-Regular.ttf > pkg\front\core\bundle.go +go get fyne.io/fyne/v2/internal/svg@v2.4.3 +go get fyne.io/fyne/v2/storage/repository@v2.4.3 +``` + +``` +go get fyne.io/fyne/v2/internal/driver/glfw@v2.4.3 +go get fyne.io/fyne/v2/app@v2.4.3 +go get fyne.io/fyne/v2/widget@v2.4.3 +go get fyne.io/fyne/v2/internal/painter@v2.4.3 +``` + +``` +fyne bundle icon.png > icon.go +``` + +``` +go get fyne.io/fyne/v2 +go get github.com/ungerik/go3d +go get github.com/fyne-io/glfw-js +go get fyne.io/fyne/v2/layout +``` + +### walk + +``` +go get github.com/akavel/rsrc +cd %GOPATH%\pkg\mod\github.com\akavel\rsrc@v0.10.2 +go build +``` + +``` +rsrc -manifest main.manifest -o rsrc.syso +``` + +``` +go get -u golang.org/x/image +``` + + +### GCプロファイル + +1. `set GOGC=1000` +2. `set GODEBUG=gctrace=1` +3. `(mtool) C:\MMD\mlib_go\crumb>go run profile.go` +4. `go tool pprof profile.go cpu.pprof` +5. `go tool pprof -http=:8080 cpu.pprof` diff --git "a/archive/defender\345\240\261\345\221\212.txt" "b/archive/defender\345\240\261\345\221\212.txt" new file mode 100644 index 00000000..e6f430ba --- /dev/null +++ "b/archive/defender\345\240\261\345\221\212.txt" @@ -0,0 +1,45 @@ +https://www.microsoft.com/en-us/wdsi/submissionhistory + + +------------------------- + + +このソフトウェアは私が開発したもので、マルウェアに関するコードは組み込んでません。 +Githubでコードを公開しています。 + +本体 +https://github.com/miu200521358/vmd_sizing_t3/tree/develop +https://github.com/miu200521358/sword_blur/tree/develop + +依存ライブラリ +https://github.com/miu200521358/mlib_go/tree/develop + +ご査収の程よろしくお願いいたします。 + + +---------------------- + +This software was developed by me, and it does not contain any malware-related code. + +The code is publicly available on GitHub. + +Main repository +https://github.com/miu200521358/vmd_sizing_t3/tree/develop + +Dependencies library +https://github.com/miu200521358/mlib_go/tree/develop + +Thank you for your consideration. + + +------------------------- + +申し訳ありません。 +先日このソフトウェアを「マルウェアである」と報告しましたが、正しくは「マルウェアと誤検知される」ため、再審査をして頂きたかったソフトウェアになります。 + + +I'm sorry. + +Recently, I reported this software as "malware," but it is actually "misidentified as malware." I would like to request a re-examination of this software. + + diff --git a/archive/revision.txt b/archive/revision.txt new file mode 100644 index 00000000..97c2457d --- /dev/null +++ b/archive/revision.txt @@ -0,0 +1,613 @@ +https://fire.st/eKz6bAA +MlibSample 1.0.0_beta_08 +・ゾンビ退治 +・（一緒にメモリリーク直ったかも？） +・中ボタンでのカメラの動き修正 + +https://fire.st/z2y6tEu +MlibSample 1.0.0_beta_09 +・物理デバッグ時に二重にバインドしていたのを修正 + ・一時停止してから再開したときの描画がダブる事もなくなった + ・メモリリークの原因？ +・モーションなしで読み込んだ時に落ちるのを修正 + +https://fire.st/EPU7lAw +MlibSample 1.0.0_beta_10 +・物理デバッグ時のVAOとVBOの生成をデバッガー初期化時に限定（後は使い回す） + +https://fire.st/oTXaOYY +MlibSample 1.0.0_beta_11 +・物理ON/OFF機能追加 +　・フォローなし … フラグONOFFのみ +　・行列更新　　 … 物理OFF→ONにした時に剛体の位置再計算を行う +　・State初期化　… 物理OFF→ONにした時にMotionState再生成（時々物理がピクつく） +　・行列更新・State初期化　…　両方対応 + +https://fire.st/aZwahtw +MlibSample 1.0.0_beta_12 +・物理ON/OFF機能 +　・フラグONOFF＋フラグを切り替えた直後に剛体の位置再計算を行う + +https://fire.st/bnz4qv4 +MlibSample 1.0.0_beta_13 +・物理リセット機能追加 +・モデル描画ボタン押下時に物理情報をクリアするよう修正 +・IKループ回数が0指定の時、1回だけ回すよう調整 + +https://fire.st/ZcZEDgM +MlibSample 1.0.0_beta_14 +・フレームスキップOFFモード追加 +　・チェックボックスは「フレームドロップON」で、デフォルトON + +https://fire.st/eVxtgI3 +MlibSample 1.0.0_beta_15 +・画面レイアウト調整 +　・表示デバッグ系はメニューに +　・プレイヤーをコンポーネント化 +・ファイルピッカーのD&D有効化 + +https://fire.st/vuhu3Ag +MlibSample 1.0.0_beta_16 +・再生中にPMXを変えた時に落ちるのを修正 +・ボーンデバッグ色定義定数化 +・描画ウィンドウをリサイズ可能に +・コンソール出力対応 +・多言語対応 + +MlibSample 1.0.0_beta_17 +・使い方メニュー追加 +・プレイヤーの再生/一時停止時の処理の流れ調整 +・ログ周り整理 +・改行が文字列内にある場合、コンソール内で改行が行われるよう置換する +・コンソールの出力文字数上限UP + +MlibSample 1.0.0_beta_18 +・予期せぬエラー時のダイアログ追加 +・モーフ描画追加 +　・頂点、UV、ボーンモーフまで +　・材質モーフは材質の半透明描画が変 + +MlibSample 1.0.0_beta_19 +・メインビューウィンドウを閉じた場合、アプリを終了するよう修正 +・PMX、VMDの読み込みエラー時のログをINFOに変更 +・材質のテクスチャで半透明が暗くなっていたのを RGBA → NRGBA に変更して修正 +・フラグメントシェーダーでアルファが非常に小さいときに描画をスキップするよう修正 + +MlibSample 1.0.0_beta_20 +・起動直後にモデルを読み込まないでビューウィンドウを閉じた時にメイン画面が閉じれてなかったのを修正 +・Radeonで描画ループ中にウィンドウを閉じた時にエラーになるのを回避（したつもり） + +MlibSample 1.0.0_beta_21 +・冗長ログで描画ループ時にOpenのエラーコードを出力追加 +・予期せぬエラーダイアログにOpenGLのエラーコードを出力追加 + +MlibSample 1.0.0_beta_22 +・UVモーフのY向き修正 +・ハイスペックモード追加 +　・ONにすると、CPU数/2の数だけ並列化ブロック生成 +・リファクタリング + +MlibSample 1.0.0_beta_23 +・光源の修正 +・メニューの下記値を次回起動時に引き継ぐよう機能追加 +　物理ON/OFF、ハイスペックモード + +MlibSample 1.0.0_beta_24 +・リファクタリングを撤回 +・UVモーフのY向き修正 +・光源の修正 +・IK計算見直し + ・冗長ログをONにしたときに、IK計算ログとIKデバッグ用モーションを出力するよう機能追加 + ※最初に再生してから冗長ログをONにしてください。逆だと読み込みに時間がエラいかかる… + モデルのファイルパス以下に IK_stepってフォルダを作成して、そこに出力 + +MlibSample 1.0.0_beta_25 +・DDS画像のデコード処理追加 +・物理演算パラ調整 +・親からの相対位置行列を求める時に親が無い場合に原点を渡していたのを、自分の位置を渡すよう修正 + +MlibSample 1.0.0_beta_26 +・IK計算見直し + ・白ワンピミクで足首がぐねりやすかったので、ジンバルロックの閾値を88.0に戻したら直った + +MlibSample 1.0.0_beta_27 +・IK計算見直し + ・リンクボーンに軸制限ある場合、事前に軸にそった理想回転量とする処理が抜けていたので追加 + +MlibSample 1.0.0_beta_28 +・IK計算ログ出力方法修正 + /IK_step/xxxxx.vmd, xxxxx.log + +MlibSample 1.0.0_beta_29 +・IK計算ログ改行追加 +・初期角度を求めた際に 1e-6 まで一致していたら抜けるよう修正 + +MlibSample 1.0.0_beta_30 +・パッケージ整理 +・ビルド時に prod / dev の環境を切り替えられるよう処理追加 +　・dev ではない場合、冗長ログ系選択肢そのものを出力しない +・IK冗長ログ追加 +　・選択肢として独立 +　・break条件時のログを追加 + +MlibSample 1.0.0_beta_31 +・IK計算見直し +　・回転角度の閾値を1e-7に厳格化 (MMDに準拠) +　・移動の閾値チェックをコメントアウト + ・IK計算時の回転量を最短回転固定（Shorten）にするよう修正 + +MlibSample 1.0.0_beta_34 +・内部処理をすべてOpenGL準拠で計算するよう修正 +・物理後ボーン対応 +・エッジ対応 +・ボーンデバッグを物理結果に沿って描画するよう修正 +・法線デバッグ追加 +・MSAA適用 +・β33でモーフが効かなくなっていたのを修正 +　・結果の保持が正しくなかった +・IK計算見直し +　・YZの軸制限に対応（でもまだ不完全かも） +・リファクタリング + +MlibSample 1.0.0_beta_35 +・IK計算見直し +　・前回と結果が同じだった場合に中断するフラグを復活 +　・X軸のみ軸制限がある場合に途中で結果を戻すよう判定追加 +　・Z軸の補正はsinで調整するよう修正（こっちの方がマシ） +・照明の向き修正 +・リファクタリング + +MlibSample 1.0.0_beta_36 +・ボーンデバッグ表示を種別で選べるよう機能追加 +・対象ボーン追加時の存在チェック追加 + +MlibSample 1.0.0_beta_37 +・エッジの法線取得方法修正 +・キーフレ再生時の計算方法修正 + +MlibSample 1.0.0_beta_38 +・物理の重力を10倍に + +MlibSample 1.0.0_beta_39 +・頂点モーフの並列割り当てをコメントアウト +・フレームドロップON/OFFの表記をONに修正 + +MlibSample 1.0.0_beta_41 +・デバッグログ追加 + +MlibSample 1.0.0_beta_42 +・1F以上描画が進んでいたら、前の時間を現在時間でUpdateするよう修正 +　（逆に時間が進んでない場合は前の時間を更新しないよう修正） + +MlibSample 1.0.0_beta_43 +・エッジ描画修正 +・ファイルを投入したタイミングで読み込む様処理変更 +・読み込んだ時に描画反映させるよう更新 +・描画ウィンドウで矢印キーを押下したときに左右に動くように（メニューウィンドウ側はキーの取得が難しかった） + +MlibSample 1.0.0_beta_44 +・再生中はリピートするよう機能変更 +・付与親が付与し続けられていたので修正（キーフレの回転自体に付与親の値をかけていた） + +MlibSample 1.0.0_beta_45 +・リファクタリング +　・キーフレにIK計算結果等を追加していたのを、変更データとして外に持って再生が過ぎたらメモリから破棄されるように +・フレームドロップOFFの時に最大0.0333だけ動くように + +MlibSample 1.0.0_beta_46 +・リファクタリング +　・頂点モーフとボーンモーフの生成をnilのリストからmapに変更 +　・画像を読み込んだ後、nilでGC対象に +　・描画ループ時に強制GC + +MlibSample 1.0.0_beta_47 +　・強制GC削除 +　・IKキーフレのON/OFFを参照してIK計算有無を決める + +MlibSample 1.0.0_beta_48 +・ログの出力先をコンソールに戻した +・IKのON/OFFの読み取りに失敗していたのを修正 +・頂点GLデータの生成を修正 +・他言語メッセージ追加 + +MlibSample 1.0.0_beta_49 +・vpdの読み込み追加 +・ジョイントのパラ調整 + +MlibSample 1.0.0_beta_50 +・FixedTimeStep = 1 / 60.0 に変更（これまでは 1/300） +・キーフレームの進捗を round で（これまでは切り捨て） + +MlibSample 1.0.0_beta_51 +・exeビルド時にエラーメッセージが出なくなっていたのを修正 +・頂点モーフの存在チェックでnilチェックが抜けていたのを修正 + +MlibSample 1.0.0_beta_52 +・キーフレの進み具合がおかしくなっていた（roundかけていた）のを修正 +・プレビュー描画時にちょっと処理が空いたときに shoudcloseチェックを行うよう処理追加 + +MlibSample 1.0.0_beta_53 +・SwapBuffers、PollEventsの前後にもshouldcloseチェック追加 + +MlibSample 1.0.0_beta_54 +・walkのメモリリーク改善 +　・boxLayout生成時にmapに使わないオブジェクトをkey-valueのvalueに入れていたので、struct{}に変更 +　・マップのキーをオブジェクト全体ではなく、小さなキーで持つように変更 +　・使い終わったら明示的にnil設定 +・Bulletの結果を受け取る btTransform を使い終わったらDeleteするよう修正 +・使い終わったら明示的にnil設定 + +MlibSample 1.0.0_beta_55 +・デバッグビルドの時に予期せぬエラーが発生した時のダイアログが出なくなっていたので判定追加 +　・スタックトレースの先頭に最終的なエラーメッセージも表示するよう追加 +・プレビューウィンドウを最小化したときに描画をスキップするよう処理追加 +　・フレームの進捗もスキップして、サイズを戻した時に再開する +・キーフレの進み具合をMMDにあわせた +　・キーフレへの加算時にint切り捨て加算していたのをfloat加算するよう修正（デフォーム時にint切り捨て） +・前のデフォームからフレーム(int)が増えてない場合、前のデフォーム結果を流用するよう修正 +・GCの強制解放コメントアウト + +MlibSample 1.0.0_beta_56 +・メモリリークリファクタリング +　・inverseしたbtTransformのdelete +　・getOpenGLでメモリから取得した mgl32.Mat4 への nil設定 + +MlibSample 1.0.0_beta_57 +・履歴ボタンを二回目に起動した時にエラーになる問題を修正 +　・履歴画面でOKの挙動をしたときにダイアログが破棄されているようなので、作り直す +・描画中にプレビューウィンドウを閉じた場合の挙動を修正 +　・drawingフラグを追加（windowが破棄されている時にループを抜ける検証条件としてglfw.Windowが使えないので、その外にフラグを持っておく） + +MlibSample 1.0.0_beta_58 +・プレビューウィンドウを閉じた時にメインウィンドウまで閉じる処理をコメントアウト + +MlibSample 1.0.0_beta_59 +・プレビューウィンドウを閉じて描画ループを抜けた後、ウィンドウのクローズ処理が二重に走っていたのを削除 + +MlibSample 1.0.0_beta_60 +・Close処理時にメインウィンドうも終了してアプリを終了させるよう修正 + +MlibSample 1.0.0_beta_61 +・IK計算変更 +　・IK計算中にIKターゲットにIK計算量を加算していくよう処理追加 +・プレビューで再生中に一時停止して前に戻ったときにフレーム数のカウントが出来なくなっていたのを修正 +・プレビューで一時停止したときに前キーフレの値を保持できてなかったので修正 + +MlibSample 1.0.0_beta_62 +・IK計算変更 +　・角度制限時の軸方向の制限処理を追加 +　・角度制限の計算方法を修正 +　・残存回転処理を削除 + +MlibSample 1.0.0_beta_63 +・プレビューで再生中に最後のフレームに行った時に前のフレームの値をクリアしておらず、リピート出来ていなかったのを修正 +・材質モーフでテクスチャ係数などがnilになる場合があったのを修正 + +MlibSample 1.0.0_beta_64 +・モーフ係数のlerpでtを整数計算していて小数点以下が切り捨てられていたのを修正 +・単位角制限でループを回す毎に制限を緩くしていく処理を復活 +　・MMDのIK処理にあったけど意味が分かんなかったのでコメントアウトしてた +・一段IKの場合、回転軸を制限された軸ではなく、外積で求めた軸そのものに対してクォータニオンを生成し、そのクォータニオンを行列に変換して軸制限を行うよう処理変更 +　・テストの精度はあがったけど、採用するかは要検討 + +MlibSample 1.0.0_beta_65 +1. IKデバッグログの出力方法修正 +　・IKグループごとの処理順INDEXを追加(処理される順番にINDEXを振る) +2. 付与親の設定がされている場合、該当ボーンの回転や移動が許可されてなくても付与親の回転と移動は受け継ぐよう判定緩和 +3. 計算順を、自身の回転（IK回転を含む）→軸制限→付与親の回転の加算に修正 + +MlibSample 1.0.0_beta_66 +・一段IKで外積はあるけど内積が1.0の場合に単位角度分回すよう判定追加 +・移動付与親の時に付与親元に直接移動を加算していたので、コピーした値に加算するよう修正 + +MlibSample 1.0.0_beta_67 +・IK事前計算として、「つま先ＩＫ」の場合のみ先頭のリンクボーンの向き先をIKがOFFの時の向きに合わせるよう処理追加 +　・実際にMMDではつま先ＩＫの名前を変えても足首がぐねるので対処療法であることは認識済み +・ファイルピッカーの候補拡張子がmapで順不同になってしまうので、順番が固定になるよう修正 +・デフォーム時のモーフ変形量の持ち方修正 +　・モーフ変形量をキーフレに登録するのではなく、変化量として別途保持してそのまま渡すよう修正 +・物理後の付与親ありボーンが暴れていたのを修正 +　・物理後のボーン変形行列をデフォーム時に二重に加算していたのを修正 +　・デフォーム処理時にだけ二重加算していたので、前と同じフレームだと暴れなかった +・プレビューの60fps制限導入 +・床のライン描画 + +MlibSample 1.0.0_beta_68 +・IKボーンが物理後で物理前の計算時にエラーになる場合があるのを修正 +　・物理前後で計算対象を分けているので、物理前後のフラグが違うと計算対象ボーン情報が正確に取れない場合があった +・64の一段IKの軸制限なし条件を撤廃 +　・90度付近での挙動がMMDと違っている +・リファクタリング +　・キーフレ（補間曲線）の計算するのを、物理前もしくはデフォーム情報を持ってない場合に限定 +　・つま先IKの時だけ必要になるIK事前計算用デフォーム情報を、つま先IK条件に合致する時だけ取ってくるよう修正 +　・デフォーム対象ボーンリストの生成時に、ボーン名指定した場合に変形階層込みボーンINDEX順番リストを生成していたのを、 +　　モデル全体のボーン変形順番INDEXから該当するボーンINDEXをピックアップする方法に変更 + +MlibSample 1.0.0_beta_69 +・角度制限がある場合のローカル軸の計算で加算予定の回転角度を加味するよう修正 +　・beta63 で入ってた処理を復活(二重に回転角度かける事になるから要らないはずなんだけど…) + +MlibSample 1.0.0_beta_70 +・69の変更を取り消し +・材質モーフの適用を全面的に見直し +・ボーンモーフがIKのリンクボーンに含まれている場合、IK計算時の初回で加算するよう修正 +・材質モーフなどで存在しないINDEXが入っていた場合にスルーするよう修正（抜けありそう） +・リファクタリング +　・メソッド名とか整理 + +MlibSample 1.0.0_beta_71 +・エッジの加算モーフを掛けていたのを足し算に修正 + +MlibSample 1.0.0_beta_72 +・単位ベクトルの定義そのものの値を変えていて次の時に値が変わってしまっていたのを修正 +　・同じモデルでも読み込みの奇数回と偶数回で結果が違っていたことの対応 + +MlibSample 1.0.0_beta_73 +・移動と回転の値を取ってくるとき、移動FLGと回転FLGの参照を行わないよう判定削除 + +MlibSample 1.0.0_beta_74 +・一段IKかつ88度以下の場合は β64 の軸制限撤廃判定復活 +　・90度付近のフリップをMMDと合わせる為、88度以上は軸制限をかけてみる +・軸制限ボーンの判定を二箇所でやっているのを、片方だけにしたパターン + +MlibSample 1.0.0_beta_75 +・（IKの角度制限ではなく）軸制限ありボーンの軸制限処理を、クォータニオンを求める前と求める後の二箇所で行っていたのを、最後に行うようにだけ修正 +・ワイヤーフレーム描画機能追加 +・マウスクリック時に近い頂点およびボーンを検出して(とりあえず)デバッグログに出す機能追加 + +MlibSample 1.0.0_beta_76 +・位置マッピングのセットアップ場所変更（GUI専用に） +・リファクタリング +　・グローバル位置の取得をデフォーム情報計算時ではなく、呼び出された時にグローバル行列から計算するよう変更 + +MlibSample 1.0.0_beta_77 +・剛体/ジョイントデバッグ +　・深度テストをメソッド内は無効にするよう修正 + +MlibSample 1.0.0_beta_78 +・ボーンデバッグ +　・全ボーン表示とそれ以外で切り替えられるよう処理追加（例: IK→全を選んだ時にIKがOFFになるように） +・剛体デバッグ +　・前面と埋め込みを切り替えられるよう分岐追加 +・リファクタリング +　・モデル初期化時の頂点なめるトコとか並列化 +　・IK計算をグループごとに並列化 + +MlibSample 1.0.0_beta_79 +・物理演算OFF時に演算が回るようになっていたので判定追加 + +MlibSample 1.0.0_beta_80 +・OpenGLウィンドウとwalkコントローラーウィンドウの並列化処理を修正 +・情報表示機能追加（タイトル部分にfps追記） +・fps制限変更機能追加 + +MlibSample 1.0.0_beta_81 +・毎回デフォームが入っていたのを修正 +　・モデルとモーションの描画時の持ち方を変えたときに参照切れてた +・0番目の材質に対する材質モーフが無効になっていたのを修正 +　・材質Indexの切り分けで > 0 になってた +・fpsの描画を1秒おきに修正 +・描画ループをfps制限時にsleepではなく、最初の方で指定spfに足りるまでcontinueするよう修正 +・エッジ描画時にほぼ透明な場合には描画処理をスキップするよう修正 +・gcflagsありで試したら描画速度が半減したのでコメントからも削除 +・Pmx出力処理追加 +　・関数名とか修正 +・ジョイントのバネ回転制限値を設定する時にラジアンで読み込んでいたので、Pmx読み込み時にもラジアンで設定するよう修正 + +MlibSample 1.0.0_beta_82 +・モデルとモーション描画情報の置き換え時にデフォームフラグを強制的にONにするよう修正 + +MlibSample 1.0.0_beta_83 +・モデルとモーションの描画情報の持ち方を修正 +　・OpenGL描画スレッドで初期化・削除するために、「次のモデル」「次のモーション」として定義 +　・walkスレッドでの描画オブジェクトの削除処理を削除して、OpenGL側で削除するよう修正 +　・IsDeformフラグ削除 +　・isSaveDeltaフラグ追加：前回デフォーム結果を保持するか否か。再生中は保持しない + +MlibSample 1.0.0_beta_84 +・ドロップOFFの時、経過時間の最大値を 30fps までとするよう修正 +・glfw.PollEvents()をすべてのループの最初に行うよう修正 +・w.MakeContextCurrent()の位置をメインループ開始前に実行するよう修正 +・1フレームの時間が経過していない場合は待機するときにglfw.WaitEventsTimeoutを使用 +・Pmxなどのファイルからの読み込みが完了したタイミングでGCを強制実行するよう処理追加 + +MlibSample 1.0.0_beta_85 +・ウィンドウが閉じられているかのイベント判定処理修正 +　・glfw.PollEvents()の後に !w.IsRunning() +・描画ループが終わった後に terminate を実行 +・ワイヤーフレーム、法線、頂点ハイライトのシェーダーを統一 +・ワイヤーフレームを材質非表示時に表示しないようにする対応追加（mlibSampleには入ってません） +・選択頂点ハイライト機能追加 +・プレビューウィンドウの最接近視野角調整（5 -> 3 まで近づけられる） +・外からワイヤーフレーム、頂点選択をONにできるように + +MlibSample 1.0.0_beta_86 +・物理リセットをwalkウィンドウからはトリガー設定だけに修正（GL描画内でリセット実行） +・物理リセットの挙動を変更 +　・物理OFF +　・物理剛体の形状を物理OFF時の状態に更新 +　・物理ON +　【課題】 +　　・ONがワンテンポ遅れる +　　・たまに一部の頂点が戻ってこない（もう一度リセットすると戻る） + +MlibSample 1.0.0_beta_87 +・GLウィンドウからwalkウィンドウの再生フレームを更新する時に別スレッドを立ち上げて更新するよう修正 +・fps情報はオリジナルの経過時間を使って表示するよう修正 +・再生時に毎回デフォーム情報を破棄していたのを、キーフレが前と違う場合のみ破棄するよう修正 + +MlibSample 1.0.0_beta_88 +・物理演算結果の受け取り時にループ内で全ボーンの再計算を行っていたので、最後に物理ボーンだけ再計算するよう修正 + +MlibSample 1.0.0_beta_89 +・clamp時に元の数値を変えていたので元は触らないよう修正 +　・フレームドロップOFFの時のfps表示バグ +・物理リセット時にボーン追従剛体と同じルート＆強制計算するよう修正 +・1体目のモデルを読み込んだ後に2体目を読み込んで、その後に物理リセットするとクラッシュするのを修正 +　・BulletのJoint設定をすべて削除していたのでモデルごとに管理するよう修正 + +MlibSample 1.0.0_beta_90 +・MaxSubSteps=2に修正 +・物理fps(timeStep)計測修正 +　・デフォームfpsとは別に作成 +　・FPS制限なしの場合、オリジナルの経過時間をそのまま使う +　・FPS制限ありの場合は指定fpsを使う +　・情報表示も上記値を使うよう修正 +・物理ONの時だけリセット処理を行うよう修正 +・フレームドロップON→無制限→物理が動かなくなる不具合の修正 +　・フレームドロップONの時の条件式で無制限の時に timeStepが -1 になっていた +・FPS制限のチェックがすべて外れたら、デフォルト30fpsをチェックさせるよう修正 + +MlibSample 1.0.0_beta_91 +・MIPMAPの定義を追加 +・物理のデバッグ表示を描画ループの最後にまとめておこなうよう修正 + +MlibSample 1.0.0_beta_92 +・GenerateMipmapを追加 +・頂点選択機能で物理後からも選べるよう修正 +　・選択時のメッセージをINFOに変更 + +MlibSample 1.0.0_beta_93 +・GenerateMipmapがRadeonだと使えない？（go-glで未対応かも？）ので削除 +・頂点選択機能でBDEF系の選択時にボーン変形行列を加味してなかったので修正 + +MlibSample 1.0.0_beta_94 +・頂点選択、ボーン選択機能で近接の判定が「マウスクリックワールド座標」からの距離となっていたので、「（変形後の）直近頂点/ボーンからの距離」とするよう修正 + +MlibSample 1.0.0_beta_95 +・選択頂点ハイライト機能が有効な時のみ頂点位置取得処理を動かすよう修正 +・選択頂点機能が有効になっていても、頂点/ボーンがとれなかった場合に処理をスルーする判定追加（スルー後の対応はユースケースの責務） + +MlibSample 1.0.0_beta_96 +・FPSの表示を開発版とリリース版で変更 +　・開発版：デフォームFPS/物理FPSで表示 +　・リリース版：無制限の場合、物理FPS。制限ありの場合、デフォームFPS + +MlibSample 1.0.0_beta_97 +・ミップマップをかけるため、gl.TEXTURE_MAX_LEVELをコメントアウト + +MlibSample 1.0.0_beta_98 +・材質の描画用素材を用意するときに名前ベースで個数をカウントしていたため、材質名の重複があるとオーバーフローエラーになっていたのを修正 +・テクスチャサイズが2のべき乗でない場合にミップマップをかけないよう修正 +　・ミップマップのONOFFでバインド時のフラグ切り替え +　・該当時に警告メッセージ表示（警告出すとビックリされる時もあるので悩ましい…） +・Toonにミップマップをかけないよう修正 + +MlibSample 1.0.0_beta_99 +・頂点モーフが「値が0でなかった場合」にのみ更新をかけていたのを、VMDで指定されたモーフがあれば更新するよう修正 +・ミップマップ生成失敗時のログをデバッグログに修正 + +MlibSample 1.0.0_beta_100 +・リソースファイル整理 +　・動作に影響はないはず +・モーション再生ウィジェットの数値欄調整 +　・入力欄で常に末尾に数字が追加されるように（機能が多くて下手に弄れなかった…） +　・数字の上下用ボタンとかレイアウト調整 +・glWindow.isSaveDelta削除 +・物理デバッグ表示をMSAAの終了後に移動 +・床にXYZのライン追加 +・システム上のすべての論理プロセッサを使用させる +・ワイヤーフレーム描画をポリゴンモードの変更で対応するよう修正 + +MlibSample 1.0.0_beta_101 +・glWindow.isSaveDeltaを復活 +　・walkウィンドウのスライダーを動かした時などにデフォームがスルーされる事がある（並列化の影響） +・頂点デルタ情報の差分受け渡し方法修正 +　・頂点分の空配列を作成せずに、必要な量だけ生成するよう修正 +・ボーンデルタのデータの持ち方を変更 +　・最初にモデルのボーン数分の空の配列を用意するよう修正 +・デフォームfps無制限モード追加 + +MlibSample 1.0.0_beta_102 +・fps整理 +　・デフォームfps ... ドロップOFF: fps制限値を上限とする経過時間、ドロップON: 経過時間 +　・物理fps ... ドロップOFF: 60固定、ドロップON: 60fps上限の経過時間 +　・描画fps ... fps制限に応じて描画を更新する + +MlibSample 1.0.0_beta_103 +・Ikデバッグログ +　・IKOFFモーションの出力 +　・ブレイク条件ログの追加 +・GLスレッド内のisSaveDelta = false を削除（自分のスレッド内なのでprevDeltasを直接クリアで対応） +・デフォーム時にデルタがある場合のみ変形情報を出力するよう修正 +・VMD出力にIK ON/OFFとか追加 + +MlibSample 1.0.0_beta_104 +・IK計算の閾値を 1e-5 まであげてみた（モーションテストの 0.03 まではクリア） + +MlibSample 1.0.0_beta_105 +・pmxのDataの持ち方をmapからスライスに変更 +・boneDeltasのmutexを削除（スライスに変更したことで不要になった） +・Lengthの処理を他と統一してmglを呼び出すように +・物理後のローカル行列生成処理が間違っていたので修正（INDEXの順番が担保されてなかった） +・物理後ボーンの挙動がおかしくなっていた（スライスに変えた時？）ので修正 +　・物理演算後の移動を受け取ると逆オフセットかけても一部モデルで破綻するのでここだけ一旦コメントアウト +　・回転の受け取りは大丈夫そう +　・要確認: 付与親で移動と回転の両方がONになっていた場合の挙動 + +MlibSample 1.0.0_beta_106 +・再生ウィジェット側でフレーム数を変えた時に反応しない時がある問題に対応 +　・並列処理でGLウィンドウ側のフレーム番号を更新 +　・フレーム番号更新時に SaveDelta = false を設定 +・IK計算時に付与親の値が変わったときに反映できてなかったのを修正 + +MlibSample 1.0.0_beta_107 +・append関数追加（頂点追加等用） +・頂点の取得時に表示材質からのみ選べるよう引数追加 +・剛体の更新と結果取得を必要なものだけに限定 +・剛体のサイズはマイナスを許容しない（絶対値で取得する） +・物理後IKが反映されるよう整理 + ・デフォーム計算時に物理後ボーンの親が物理前だった場合に取れてない場合があったのを修正 + ・物理後デフォーム計算で物理前ボーンが親だったときに正常に計算ができない場合があったのを修正 + ・物理後フラグが立っているボーンに紐付く物理剛体が取れてなかったのを修正 +・編集後モデルの再セットアップの調整 +・モデル構造セットアップタイミング修正 +・ボーンデフォーム対象リスト用ボーンリストをmapで持つよう修正（存在有無チェックが多いため） +・システム通知音発生処理追加 + +MlibSample 1.0.0_beta_108 +・MQuaternion.MuledScaler で1.0が指定された場合に、変化後のクォータニオンをそのまま返すよう修正（slerpは不要） +・1ボーンだけ指定した場合に、関連ボーンを変形階層を加味した順番で取得する処理をモデルセットアップ時に行うよう修正 +　・これで、描画時の全ボーンと1ボーンはほぼ計算不要。複数のボーンを加味する場合のみ、boneDeltas内で判定計算する +・付与親のマイナス補正が効いてなかったので修正 +　・slerpなので＋値しか有効になってなかった +　・絶対値のslerpを inverse するよう修正 +・物理をOFFにしたときに重さが変わらない +・再生後に止めた後の動きが重い（0Fの再生前の時と操作感が違う） +　→　デフォームがちょっと速くなったので体感速度が変わるようになった + +MlibSample 1.0.0_beta_109 +・剛体Bがボーン追従剛体だった場合にのみ、ジョイントのバネ値を設定しないよう変更 +・モデルが変わっている場合は最新の情報を取得する判定の時に不要な描画初期化判定が入っていたので、必要な箇所に移動 +・再生ループの時に物理リセットする +・ファイルピッカーでファイルを明示的に取得する場合（GetData）、キャッシュを参照しないよう変更 +　・モデルを読み込んだ後にモーションを読み込んだ場合などはキャッシュを流用 +・デフォームと描画の順番を整理 +　・物理前デフォーム…複数モデルを並列処理 +　・StepSimulation +　・物理後デフォーム…複数モデルを並列処理 +　・描画…複数モデルを直列処理 +・出力パス生成ユーティリティメソッド追加 +・モデル入替時の処理修正 +　・描画初期化タイミング +　・物理をワールドから削除したときに、辞書からも削除（物理の少ないモデルから多いモデルとかに入れ替えた後に物理リセットすると落ちた） + +MlibSample 1.0.0_beta_110 +・Beepライブラリ取得タイミング調整 +・ビューワー矩形選択機能追加（まだ何か判定が変…） +・ファイルを指定しなかった場合にモデル名欄に「未設定」を設定するよう修正 +・デルタ情報がなかった場合に描画をスキップするよう修正（次で描画される） +・キーフレコピー処理でnilチェックが抜けていたのを修正 +・IKリンクの無限ループを避けるよう修正 + +MlibSample 1.0.0_beta_111 +・モデルを読み込んだ時に物理リセットするよう処理追加 + + + + +TODO: +・バリデーション系の追加 +・剛体、ジョイントサイズのマイナスチェック + + diff --git a/cmd/app/app.ico b/cmd/app/app.ico new file mode 100644 index 00000000..dc159457 Binary files /dev/null and b/cmd/app/app.ico differ diff --git a/cmd/app/app.png b/cmd/app/app.png new file mode 100644 index 00000000..b2e3cb07 Binary files /dev/null and b/cmd/app/app.png differ diff --git a/cmd/app/app.rc b/cmd/app/app.rc new file mode 100644 index 00000000..bd7d7ac6 --- /dev/null +++ b/cmd/app/app.rc @@ -0,0 +1,2 @@ +// app.rc +IDI_ICON1 ICON DISCARDABLE "app.ico" \ No newline at end of file diff --git a/cmd/app/app.res b/cmd/app/app.res new file mode 100644 index 00000000..72b4547e Binary files /dev/null and b/cmd/app/app.res differ diff --git a/cmd/app/app_config.json b/cmd/app/app_config.json new file mode 100644 index 00000000..3d13fd8b --- /dev/null +++ b/cmd/app/app_config.json @@ -0,0 +1,4 @@ +{ + "Name": "MlibSample", + "Version": "1.0.0_beta_110" +} \ No newline at end of file diff --git a/cmd/app/main.manifest b/cmd/app/main.manifest new file mode 100644 index 00000000..d36b7713 --- /dev/null +++ b/cmd/app/main.manifest @@ -0,0 +1,15 @@ + + + + + + + + + + + PerMonitorV2, PerMonitor + True + + + diff --git a/cmd/app/rsrc.syso b/cmd/app/rsrc.syso new file mode 100644 index 00000000..c1837d4f Binary files /dev/null and b/cmd/app/rsrc.syso differ diff --git a/cmd/i18n/app.en.json b/cmd/i18n/app.en.json new file mode 100644 index 00000000..ffd7c0cf --- /dev/null +++ b/cmd/i18n/app.en.json @@ -0,0 +1,42 @@ +[ + { + "id": "Pmxファイルを選択してください", + "translation": "Please select a PMX file" + }, + { + "id": "Vmdファイルを選択してください", + "translation": "Please select a VMD file" + }, + { + "id": "出力Pmxファイル", + "translation": "Output PMX file" + }, + { + "id": "出力Pmxファイルパスを入力もしくは選択してください", + "translation": "Please enter or select the output PMX file path" + }, + { + "id": "出力Pmxファイルピッカー生成エラー", + "translation": "Error generating output PMX file picker" + }, + { + "id": "Pmxファイルの使い方", + "translation": "・You can set the Pmx model to be displayed in the viewer\n・You can select the text in the model name field\n・When a Pmx file is specified, the 'play' button becomes clickable" + }, + { + "id": "Vmdファイルの使い方", + "translation": "・You can set the Vmd motion to be applied to the Pmx model displayed in the viewer\n・You can select the text in the model name field\n・If not specified, the model will be displayed in the default pose" + }, + { + "id": "出力Pmxファイルの使い方", + "translation": "・You can enter or select the destination for the output Pmx file after adjustment\n・A value is set by default, but it can be changed to any path" + }, + { + "id": "&サンプルメニュー", + "translation": "&Sample Menu" + }, + { + "id": "サンプルヘルプ", + "translation": "Sample help message\nSample help message\nSample help message\nSample help message\nSample help message" + } +] \ No newline at end of file diff --git a/cmd/i18n/app.ja.json b/cmd/i18n/app.ja.json new file mode 100644 index 00000000..765f37a1 --- /dev/null +++ b/cmd/i18n/app.ja.json @@ -0,0 +1,42 @@ +[ + { + "id": "Pmxファイルを選択してください", + "translation": "Pmxファイルを選択してください" + }, + { + "id": "Vmdファイルを選択してください", + "translation": "Vmdファイルを選択してください" + }, + { + "id": "出力Pmxファイル", + "translation": "出力Pmxファイル" + }, + { + "id": "出力Pmxファイルパスを入力もしくは選択してください", + "translation": "出力Pmxファイルパスを入力もしくは選択してください" + }, + { + "id": "出力Pmxファイルピッカー生成エラー", + "translation": "出力Pmxファイルピッカー生成エラー" + }, + { + "id": "Pmxファイルの使い方", + "translation": "・ビューワーで表示するPmxモデルを設定できます\n・モデル名欄の文字列は選択することが出来ます\n・Pmxファイルを指定すると、「再生」ボタンがクリックできるようになります" + }, + { + "id": "Vmdファイルの使い方", + "translation": "・ビューワーで表示するPmxモデルに適用するVmdモーションを設定できます\n・モデル名欄の文字列は選択することが出来ます\n・指定しなかった場合、モデルは初期姿勢で表示されます" + }, + { + "id": "出力Pmxファイルの使い方", + "translation": "・調整後のPmxファイルを出力させる先を入力もしくは選択できます\n・デフォルトで値が設定されますが、任意のパスに変更することも可能です" + }, + { + "id": "&サンプルメニュー", + "translation": "&サンプルメニュー" + }, + { + "id": "サンプルヘルプ", + "translation": "サンプルヘルプのメッセージ\nサンプルヘルプのメッセージ\nサンプルヘルプのメッセージ\nサンプルヘルプのメッセージ\nサンプルヘルプのメッセージ" + } +] \ No newline at end of file diff --git a/cmd/i18n/app.ko.json b/cmd/i18n/app.ko.json new file mode 100644 index 00000000..12bfebac --- /dev/null +++ b/cmd/i18n/app.ko.json @@ -0,0 +1,42 @@ +[ + { + "id": "Pmxファイルを選択してください", + "translation": "PMX 파일을 선택해주세요" + }, + { + "id": "Vmdファイルを選択してください", + "translation": "VMD 파일을 선택해주세요" + }, + { + "id": "出力Pmxファイル", + "translation": "출력 PMX 파일" + }, + { + "id": "出力Pmxファイルパスを入力もしくは選択してください", + "translation": "출력 PMX 파일 경로를 입력하거나 선택해주세요" + }, + { + "id": "出力Pmxファイルピッカー生成エラー", + "translation": "출력 PMX 파일 선택기 생성 오류" + }, + { + "id": "Pmxファイルの使い方", + "translation": "・뷰어에서 표시할 Pmx 모델을 설정할 수 있습니다\n・모델 이름 필드의 텍스트를 선택할 수 있습니다\n・Pmx 파일을 지정하면 '재생' 버튼을 클릭할 수 있습니다" + }, + { + "id": "Vmdファイルの使い方", + "translation": "・뷰어에 표시될 Pmx 모델에 적용할 Vmd 모션을 설정할 수 있습니다\n・모델 이름 필드의 텍스트를 선택할 수 있습니다\n・지정하지 않은 경우, 모델은 기본 포즈로 표시됩니다" + }, + { + "id": "出力Pmxファイルの使い方", + "translation": "・조정 후 Pmx 파일을 출력할 목적지를 입력하거나 선택할 수 있습니다\n・기본값이 설정되어 있지만, 원하는 경로로 변경할 수도 있습니다" + }, + { + "id": "&サンプルメニュー", + "translation": "&샘플 메뉴" + }, + { + "id": "サンプルヘルプ", + "translation": "샘플 도움말 메시지\n샘플 도움말 메시지\n샘플 도움말 메시지\n샘플 도움말 메시지\n샘플 도움말 메시지" + } +] \ No newline at end of file diff --git a/cmd/i18n/app.zh.json b/cmd/i18n/app.zh.json new file mode 100644 index 00000000..d0547578 --- /dev/null +++ b/cmd/i18n/app.zh.json @@ -0,0 +1,42 @@ +[ + { + "id": "Pmxファイルを選択してください", + "translation": "请选择PMX文件" + }, + { + "id": "Vmdファイルを選択してください", + "translation": "请选择VMD文件" + }, + { + "id": "出力Pmxファイル", + "translation": "输出PMX文件" + }, + { + "id": "出力Pmxファイルパスを入力もしくは選択してください", + "translation": "请输入或选择输出PMX文件路径" + }, + { + "id": "出力Pmxファイルピッカー生成エラー", + "translation": "生成输出PMX文件选择器时出错" + }, + { + "id": "Pmxファイルの使い方", + "translation": "・可以设置在查看器中显示的Pmx模型\n・可以选择模型名称字段中的文本\n・指定Pmx文件后，‘播放’按钮会变为可点击" + }, + { + "id": "Vmdファイルの使い方", + "translation": "・可以设置应用于查看器中显示的Pmx模型的Vmd动作\n・可以选择模型名称字段中的文本\n・如果未指定，模型将以默认姿势显示" + }, + { + "id": "出力Pmxファイルの使い方", + "translation": "・可以输入或选择调整后的Pmx文件的输出目的地\n・虽然默认设置了一个值，但也可以更改为任何路径" + }, + { + "id": "&サンプルメニュー", + "translation": "&样本菜单" + }, + { + "id": "サンプルヘルプ", + "translation": "示例帮助消息\n示例帮助消息\n示例帮助消息\n示例帮助消息\n示例帮助消息" + } +] \ No newline at end of file diff --git a/cmd/main.go b/cmd/main.go new file mode 100644 index 00000000..19e05734 --- /dev/null +++ b/cmd/main.go @@ -0,0 +1,301 @@ +//go:build windows +// +build windows + +package main + +import ( + "embed" + "fmt" + "log" + "path/filepath" + "runtime" + + "github.com/miu200521358/walk/pkg/declarative" + "github.com/miu200521358/walk/pkg/walk" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils" + "github.com/miu200521358/mlib_go/pkg/mutils/mconfig" + "github.com/miu200521358/mlib_go/pkg/mutils/mi18n" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" + "github.com/miu200521358/mlib_go/pkg/mwidget" + "github.com/miu200521358/mlib_go/pkg/pmx" + "github.com/miu200521358/mlib_go/pkg/vmd" +) + +var env string + +func init() { + runtime.LockOSThread() + + walk.AppendToWalkInit(func() { + walk.MustRegisterWindowClass(mwidget.FilePickerClass) + walk.MustRegisterWindowClass(mwidget.MotionPlayerClass) + walk.MustRegisterWindowClass(mwidget.ConsoleViewClass) + walk.MustRegisterWindowClass(mwidget.FixViewWidgetClass) + }) +} + +//go:embed app/* +var appFiles embed.FS + +//go:embed i18n/* +var appI18nFiles embed.FS + +func main() { + // defer profile.Start(profile.MemProfileHeap, profile.ProfilePath(time.Now().Format("20060102_150405"))).Stop() + // defer profile.Start(profile.MemProfile, profile.ProfilePath(time.Now().Format("20060102_150405"))).Stop() + // defer profile.Start(profile.CPUProfile, profile.ProfilePath(fmt.Sprintf("cpu_%s", time.Now().Format("20060102_150405")))).Stop() + // defer profile.Start(profile.CPUProfile, profile.ProfilePath(fmt.Sprintf("cpu_%s", time.Now().Format("20060102_150405")))).Stop() + + // システム上のすべての論理プロセッサを使用させる + runtime.GOMAXPROCS(runtime.NumCPU()) + + var mWindow *mwidget.MWindow + var err error + + appConfig := mconfig.LoadAppConfig(appFiles) + appConfig.Env = env + mi18n.Initialize(appI18nFiles) + + if appConfig.IsEnvProd() || appConfig.IsEnvDev() { + defer mwidget.RecoverFromPanic(mWindow) + } + + iconImg, err := mconfig.LoadIconFile(appFiles) + mwidget.CheckError(err, nil, mi18n.T("アイコン生成エラー")) + + glWindow, err := mwidget.NewGlWindow(512, 768, 0, iconImg, appConfig, nil, nil) + + go func() { + mWindow, err = mwidget.NewMWindow(512, 768, getMenuItems, iconImg, appConfig, true) + mwidget.CheckError(err, nil, mi18n.T("メインウィンドウ生成エラー")) + + motionPlayer, _, funcWorldPos := NewFileTabPage(mWindow) + + mwidget.CheckError(err, mWindow, mi18n.T("ビューワーウィンドウ生成エラー")) + mWindow.AddGlWindow(glWindow) + glWindow.SetFuncWorldPos(funcWorldPos) + glWindow.SetMotionPlayer(motionPlayer) + glWindow.SetTitle(fmt.Sprintf("%s %s", mWindow.Title(), mi18n.T("ビューワー"))) + + // コンソールはタブ外に表示 + mWindow.ConsoleView, err = mwidget.NewConsoleView(mWindow, 256, 30) + mwidget.CheckError(err, mWindow, mi18n.T("コンソール生成エラー")) + log.SetOutput(mWindow.ConsoleView) + + mWindow.AsFormBase().Closing().Attach(func(canceled *bool, reason walk.CloseReason) { + go func() { + mWindow.GetMainGlWindow().IsClosedChannel <- true + }() + mWindow.Close() + }) + + mWindow.Center() + mWindow.Run() + }() + + glWindow.Run() + defer glWindow.TriggerClose(glWindow.Window) +} + +func getMenuItems() []declarative.MenuItem { + return []declarative.MenuItem{ + declarative.Action{ + Text: mi18n.T("&サンプルメニュー"), + OnTriggered: func() { mlog.IL(mi18n.T("サンプルヘルプ")) }, + }, + } +} + +func NewFileTabPage(mWindow *mwidget.MWindow) (*mwidget.MotionPlayer, *mwidget.FixViewWidget, func(prevXprevYFrontPos, prevXprevYBackPos, prevXnowYFrontPos, prevXnowYBackPos, + nowXprevYFrontPos, nowXprevYBackPos, nowXnowYFrontPos, nowXnowYBackPos *mmath.MVec3, vmdDeltas []*vmd.VmdDeltas)) { + page, _ := mwidget.NewMTabPage(mWindow, mWindow.TabWidget, mi18n.T("ファイル")) + + page.SetLayout(walk.NewVBoxLayout()) + + pmxReadPicker, err := (mwidget.NewPmxReadFilePicker( + mWindow, + page, + "PmxPath", + mi18n.T("Pmxファイル"), + mi18n.T("Pmxファイルを選択してください"), + mi18n.T("Pmxファイルの使い方"), + func(path string) {})) + mwidget.CheckError(err, mWindow, mi18n.T("Pmxファイルピッカー生成エラー")) + + vmdReadPicker, err := (mwidget.NewVmdVpdReadFilePicker( + mWindow, + page, + "VmdPath", + mi18n.T("Vmdファイル"), + mi18n.T("Vmdファイルを選択してください"), + mi18n.T("Vmdファイルの使い方"), + func(path string) {})) + mwidget.CheckError(err, mWindow, mi18n.T("Vmdファイルピッカー生成エラー")) + + pmxSavePicker, err := (mwidget.NewPmxSaveFilePicker( + mWindow, + page, + mi18n.T("出力Pmxファイル"), + mi18n.T("出力Pmxファイルパスを入力もしくは選択してください"), + mi18n.T("出力Pmxファイルの使い方"), + func(path string) {})) + mwidget.CheckError(err, mWindow, mi18n.T("出力Pmxファイルピッカー生成エラー")) + + _, err = walk.NewVSeparator(page) + mwidget.CheckError(err, mWindow, mi18n.T("セパレータ生成エラー")) + + motionPlayer, err := mwidget.NewMotionPlayer(page, mWindow) + mwidget.CheckError(err, mWindow, mi18n.T("モーションプレイヤー生成エラー")) + motionPlayer.SetEnabled(false) + + // fixViewWidget, err := mwidget.NewFixViewWidget(page, mWindow) + // mwidget.CheckError(err, mWindow, mi18n.T("固定ビューウィジェット生成エラー")) + // fixViewWidget.SetEnabled(false) + + var onFilePathChanged = func() { + if motionPlayer.Playing() { + motionPlayer.Play(false) + } + enabled := pmxReadPicker.Exists() && vmdReadPicker.ExistsOrEmpty() + motionPlayer.SetEnabled(enabled) + // fixViewWidget.SetEnabled(enabled) + } + + pmxReadPicker.OnPathChanged = func(path string) { + isExist, err := mutils.ExistsFile(path) + if !isExist || err != nil { + pmxSavePicker.PathLineEdit.SetText("") + return + } + + dir, file := filepath.Split(path) + ext := filepath.Ext(file) + outputPath := filepath.Join(dir, file[:len(file)-len(ext)]+"_out"+ext) + pmxSavePicker.PathLineEdit.SetText(outputPath) + + if pmxReadPicker.Exists() { + data, err := pmxReadPicker.GetData() + if err != nil { + mlog.E(mi18n.T("Pmxファイル読み込みエラー"), err.Error()) + return + } + model := data.(*pmx.PmxModel) + var motion *vmd.VmdMotion + if vmdReadPicker.IsCached() { + motion = vmdReadPicker.GetCache().(*vmd.VmdMotion) + } else { + motion = vmd.NewVmdMotion("") + } + + motionPlayer.SetEnabled(true) + motionPlayer.SetValue(0) + + go func() { + mWindow.GetMainGlWindow().FrameChannel <- 0 + mWindow.GetMainGlWindow().IsPlayingChannel <- false + mWindow.GetMainGlWindow().ReplaceModelSetChannel <- map[int]*mwidget.ModelSet{0: {NextModel: model, NextMotion: motion}} + }() + } else { + go func() { + mWindow.GetMainGlWindow().RemoveModelSetIndexChannel <- 0 + }() + } + + onFilePathChanged() + } + + vmdReadPicker.OnPathChanged = func(path string) { + if vmdReadPicker.Exists() { + motionData, err := vmdReadPicker.GetData() + if err != nil { + mlog.E(mi18n.T("Vmdファイル読み込みエラー"), err.Error()) + return + } + motion := motionData.(*vmd.VmdMotion) + + motionPlayer.SetRange(0, motion.GetMaxFrame()+1) + motionPlayer.SetValue(0) + + if pmxReadPicker.Exists() { + motionPlayer.SetEnabled(true) + motionPlayer.SetValue(0) + + go func() { + mWindow.GetMainGlWindow().FrameChannel <- 0 + mWindow.GetMainGlWindow().IsPlayingChannel <- false + mWindow.GetMainGlWindow().ReplaceModelSetChannel <- map[int]*mwidget.ModelSet{0: {NextMotion: motion}} + }() + } else { + go func() { + mWindow.GetMainGlWindow().RemoveModelSetIndexChannel <- 0 + }() + } + } + + onFilePathChanged() + } + + motionPlayer.OnPlay = func(isPlaying bool) error { + if !isPlaying { + pmxReadPicker.SetEnabled(true) + vmdReadPicker.SetEnabled(true) + pmxSavePicker.SetEnabled(true) + } else { + pmxReadPicker.SetEnabled(false) + vmdReadPicker.SetEnabled(false) + pmxSavePicker.SetEnabled(false) + } + + motionPlayer.PlayButton.SetEnabled(true) + go func() { + mWindow.GetMainGlWindow().IsPlayingChannel <- isPlaying + }() + + return nil + } + + pmxReadPicker.PathLineEdit.SetFocus() + + funcWorldPos := func(prevXprevYFrontPos, prevXprevYBackPos, prevXnowYFrontPos, prevXnowYBackPos, + nowXprevYFrontPos, nowXprevYBackPos, nowXnowYFrontPos, nowXnowYBackPos *mmath.MVec3, vmdDeltas []*vmd.VmdDeltas) { + mlog.L() + + if pmxReadPicker.Exists() { + model := pmxReadPicker.GetCache().(*pmx.PmxModel) + var nearestVertexIndexes [][]int + // 直近頂点を取得 + if prevXnowYFrontPos == nil { + nearestVertexIndexes = vmdDeltas[0].Vertices.FindNearestVertexIndexes(prevXprevYFrontPos, nil) + } else { + nearestVertexIndexes = vmdDeltas[0].Vertices.FindVerticesInBox(prevXprevYFrontPos, prevXprevYBackPos, + prevXnowYFrontPos, prevXnowYBackPos, nowXprevYFrontPos, nowXprevYBackPos, nowXnowYFrontPos, + nowXnowYBackPos, nil) + } + + if len(nearestVertexIndexes) > 0 { + for _, vertexIndex := range nearestVertexIndexes { + vertex := model.Vertices.Get(vertexIndex[0]) + mlog.I("In Box Vertex: %d (元: %s)(変形: %s)", + vertex.Index, vertex.Position.String(), + vmdDeltas[0].Vertices.Get(vertex.Index).Position.String()) + } + go func() { + mWindow.GetMainGlWindow().ReplaceModelSetChannel <- map[int]*mwidget.ModelSet{0: {NextSelectedVertexIndexes: nearestVertexIndexes[0]}} + }() + } + + // // 大体近いボーンを取得 + // nearestBoneIndexes := vmdDeltas[0].Bones.GetNearestBoneIndexes(worldPos) + // for _, boneIndex := range nearestBoneIndexes { + // bone := model.Bones.Get(boneIndex) + // mlog.I("Near Bone: %d, %s (元: %s)(変形: %s)", + // bone.Index, bone.Name, bone.Position.String(), + // vmdDeltas[0].Bones.Get(bone.Index).GlobalPosition().String()) + // } + } + } + + return motionPlayer, nil, funcWorldPos +} diff --git a/crumb/profile.go b/crumb/profile.go new file mode 100644 index 00000000..d4176044 --- /dev/null +++ b/crumb/profile.go @@ -0,0 +1,43 @@ +package main + +import ( + "log" + + "github.com/miu200521358/mlib_go/pkg/pmx" + "github.com/miu200521358/mlib_go/pkg/vmd" + "github.com/pkg/profile" +) + +func main() { + defer profile.Start(profile.CPUProfile, profile.ProfilePath(".")).Stop() + // defer profile.Start(profile.MemProfile, profile.ProfilePath(".")).Stop() + + // -------------------------------------------- + + vr := &vmd.VmdMotionReader{} + motionData, err := vr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Motion/ダンス_1人/[A]ddiction_モーション hino/[A]ddiction_Lat式.vmd") + // motionData, err := vr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Motion/ダンス_1人/CH4NGE mobiusP/CH4NGE.vmd") + + if err != nil { + log.Fatalf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*vmd.VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/_VMDサイジング/mlibkiller/mlibkiller.pmx") + // modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/ISAO式ミク/I_ミクv4チャイナ/Miku_V4_チャイナ.pmx") + + if err != nil { + log.Fatalf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + for i := 0; i < 500; i++ { + if i%100 == 0 { + log.Printf("i: %d", i) + } + motion.BoneFrames.Deform(i, model, nil, true, nil, nil) + } +} diff --git a/go.mod b/go.mod index de73a1bb..8e6d9ebb 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,38 @@ module github.com/miu200521358/mlib_go -go 1.21.5 +go 1.22.4 + +require ( + github.com/ftrvxmtrx/tga v0.0.0-20150524081124-bd8e8d5be13a + github.com/go-gl/gl v0.0.0-20231021071112-07e5d0ea2e71 + github.com/go-gl/glfw/v3.3/glfw v0.0.0-20240118000515-a250818d05e3 + github.com/go-gl/mathgl v1.1.0 + github.com/miu200521358/dds v0.0.0 + github.com/miu200521358/walk v0.0.3 + github.com/miu200521358/win v0.0.1 + github.com/pkg/profile v1.7.0 + golang.org/x/image v0.15.0 + golang.org/x/text v0.14.0 +) + +require ( + github.com/felixge/fgprof v0.9.3 // indirect + github.com/google/pprof v0.0.0-20211214055906-6f57359322fd // indirect + golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect + golang.org/x/tools v0.15.0 // indirect +) + +require ( + github.com/jinzhu/copier v0.4.0 + github.com/nicksnyder/go-i18n/v2 v2.4.0 + github.com/petar/GoLLRB v0.0.0-20210522233825-ae3b015fd3e9 + golang.org/x/sys v0.14.0 + gonum.org/v1/gonum v0.15.0 + gopkg.in/Knetic/govaluate.v3 v3.0.0 // indirect +) + +replace github.com/miu200521358/walk => ../walk + +replace github.com/miu200521358/win => ../win + +replace github.com/miu200521358/dds => ../dds diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..a03526a6 --- /dev/null +++ b/go.sum @@ -0,0 +1,59 @@ +github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8= +github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/felixge/fgprof v0.9.3 h1:VvyZxILNuCiUCSXtPtYmmtGvb65nqXh2QFWc0Wpf2/g= +github.com/felixge/fgprof v0.9.3/go.mod h1:RdbpDgzqYVh/T9fPELJyV7EYJuHB55UTEULNun8eiPw= +github.com/ftrvxmtrx/tga v0.0.0-20150524081124-bd8e8d5be13a h1:eSqaRmdlZ9JsJ7JuWfDr3ym3monToXRczohBOL+heVQ= +github.com/ftrvxmtrx/tga v0.0.0-20150524081124-bd8e8d5be13a/go.mod h1:US5WvgEHtG+BvWNNs6gk937h0QL2g2x+r7RH8m3g80Y= +github.com/go-gl/gl v0.0.0-20231021071112-07e5d0ea2e71 h1:5BVwOaUSBTlVZowGO6VZGw2H/zl9nrd3eCZfYV+NfQA= +github.com/go-gl/gl v0.0.0-20231021071112-07e5d0ea2e71/go.mod h1:9YTyiznxEY1fVinfM7RvRcjRHbw2xLBJ3AAGIT0I4Nw= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20240118000515-a250818d05e3 h1:nanQfMsOs3gnuKRm0E5jXWomedE/9YIFXdmHJNZYeqc= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20240118000515-a250818d05e3/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gl/mathgl v1.1.0 h1:0lzZ+rntPX3/oGrDzYGdowSLC2ky8Osirvf5uAwfIEA= +github.com/go-gl/mathgl v1.1.0/go.mod h1:yhpkQzEiH9yPyxDUGzkmgScbaBVlhC06qodikEM0ZwQ= +github.com/google/pprof v0.0.0-20211214055906-6f57359322fd h1:1FjCyPC+syAzJ5/2S8fqdZK1R22vvA0J7JZKcuOIQ7Y= +github.com/google/pprof v0.0.0-20211214055906-6f57359322fd/go.mod h1:KgnwoLYCZ8IQu3XUZ8Nc/bM9CCZFOyjUNOSygVozoDg= +github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w= +github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8= +github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg= +github.com/nicksnyder/go-i18n/v2 v2.4.0 h1:3IcvPOAvnCKwNm0TB0dLDTuawWEj+ax/RERNC+diLMM= +github.com/nicksnyder/go-i18n/v2 v2.4.0/go.mod h1:nxYSZE9M0bf3Y70gPQjN9ha7XNHX7gMc814+6wVyEI4= +github.com/petar/GoLLRB v0.0.0-20210522233825-ae3b015fd3e9 h1:1/WtZae0yGtPq+TI6+Tv1WTxkukpXeMlviSxvL7SRgk= +github.com/petar/GoLLRB v0.0.0-20210522233825-ae3b015fd3e9/go.mod h1:x3N5drFsm2uilKKuuYo6LdyD8vZAW55sH/9w+pbo1sw= +github.com/pkg/profile v1.7.0 h1:hnbDkaNWPCLMO9wGLdBFTIZvzDrDfBM2072E1S9gJkA= +github.com/pkg/profile v1.7.0/go.mod h1:8Uer0jas47ZQMJ7VD+OHknK4YDY07LPUC6dEvqDjvNo= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= +golang.org/x/image v0.0.0-20190321063152-3fc05d484e9f/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.15.0 h1:kOELfmgrmJlw4Cdb7g/QGuB3CvDrXbqEIww/pNtNBm8= +golang.org/x/image v0.15.0/go.mod h1:HUYqC05R2ZcZ3ejNQsIHQDQiwWM4JBqmm6MKANTp4LE= +golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q= +golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/tools v0.15.0 h1:zdAyfUGbYmuVokhzVmghFl2ZJh5QhcfebBgmVPFYA+8= +golang.org/x/tools v0.15.0/go.mod h1:hpksKq4dtpQWS1uQ61JkdqWM3LscIS6Slf+VVkm+wQk= +gonum.org/v1/gonum v0.15.0 h1:2lYxjRbTYyxkJxlhC+LvJIx3SsANPdRybu1tGj9/OrQ= +gonum.org/v1/gonum v0.15.0/go.mod h1:xzZVBJBtS+Mz4q0Yl2LJTk+OxOg4jiXZ7qBoM0uISGo= +gopkg.in/Knetic/govaluate.v3 v3.0.0 h1:18mUyIt4ZlRlFZAAfVetz4/rzlJs9yhN+U02F4u1AOc= +gopkg.in/Knetic/govaluate.v3 v3.0.0/go.mod h1:csKLBORsPbafmSCGTEh3U7Ozmsuq8ZSIlKk1bcqph0E= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/mcore/hash_model.go b/pkg/mcore/hash_model.go new file mode 100644 index 00000000..2eeed519 --- /dev/null +++ b/pkg/mcore/hash_model.go @@ -0,0 +1,59 @@ +package mcore + +type IHashModel interface { + GetName() string + SetName(name string) + IsNotEmpty() bool + IsEmpty() bool + GetHash() string + GetPath() string + SetPath(path string) + Delete() +} + +type HashModel struct { + Path string + Hash string +} + +func NewHashModel(path string) *HashModel { + return &HashModel{ + Path: path, + Hash: "", + } +} + +func (m *HashModel) GetPath() string { + return m.Path +} + +func (m *HashModel) SetPath(path string) { + m.Path = path +} + +func (m *HashModel) GetName() string { + // モデル内の名前に相当する値を返す + panic("not implemented") +} + +func (m *HashModel) SetName(name string) { + // モデル内の名前に相当する値を設定する + panic("not implemented") +} + +func (m *HashModel) GetHash() string { + return m.Hash +} + +func (m *HashModel) IsNotEmpty() bool { + // パスが定義されていたら、中身入り + return len(m.Path) > 0 +} + +func (m *HashModel) IsEmpty() bool { + // パスが定義されていなかったら、空 + return len(m.Path) == 0 +} + +func (m *HashModel) Delete() { +} diff --git a/pkg/mcore/index_model.go b/pkg/mcore/index_model.go new file mode 100644 index 00000000..f648e9e8 --- /dev/null +++ b/pkg/mcore/index_model.go @@ -0,0 +1,99 @@ +package mcore + +import ( + "reflect" + + "github.com/jinzhu/copier" +) + +type IIndexModel interface { + IsValid() bool + Copy() IIndexModel + GetIndex() int + SetIndex(index int) +} + +// INDEXを持つ基底クラス +type IndexModel struct { + Index int +} + +func (v *IndexModel) GetIndex() int { + return v.Index +} + +func (v *IndexModel) SetIndex(index int) { + v.Index = index +} + +func (v *IndexModel) IsValid() bool { + return v != nil && v.GetIndex() >= 0 +} + +func (v *IndexModel) Copy() IIndexModel { + copied := IndexModel{Index: v.Index} + copier.CopyWithOption(copied, v, copier.Option{DeepCopy: true}) + return &copied +} + +// Tのリスト基底クラス +type IndexModels[T IIndexModel] struct { + Data []T + nilFunc func() T + isDirty bool +} + +func NewIndexModels[T IIndexModel](count int, nilFunc func() T) *IndexModels[T] { + return &IndexModels[T]{ + Data: make([]T, count), + nilFunc: nilFunc, + } +} + +func (c *IndexModels[T]) Get(index int) T { + if index < 0 || index >= len(c.Data) { + return c.nilFunc() + } + + return c.Data[index] +} + +func (c *IndexModels[T]) SetItem(index int, v T) { + c.Data[index] = v +} + +func (c *IndexModels[T]) Update(value T) { + if value.GetIndex() < 0 { + value.SetIndex(len(c.Data)) + } + c.Data[value.GetIndex()] = value + c.SetDirty(true) +} + +func (c *IndexModels[T]) Append(value T) { + if value.GetIndex() < 0 { + value.SetIndex(len(c.Data)) + } + c.Data = append(c.Data, value) + c.SetDirty(true) +} + +func (c *IndexModels[T]) DeleteItem(index int) { + c.Data[index] = c.nilFunc() +} + +func (c *IndexModels[T]) Len() int { + return len(c.Data) +} + +func (c *IndexModels[T]) Contains(key int) bool { + return c != nil && key >= 0 && key < len(c.Data) && !reflect.ValueOf(c.Data[key]).IsNil() +} + +func (c *IndexModels[T]) IsDirty() bool { + return c.isDirty +} + +func (c *IndexModels[T]) SetDirty(dirty bool) { + c.isDirty = dirty +} diff --git a/pkg/mcore/index_model_test.go b/pkg/mcore/index_model_test.go new file mode 100644 index 00000000..aa565e9b --- /dev/null +++ b/pkg/mcore/index_model_test.go @@ -0,0 +1,166 @@ +package mcore + +import ( + "testing" +) + +func TestIndexModel_GetIndex(t *testing.T) { + model := &IndexModel{Index: 5} + index := model.GetIndex() + if index != 5 { + t.Errorf("Expected index to be 5, but got %d", index) + } +} + +func TestIndexModel_SetIndex(t *testing.T) { + model := &IndexModel{} + model.SetIndex(10) + if model.Index != 10 { + t.Errorf("Expected index to be 10, but got %d", model.Index) + } +} + +func TestIndexModel_IsValid(t *testing.T) { + model := &IndexModel{Index: 3} + valid := model.IsValid() + if !valid { + t.Error("Expected IsValid to return true, but got false") + } + + model.SetIndex(-1) + valid = model.IsValid() + if valid { + t.Error("Expected IsValid to return false, but got true") + } +} + +func TestIndexModel_Copy(t *testing.T) { + model := &IndexModel{Index: 7} + copied := model.Copy().(*IndexModel) + if copied.Index != 7 { + t.Errorf("Expected copied index to be 7, but got %d", copied.Index) + } + + // Modify the copied model + copied.SetIndex(9) + if model.Index == copied.Index { + t.Errorf("Expected copied model to be a separate instance, but both have the same index %d", model.Index) + } +} + +type Face struct { + *IndexModel + VertexIndexes [3]int +} + +func NewFace(index, vertexIndex0, vertexIndex1, vertexIndex2 int) *Face { + return &Face{ + IndexModel: &IndexModel{Index: index}, + VertexIndexes: [3]int{vertexIndex0, vertexIndex1, vertexIndex2}, + } +} + +// 面リスト +type Faces struct { + *IndexModels[*Face] +} + +func NewFaces() *Faces { + return &Faces{ + IndexModels: NewIndexModels[*Face](2, func() *Face { return nil }), + } +} + +func TestIndexModelCorrection_GetItem(t *testing.T) { + model := NewFaces() + item := NewFace(0, 0, 0, 0) + model.SetItem(0, item) + + result := model.Get(0) + if result != item { + t.Errorf("Expected GetItem to return the item, but got %v", result) + } + + // Test out of range index + { + result := model.Get(1) + if result != nil { + t.Errorf("Expected GetItem to return nil, but got %v", result) + } + } +} + +func TestIndexModelCorrection_SetItem(t *testing.T) { + model := NewFaces() + item := NewFace(0, 0, 0, 0) + model.SetItem(0, item) + + result := model.Get(0) + if result != item { + t.Errorf("Expected SetItem to set the item, but got %v", result) + } +} + +func TestIndexModelCorrection_Append(t *testing.T) { + model := NewFaces() + item := NewFace(0, 0, 0, 0) + model.Update(item) + + result := model.Get(0) + if result != item { + t.Errorf("Expected Append to add the item, but got %v", result) + } + + item2 := NewFace(1, 0, 0, 0) + // Test sorting + model.Update(item2) + result = model.Get(0) + if result != item { + t.Errorf("Expected Append to sort the items, but got %v", result) + } + if result == item2 { + t.Errorf("Expected Append to sort the items, but got %v", result) + } +} + +func TestIndexModelCorrection_DeleteItem(t *testing.T) { + model := NewFaces() + item := NewFace(0, 0, 0, 0) + model.SetItem(0, item) + + model.DeleteItem(0) + + { + result := model.Get(0) + if result != nil { + t.Errorf("Expected GetItem to return nil, but got %v", result) + } + } +} + +func TestIndexModelCorrection_Len(t *testing.T) { + model := NewFaces() + item := NewFace(0, 0, 0, 0) + model.SetItem(0, item) + + result := model.Len() + if result != 2 { + t.Errorf("Expected Len to return 1, but got %d", result) + } +} + +func TestIndexModelCorrection_Contains(t *testing.T) { + model := NewFaces() + item := NewFace(0, 0, 0, 0) + model.SetItem(0, item) + + result := model.Contains(0) + if !result { + t.Error("Expected Contains to return true, but got false") + } + + result = model.Contains(1) + if result { + t.Error("Expected Contains to return false, but got true") + } +} diff --git a/pkg/mcore/index_name_model.go b/pkg/mcore/index_name_model.go new file mode 100644 index 00000000..06c102fc --- /dev/null +++ b/pkg/mcore/index_name_model.go @@ -0,0 +1,181 @@ +package mcore + +import ( + "reflect" + "sort" + + "github.com/jinzhu/copier" +) + +type IIndexNameModel interface { + IsValid() bool + Copy() IIndexNameModel + GetIndex() int + SetIndex(index int) + GetName() string + SetName(name string) +} + +// INDEXを持つ基底クラス +type IndexNameModel struct { + Index int + Name string + EnglishName string +} + +func (v *IndexNameModel) GetIndex() int { + return v.Index +} + +func (v *IndexNameModel) SetIndex(index int) { + v.Index = index +} + +func (v *IndexNameModel) GetName() string { + return v.Name +} + +func (v *IndexNameModel) SetName(name string) { + v.Name = name +} + +func (v *IndexNameModel) IsValid() bool { + return v != nil && v.GetIndex() >= 0 +} + +func (v *IndexNameModel) Copy() IIndexNameModel { + copied := IndexNameModel{Index: v.Index, Name: v.Name, EnglishName: v.EnglishName} + copier.CopyWithOption(copied, v, copier.Option{DeepCopy: true}) + return &copied +} + +// Tのリスト基底クラス +type IndexNameModels[T IIndexNameModel] struct { + Data []T + NameIndexes map[string]int + nilFunc func() T + isDirty bool +} + +func NewIndexNameModels[T IIndexNameModel](count int, nilFunc func() T) *IndexNameModels[T] { + return &IndexNameModels[T]{ + Data: make([]T, count), + NameIndexes: make(map[string]int, 0), + nilFunc: nilFunc, + } +} + +func (c *IndexNameModels[T]) Get(index int) T { + if index < 0 || index >= len(c.Data) { + return c.nilFunc() + } + return c.Data[index] +} + +func (c *IndexNameModels[T]) SetItem(index int, v T) { + c.Data[index] = v +} + +func (c *IndexNameModels[T]) Update(value T) { + if value.GetIndex() < 0 { + value.SetIndex(len(c.Data)) + } + c.Data[value.GetIndex()] = value + if _, ok := c.NameIndexes[value.GetName()]; !ok { + // 名前は先勝ち + c.NameIndexes[value.GetName()] = value.GetIndex() + } + c.SetDirty(true) +} + +func (c *IndexNameModels[T]) Append(value T) { + if value.GetIndex() < 0 { + value.SetIndex(len(c.Data)) + } + c.Data = append(c.Data, value) + if _, ok := c.NameIndexes[value.GetName()]; !ok { + // 名前は先勝ち + c.NameIndexes[value.GetName()] = value.GetIndex() + } + c.SetDirty(true) +} + +func (c *IndexNameModels[T]) GetIndexes() []int { + indexes := make([]int, len(c.NameIndexes)) + i := 0 + for _, index := range c.NameIndexes { + indexes[i] = index + i++ + } + sort.Ints(indexes) + return indexes +} + +func (c *IndexNameModels[T]) GetNames() []string { + names := make([]string, len(c.NameIndexes)) + i := 0 + for index := range c.GetIndexes() { + names[i] = c.Data[index].GetName() + i++ + } + return names +} + +func (c *IndexNameModels[T]) DeleteItem(index int) { + c.Data[index] = c.nilFunc() +} + +func (c *IndexNameModels[T]) Len() int { + return len(c.Data) +} + +func (c *IndexNameModels[T]) ContainsIndex(key int) bool { + return c != nil && key >= 0 && key < len(c.Data) && !reflect.ValueOf(c.Data[key]).IsNil() +} + +func (c *IndexNameModels[T]) ContainsName(key string) bool { + _, ok := c.NameIndexes[key] + return ok +} + +func (c *IndexNameModels[T]) IsEmpty() bool { + return len(c.Data) == 0 +} + +func (c *IndexNameModels[T]) IsNotEmpty() bool { + return len(c.Data) > 0 +} + +func (c *IndexNameModels[T]) LastIndex() int { + maxIndex := 0 + for index := range c.Data { + if index > maxIndex { + maxIndex = index + } + } + return maxIndex +} + +func (c *IndexNameModels[T]) GetByName(name string) T { + if index, ok := c.NameIndexes[name]; ok { + return c.Data[index] + } + return c.nilFunc() +} + +func (v *IndexNameModels[T]) Contains(index int) bool { + return index >= 0 && index < len(v.Data) && !reflect.ValueOf(v.Data[index]).IsNil() +} + +func (v *IndexNameModels[T]) ContainsByName(name string) bool { + _, ok := v.NameIndexes[name] + return ok +} + +func (v *IndexNameModels[T]) IsDirty() bool { + return v.isDirty +} + +func (v *IndexNameModels[T]) SetDirty(dirty bool) { + v.isDirty = dirty +} diff --git a/pkg/mcore/llrb.go b/pkg/mcore/llrb.go new file mode 100644 index 00000000..4f3469bf --- /dev/null +++ b/pkg/mcore/llrb.go @@ -0,0 +1,81 @@ +package mcore + +import "github.com/petar/GoLLRB/llrb" + +type Int int + +func NewInt(v int) Int { + return Int(v) +} + +func (v Int) Less(than llrb.Item) bool { + if than == nil { + return false + } + return v < than.(Int) +} + +type IntIndexes struct { + *llrb.LLRB +} + +func NewIntIndexes() *IntIndexes { + return &IntIndexes{ + LLRB: llrb.New(), + } +} + +func (i IntIndexes) Prev(index int) int { + prevIndex := Int(0) + + i.DescendLessOrEqual(Int(index), func(i llrb.Item) bool { + prevIndex = i.(Int) + return false + }) + + return int(prevIndex) +} + +func (i IntIndexes) Next(index int) int { + nextIndex := Int(index) + + i.AscendGreaterOrEqual(Int(index), func(i llrb.Item) bool { + nextIndex = i.(Int) + return false + }) + + return int(nextIndex) +} + +func (i IntIndexes) Has(index int) bool { + return i.LLRB.Has(Int(index)) +} + +func (i IntIndexes) Max() int { + if i.LLRB.Len() == 0 { + return 0 + } + return int(i.LLRB.Max().(Int)) +} + +func (i IntIndexes) Min() int { + if i.LLRB.Len() == 0 { + return 0 + } + return int(i.LLRB.Min().(Int)) +} + +func (i IntIndexes) Len() int { + return i.LLRB.Len() +} + +func (i IntIndexes) List() []int { + list := make([]int, 0, i.LLRB.Len()) + i.LLRB.AscendGreaterOrEqual(i.LLRB.Min(), func(item llrb.Item) bool { + if int(item.(Int)) >= 0 { + list = append(list, int(item.(Int))) + } + return true + }) + return list +} diff --git a/pkg/mcore/reader.go b/pkg/mcore/reader.go new file mode 100644 index 00000000..2e1b9555 --- /dev/null +++ b/pkg/mcore/reader.go @@ -0,0 +1,313 @@ +package mcore + +import ( + "bufio" + "crypto/sha1" + "encoding/binary" + "encoding/hex" + "fmt" + "io" + "math" + "os" + + "golang.org/x/text/encoding" + "golang.org/x/text/encoding/japanese" + "golang.org/x/text/encoding/unicode" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils" +) + +type ReaderInterface interface { + ReadNameByFilepath(path string) (string, error) + ReadByFilepath(path string) (IHashModel, error) + ReadHashByFilePath(path string) (string, error) +} + +type BaseReader[T IHashModel] struct { + File *os.File + reader *bufio.Reader + encoding encoding.Encoding + ReadText func() string +} + +func (r *BaseReader[T]) Open(path string) error { + + file, err := mutils.Open(path) + if err != nil { + return err + } + r.File = file + r.reader = bufio.NewReader(r.File) + + return nil +} + +func (r *BaseReader[T]) Close() { + defer r.File.Close() +} + +func (r *BaseReader[T]) ReadNameByFilepath(path string) (string, error) { + panic("not implemented") +} + +func (r *BaseReader[T]) ReadByFilepath(path string) (T, error) { + panic("not implemented") +} + +func (r *BaseReader[T]) ReadHashByFilePath(path string) (string, error) { + file, err := os.Open(path) + if err != nil { + return "", err + } + defer file.Close() + + sha1Hash := sha1.New() + if _, err := io.Copy(sha1Hash, file); err != nil { + return "", err + } + + // ファイルパスをハッシュに含める + sha1Hash.Write([]byte(path)) + + return hex.EncodeToString(sha1Hash.Sum(nil)), nil + +} + +func (r *BaseReader[T]) DefineEncoding(encoding encoding.Encoding) { + r.encoding = encoding + r.ReadText = r.defineReadText(encoding) +} + +func (r *BaseReader[T]) defineReadText(encoding encoding.Encoding) func() string { + return func() string { + size, err := r.UnpackInt() + if err != nil { + return "" + } + fbytes, err := r.UnpackBytes(int(size)) + if err != nil { + return "" + } + return r.DecodeText(encoding, fbytes) + } +} + +func (r *BaseReader[T]) DecodeText(mainEncoding encoding.Encoding, fbytes []byte) string { + // 基本のエンコーディングを第一候補でデコードして、ダメなら順次テスト + for _, targetEncoding := range []encoding.Encoding{ + mainEncoding, + japanese.ShiftJIS, + unicode.UTF8, + unicode.UTF16(unicode.LittleEndian, unicode.UseBOM), + } { + var decodedText string + var err error + if targetEncoding == japanese.ShiftJIS { + // shift-jisは一旦cp932に変換してもう一度戻したので返す + decodedText, err = r.DecodeShiftJIS(fbytes) + if err != nil { + continue + } + } else { + // 変換できなかった文字は「?」に変換する + decodedText, err = r.DecodeBytes(fbytes, targetEncoding) + if err != nil { + continue + } + } + return decodedText + } + return "" +} + +func (r *BaseReader[T]) DecodeShiftJIS(fbytes []byte) (string, error) { + decodedText, err := japanese.ShiftJIS.NewDecoder().Bytes(fbytes) + if err != nil { + return "", err + } + return string(decodedText), nil +} + +func (r *BaseReader[T]) DecodeBytes(fbytes []byte, encoding encoding.Encoding) (string, error) { + decodedText, err := encoding.NewDecoder().Bytes(fbytes) + if err != nil { + return "", err + } + return string(decodedText), nil +} + +// バイナリデータから bytes を読み出す +func (r *BaseReader[T]) UnpackBytes(size int) ([]byte, error) { + chunk, err := r.unpack(size) + if err != nil { + return nil, err + } + + return chunk, nil +} + +// バイナリデータから byte を読み出す +func (r *BaseReader[T]) UnpackByte() (byte, error) { + chunk, err := r.unpack(1) + if err != nil { + return 0, err + } + + return chunk[0], nil +} + +// バイナリデータから sbyte を読み出す +func (r *BaseReader[T]) UnpackSByte() (int8, error) { + chunk, err := r.unpack(1) + if err != nil { + return 0, err + } + + return int8(chunk[0]), nil +} + +// バイナリデータから int16 を読み出す +func (r *BaseReader[T]) UnpackShort() (int16, error) { + chunk, err := r.unpack(2) + if err != nil { + return 0, err + } + + return int16(binary.LittleEndian.Uint16(chunk)), nil +} + +// バイナリデータから uint16 を読み出す +func (r *BaseReader[T]) UnpackUShort() (uint16, error) { + chunk, err := r.unpack(2) + if err != nil { + return 0, err + } + + return binary.LittleEndian.Uint16(chunk), nil +} + +// バイナリデータから uint を読み出す +func (r *BaseReader[T]) UnpackUInt() (uint, error) { + chunk, err := r.unpack(4) + if err != nil { + return 0, err + } + + return uint(binary.LittleEndian.Uint32(chunk)), nil +} + +// バイナリデータから int を読み出す +func (r *BaseReader[T]) UnpackInt() (int, error) { + chunk, err := r.unpack(4) + if err != nil { + return 0, err + } + + return int(binary.LittleEndian.Uint32(chunk)), nil +} + +// バイナリデータから float64 を読み出す +func (r *BaseReader[T]) UnpackFloat() (float64, error) { + // 単精度実数(4byte)なので、一旦uint32にしてからfloat32に変換する + chunk, err := r.unpack(4) + if err != nil { + return 0, err + } + + return float64(math.Float32frombits(binary.LittleEndian.Uint32(chunk))), nil +} + +func (r *BaseReader[T]) UnpackVec2() (mmath.MVec2, error) { + x, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMVec2(), err + } + y, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMVec2(), err + } + return mmath.MVec2{x, y}, nil +} + +func (r *BaseReader[T]) UnpackVec3(isConvertGl bool) (mmath.MVec3, error) { + x, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMVec3(), err + } + y, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMVec3(), err + } + z, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMVec3(), err + } + // if isConvertGl { + // z = -z + // } + return mmath.MVec3{x, y, z}, nil +} + +func (r *BaseReader[T]) UnpackVec4(isConvertGl bool) (mmath.MVec4, error) { + x, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMVec4(), err + } + y, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMVec4(), err + } + z, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMVec4(), err + } + w, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMVec4(), err + } + // if isConvertGl { + // z = -z + // } + return mmath.MVec4{x, y, z, w}, nil +} + +func (r *BaseReader[T]) UnpackQuaternion(isConvertGl bool) (mmath.MQuaternion, error) { + x, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMQuaternion(), err + } + y, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMQuaternion(), err + } + z, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMQuaternion(), err + } + w, err := r.UnpackFloat() + if err != nil { + return *mmath.NewMQuaternion(), err + } + // if isConvertGl { + // z = -z + // } + return *mmath.NewMQuaternionByValues(x, y, z, w), nil +} + +func (r *BaseReader[T]) unpack(size int) ([]byte, error) { + if r.reader == nil { + return nil, fmt.Errorf("file is not opened") + } + + chunk := make([]byte, size) + _, err := io.ReadFull(r.reader, chunk) + if err != nil { + if err == io.EOF { + return nil, fmt.Errorf("EOF") + } + return nil, fmt.Errorf("failed to read: %w", err) + } + + return chunk, nil +} diff --git a/pkg/mmath/argsort.go b/pkg/mmath/argsort.go new file mode 100644 index 00000000..872d8439 --- /dev/null +++ b/pkg/mmath/argsort.go @@ -0,0 +1,55 @@ +// Package argsort implements a variant of the sort function that returns a slice of indices that would sort the array. +// +// The name comes from the popular Python numpy.Argsort function. +package mmath + +import ( + "reflect" + "sort" +) + +// SortInto sorts s and populates the indices slice with the indices that would sort the input slice. +func SortInto(s sort.Interface, indices []int) { + for i := 0; i < s.Len(); i++ { + indices[i] = i + } + sort.Stable(argsorter{s: s, m: indices}) +} + +// ArgSort returns the indices that would sort s. +func ArgSort(s sort.Interface) []int { + indices := make([]int, s.Len()) + SortInto(s, indices) + return indices +} + +// SortSliceInto sorts a slice and populates the indices slice with the indices that would sort the input slice. +func SortSliceInto(slice interface{}, indices []int, less func(i, j int) bool) { + SortInto(dyn{slice, less}, indices) +} + +// SortSlice return the indices that would sort a slice given a comparison function. +func SortSlice(slice interface{}, less func(i, j int) bool) []int { + v := reflect.ValueOf(slice) + indices := make([]int, v.Len()) + SortSliceInto(slice, indices, less) + return indices +} + +type argsorter struct { + s sort.Interface + m []int +} + +func (a argsorter) Less(i, j int) bool { return a.s.Less(a.m[i], a.m[j]) } +func (a argsorter) Len() int { return a.s.Len() } +func (a argsorter) Swap(i, j int) { a.m[i], a.m[j] = a.m[j], a.m[i] } + +type dyn struct { + slice interface{} + less func(i, j int) bool +} + +func (d dyn) Less(i, j int) bool { return d.less(i, j) } +func (d dyn) Len() int { return reflect.ValueOf(d.slice).Len() } +func (d dyn) Swap(i, j int) { panic("unnecessary") } diff --git a/pkg/mmath/curve.go b/pkg/mmath/curve.go new file mode 100644 index 00000000..0fce7664 --- /dev/null +++ b/pkg/mmath/curve.go @@ -0,0 +1,299 @@ +package mmath + +import ( + "math" + + "gonum.org/v1/gonum/optimize" +) + +type Curve struct { + Start MVec2 + End MVec2 +} + +const ( + // MMDでの補間曲線の最大値 + CURVE_MAX = 127.0 +) + +var LINER_CURVE = &Curve{ + Start: MVec2{20.0, 20.0}, + End: MVec2{107.0, 107.0}, +} + +func NewCurve() *Curve { + return &Curve{ + Start: MVec2{20.0, 20.0}, + End: MVec2{107.0, 107.0}, + } +} + +func NewCurveByValues(startX, startY, endX, endY byte) *Curve { + if startX == 20 && startY == 20 && endX == 107 && endY == 107 { + return LINER_CURVE + } + + return &Curve{ + Start: MVec2{float64(startX), float64(startY)}, + End: MVec2{float64(endX), float64(endY)}, + } +} + +// Copy +func (v *Curve) Copy() *Curve { + copied := NewCurve() + copied.Start.SetX(v.Start.GetX()) + copied.Start.SetY(v.Start.GetY()) + copied.End.SetX(v.End.GetX()) + copied.End.SetY(v.End.GetY()) + return copied +} + +func (v *Curve) Normalize(begin, finish *MVec2) { + diff := finish.Subed(begin) + + v.Start = *v.Start.Sub(begin).Div(diff).MulScalar(CURVE_MAX).Round() + + if v.Start.GetX() < 0 { + v.Start.SetX(0) + } else if v.Start.GetX() > CURVE_MAX { + v.Start.SetX(CURVE_MAX) + } + + if v.Start.GetY() < 0 { + v.Start.SetY(0) + } else if v.Start.GetY() > CURVE_MAX { + v.Start.SetY(CURVE_MAX) + } + + v.End = *v.End.Sub(begin).Div(diff).MulScalar(CURVE_MAX).Round() + + if v.End.GetX() < 0 { + v.End.SetX(0) + } else if v.End.GetX() > CURVE_MAX { + v.End.SetX(CURVE_MAX) + } + + if v.End.GetY() < 0 { + v.End.SetY(0) + } else if v.End.GetY() > CURVE_MAX { + v.End.SetY(CURVE_MAX) + } +} + +// https://pomax.github.io/bezierinfo +// https://shspage.hatenadiary.org/entry/20140625/1403702735 +// https://bezier.readthedocs.io/en/stable/python/reference/bezier.curve.html#bezier.curve.Curve.evaluate +// https://edvakf.hatenadiary.org/entry/20111016/1318716097 +// Evaluate 補間曲線を求めます。 +// return x（計算キーフレ時点のX値）, y（計算キーフレ時点のY値）, t（計算キーフレまでの変化量） +func Evaluate(curve *Curve, start, now, end int) (float64, float64, float64) { + if (now-start) == 0.0 || (end-start) == 0.0 { + return 0.0, 0.0, 0.0 + } + + x := float64(now-start) / float64(end-start) + + if x >= 1 { + return 1.0, 1.0, 1.0 + } + + if curve.Start.GetX() == curve.Start.GetY() && curve.End.GetX() == curve.End.GetY() { + // 前後が同じ場合、必ず線形補間になる + return x, x, x + } + + x1 := curve.Start.GetX() / CURVE_MAX + y1 := curve.Start.GetY() / CURVE_MAX + x2 := curve.End.GetX() / CURVE_MAX + y2 := curve.End.GetY() / CURVE_MAX + + t := newton(x1, x2, x, 0.5, 1e-15, 1e-20) + s := 1.0 - t + + y := (3.0 * (math.Pow(s, 2.0)) * t * y1) + (3.0 * s * (math.Pow(t, 2.0)) * y2) + math.Pow(t, 3.0) + + return x, y, t +} + +// 解を求める関数 +func newtonFuncF(x1, x2, x, t float64) float64 { + t1 := 1.0 - t + return 3.0*(math.Pow(t1, 2.0))*t*x1 + 3.0*t1*(math.Pow(t, 2.0))*x2 + math.Pow(t, 3.0) - x +} + +// Newton法（方程式の関数項、探索の開始点、微小量、誤差範囲、最大反復回数） +func newton(x1, x2, x, t0, eps, err float64) float64 { + derivative := 2.0 * eps + + for i := 0; i < 20; i++ { + funcFValue := newtonFuncF(x1, x2, x, t0) + // 中心差分による微分値 + funcDF := (newtonFuncF(x1, x2, x, t0+eps) - newtonFuncF(x1, x2, x, t0-eps)) / derivative + + // 次の解を計算 + t1 := t0 - funcFValue/funcDF + + if err >= math.Abs(t1-t0) { + // 「誤差範囲が一定値以下」ならば終了 + break + } + + // 解を更新 + t0 = t1 + } + + return t0 +} + +// SplitCurve 補間曲線を指定キーフレで前後に分割する +func SplitCurve(curve *Curve, start, now, end int) (*Curve, *Curve) { + if (now-start) == 0 || (end-start) == 0 { + return NewCurve(), NewCurve() + } + + _, _, t := Evaluate(curve, start, now, end) + + iA := &MVec2{0.0, 0.0} + iB := curve.Start.DivedScalar(CURVE_MAX) + iC := curve.End.DivedScalar(CURVE_MAX) + iD := &MVec2{1.0, 1.0} + + iAt1 := iA.MuledScalar(1 - t) + iBt1 := iB.MuledScalar(1 - t) + iBt2 := iB.MuledScalar(t) + iCt1 := iC.MuledScalar(1 - t) + iCt2 := iC.MuledScalar(t) + iDt2 := iD.MuledScalar(t) + + iE := iAt1.Added(iBt2) + iF := iBt1.Added(iCt2) + iG := iCt1.Added(iDt2) + + iEt1 := iE.MuledScalar(1 - t) + iFt1 := iF.MuledScalar(1 - t) + iFt2 := iF.MuledScalar(t) + iGt2 := iG.MuledScalar(t) + + iH := iEt1.Added(iFt2) + iI := iFt1.Added(iGt2) + + iHt1 := iH.MuledScalar(1 - t) + iIt2 := iI.MuledScalar(t) + + iJ := iHt1.Added(iIt2) + + // 新たな4つのベジェ曲線の制御点は、A側がAEHJ、C側がJIGDとなる。 + startCurve := &Curve{ + Start: *iE, + End: *iH, + } + startCurve.Normalize(iA, iJ) + + endCurve := &Curve{ + Start: *iI, + End: *iG, + } + endCurve.Normalize(iJ, iD) + + if startCurve.Start.GetX() == startCurve.Start.GetY() && + startCurve.End.GetX() == startCurve.End.GetY() && + endCurve.Start.GetX() == endCurve.Start.GetY() && + endCurve.End.GetX() == endCurve.End.GetY() { + // 線形の場合初期化 + startCurve = NewCurve() + endCurve = NewCurve() + } + + return startCurve, endCurve +} + +func Bezier(t float64, p0, p1, p2, p3 *MVec2) *MVec2 { + t2 := t * t + t3 := t2 * t + mt := 1 - t + mt2 := mt * mt + mt3 := mt2 * mt + + bx := mt3*p0.GetX() + 3*mt2*t*p1.GetX() + 3*mt*t2*p2.GetX() + t3*p3.GetX() + by := mt3*p0.GetY() + 3*mt2*t*p1.GetY() + 3*mt*t2*p2.GetY() + t3*p3.GetY() + + return &MVec2{bx, by} +} + +// NewCurveFromValues calculates the control points of a cubic Bezier curve +// that best fits a given set of y-values. +func NewCurveFromValues(values []float64) *Curve { + n := len(values) + if n <= 2 { + return NewCurve() + } + + // Set start and end points + p0 := &MVec2{0, values[0]} + p3 := &MVec2{float64(n - 1), values[n-1]} + + // Initial guesses for control points + p1 := &MVec2{1, values[1]} + p2 := &MVec2{float64(n - 2), values[n-2]} + + funcEval := func(x []float64) float64 { + p1 = &MVec2{x[0], x[1]} + p2 = &MVec2{x[2], x[3]} + sumSq := 0.0 + for i, y := range values { + t := float64(i) / float64(n-1) + bp := Bezier(t, p0, p1, p2, p3) + diff := bp.GetY() - y + sumSq += diff * diff + } + return sumSq + } + + // Define the optimization problem + problem := optimize.Problem{ + Func: funcEval, + Grad: func(grad, x []float64) { + h := 1e-6 + fx := funcEval(x) + for i := range x { + orig := x[i] + x[i] += h + fxh := funcEval(x) + x[i] = orig + grad[i] = (fxh - fx) / h + } + }, + } + + // Optimization settings + settings := &optimize.Settings{ + MajorIterations: 1000, // 最大イテレーション数を増やす + FuncEvaluations: 10000, // 関数評価の最大数を増やす + GradientThreshold: 1e-6, // 勾配の閾値を変更する + } + method := &optimize.LBFGS{} + + // Initial control points vector + initial := []float64{p1.GetX(), p1.GetY(), p2.GetX(), p2.GetY()} + + // Perform optimization + result, err := optimize.Minimize(problem, initial, settings, method) + if err != nil { + return NewCurve() + } + + // Update p1 and p2 with optimized values + c := &Curve{ + Start: MVec2{result.X[0], result.X[1]}, + End: MVec2{result.X[2], result.X[3]}, + } + c.Normalize(p0, p3) + + if c.Start.GetX()/c.Start.GetY() == 1.0 && c.End.GetX()/c.End.GetY() == 1.0 { + // 線形の場合初期化 + c = NewCurve() + } + + return c +} diff --git a/pkg/mmath/curve_test.go b/pkg/mmath/curve_test.go new file mode 100644 index 00000000..92be08b2 --- /dev/null +++ b/pkg/mmath/curve_test.go @@ -0,0 +1,287 @@ +package mmath + +import ( + "math" + "reflect" + "testing" +) + +func TestEvaluate(tst *testing.T) { + inter := &Curve{} + inter.Start = MVec2{20.0, 20.0} + inter.End = MVec2{107.0, 107.0} + + x, y, t := Evaluate(inter, 0, 50, 100) + + if x != 0.5 { + tst.Errorf("Expected x to be 0.5, but got %f", x) + } + + if y != 0.5 { + tst.Errorf("Expected y to be 0.5, but got %f", y) + } + + if t != 0.5 { + tst.Errorf("Expected t to be 0.5, but got %f", t) + } +} + +func TestEvaluate2(tst *testing.T) { + inter := &Curve{} + inter.Start = MVec2{10.0, 30.0} + inter.End = MVec2{100.0, 80.0} + + x, y, t := Evaluate(inter, 0, 2, 10) + + if x != 0.2 { + tst.Errorf("Expected x to be 0.2, but got %f", x) + } + + expectedY := 0.24085271757748078 + if math.Abs(y-expectedY) > 1e-10 { + tst.Errorf("Expected y to be %.20f, but got %.20f", expectedY, y) + } + + expectedT := 0.2900272452240925 + if math.Abs(t-expectedT) > 1e-10 { + tst.Errorf("Expected t to be %.20f, but got %.20f", expectedT, t) + } +} + +func TestSplitCurve(t *testing.T) { + curve := &Curve{} + curve.Start = MVec2{89.0, 2.0} + curve.End = MVec2{52.0, 106.0} + + startCurve, endCurve := SplitCurve(curve, 0, 2, 10) + + expectedStartStart := MVec2{50, 7} + if !startCurve.Start.NearEquals(&expectedStartStart, 1e-1) { + t.Errorf("Expected startCurve.Start to be %v, but got %v", expectedStartStart, startCurve.Start) + } + + expectedStartEnd := MVec2{91, 52} + if !startCurve.End.NearEquals(&expectedStartEnd, 1e-1) { + t.Errorf("Expected startCurve.End to be %v, but got %v", expectedStartEnd, startCurve.End) + } + + expectedEndStart := MVec2{71, 21} + if !endCurve.Start.NearEquals(&expectedEndStart, 1e-1) { + t.Errorf("Expected endCurve.Start to be %v, but got %v", expectedEndStart, endCurve.Start) + } + + expectedEndEnd := MVec2{44, 108} + if !endCurve.End.NearEquals(&expectedEndEnd, 1e-1) { + t.Errorf("Expected endCurve.End to be %v, but got %v", expectedEndEnd, endCurve.End) + } +} + +func TestSplitCurve2(t *testing.T) { + curve := &Curve{} + curve.Start = MVec2{89.0, 2.0} + curve.End = MVec2{52.0, 106.0} + + startCurve, endCurve := SplitCurve(curve, 0, 2, 10) + + expectedStartStart := MVec2{50, 7} + if !startCurve.Start.NearEquals(&expectedStartStart, 1e-1) { + t.Errorf("Expected startCurve.Start to be %v, but got %v", expectedStartStart, startCurve.Start) + } + + expectedStartEnd := MVec2{91, 52} + if !startCurve.End.NearEquals(&expectedStartEnd, 1e-1) { + t.Errorf("Expected startCurve.End to be %v, but got %v", expectedStartEnd, startCurve.End) + } + + expectedEndStart := MVec2{71, 21} + if !endCurve.Start.NearEquals(&expectedEndStart, 1e-1) { + t.Errorf("Expected endCurve.Start to be %v, but got %v", expectedEndStart, endCurve.Start) + } + + expectedEndEnd := MVec2{44, 108} + if !endCurve.End.NearEquals(&expectedEndEnd, 1e-1) { + t.Errorf("Expected endCurve.End to be %v, but got %v", expectedEndEnd, endCurve.End) + } +} + +func TestSplitCurveLinear(t *testing.T) { + curve := &Curve{} + curve.Start = MVec2{20.0, 20.0} + curve.End = MVec2{107.0, 107.0} + + startCurve, endCurve := SplitCurve(curve, 0, 50, 100) + + expectedStartStart := MVec2{20, 20} + if !startCurve.Start.Equals(&expectedStartStart) { + t.Errorf("Expected startCurve.Start to be %v, but got %v", expectedStartStart, startCurve.Start) + } + + expectedStartEnd := MVec2{107, 107} + if !startCurve.End.Equals(&expectedStartEnd) { + t.Errorf("Expected startCurve.End to be %v, but got %v", expectedStartEnd, startCurve.End) + } + + expectedEndStart := MVec2{20, 20} + if !endCurve.Start.Equals(&expectedEndStart) { + t.Errorf("Expected endCurve.Start to be %v, but got %v", expectedEndStart, endCurve.Start) + } + + expectedEndEnd := MVec2{107, 107} + if !endCurve.End.Equals(&expectedEndEnd) { + t.Errorf("Expected endCurve.End to be %v, but got %v", expectedEndEnd, endCurve.End) + } +} + +func TestSplitCurveSamePoints(t *testing.T) { + curve := &Curve{} + curve.Start = MVec2{10.0, 10.0} + curve.End = MVec2{10.0, 10.0} + + startCurve, endCurve := SplitCurve(curve, 0, 2, 10) + + expectedStartStart := MVec2{20, 20} + if !startCurve.Start.Equals(&expectedStartStart) { + t.Errorf("Expected startCurve.Start to be %v, but got %v", expectedStartStart, startCurve.Start) + } + + expectedStartEnd := MVec2{107, 107} + if !startCurve.End.Equals(&expectedStartEnd) { + t.Errorf("Expected startCurve.End to be %v, but got %v", expectedStartEnd, startCurve.End) + } + + expectedEndStart := MVec2{20, 20} + if !endCurve.Start.Equals(&expectedEndStart) { + t.Errorf("Expected endCurve.Start to be %v, but got %v", expectedEndStart, endCurve.Start) + } + + expectedEndEnd := MVec2{107, 107} + if !endCurve.End.Equals(&expectedEndEnd) { + t.Errorf("Expected endCurve.End to be %v, but got %v", expectedEndEnd, endCurve.End) + } +} + +func TestSplitCurveOutOfRange(t *testing.T) { + curve := &Curve{} + curve.Start = MVec2{25.0, 101.0} + curve.End = MVec2{127.0, 12.0} + + startCurve, endCurve := SplitCurve(curve, 0, 2, 10) + + expectedStartStart := MVec2{27, 65} + if !startCurve.Start.Equals(&expectedStartStart) { + t.Errorf("Expected startCurve.Start to be %v, but got %v", expectedStartStart, startCurve.Start) + } + + expectedStartEnd := MVec2{73, 103} + if !startCurve.End.Equals(&expectedStartEnd) { + t.Errorf("Expected startCurve.End to be %v, but got %v", expectedStartEnd, startCurve.End) + } + + expectedEndStart := MVec2{49, 44} + if !endCurve.Start.Equals(&expectedEndStart) { + t.Errorf("Expected endCurve.Start to be %v, but got %v", expectedEndStart, endCurve.Start) + } + + expectedEndEnd := MVec2{127, 0} + if !endCurve.End.Equals(&expectedEndEnd) { + t.Errorf("Expected endCurve.End to be %v, but got %v", expectedEndEnd, endCurve.End) + } +} + +func TestNewCurveFromValues(t *testing.T) { + // Test case 1: Empty values + values := []float64{} + expected := NewCurve() + result := NewCurveFromValues(values) + if !reflect.DeepEqual(result, expected) { + t.Errorf("Expected %v, but got %v", expected, result) + } + + // Test case 2: Single value + values = []float64{1.0} + expected = NewCurve() + result = NewCurveFromValues(values) + if !reflect.DeepEqual(result, expected) { + t.Errorf("Expected %v, but got %v", expected, result) + } + + // Test case 3: Two values + values = []float64{1.0, 2.0} + expected = NewCurve() + result = NewCurveFromValues(values) + if !reflect.DeepEqual(result, expected) { + t.Errorf("Expected %v, but got %v", expected, result) + } + + // Test case 4: Three values + values = []float64{1.0, 2.0, 3.0} + expected = NewCurve() + result = NewCurveFromValues(values) + if !reflect.DeepEqual(result, expected) { + t.Errorf("Expected %v, but got %v", expected, result) + } + + // Test case 5: Four values + values = []float64{ + 0.5979851484298706, + 0.521004855632782, + 0.37936708331108093, + 0.3069007694721222, + 0.30701854825019836, + 0.243390291929245, + 0.28262293338775635, + 0.2678329348564148, + 0.27642160654067993, + 0.276456743478775, + 0.3345196545124054, + 0.3592238426208496, + 0.34113433957099915, + 0.32507243752479553, + 0.32527124881744385, + 0.28771495819091797, + 0.16925211250782013, + 0.07562929391860962, + -0.01844712160527706, + -0.01857336051762104, + -0.10410086810588837, + -0.1692115068435669, + -0.22358137369155884, + -0.28167492151260376, + -0.2816798686981201, + -0.2936137318611145, + -0.35715776681900024, + -0.3935558795928955, + -0.43389225006103516, + -0.4339143633842468, + -0.4917398691177368, + -0.5314293503761292, + -0.5342316031455994, + -0.5640663504600525, + -0.5642469525337219, + -0.5541977882385254, + -0.5907184481620789, + -0.6129558682441711, + -0.7112897038459778, + -0.7110443711280823, + -0.7198588848114014, + -0.7699093818664551, + -0.8582518100738525, + -0.9080440998077393, + -0.907961368560791, + -0.9225611090660095, + -1.009341835975647, + -1.0600273609161377, + -1.1095038652420044, + -1.1092925071716309, + -1.1037554740905762, + -1.1115431785583496, + } + expected = &Curve{ + Start: MVec2{2, 37}, + End: MVec2{125, 94}, + } + result = NewCurveFromValues(values) + if !reflect.DeepEqual(result, expected) { + t.Errorf("Expected %v, but got %v", expected, result) + } +} diff --git a/pkg/mmath/infrection.go b/pkg/mmath/infrection.go new file mode 100644 index 00000000..03a08bbf --- /dev/null +++ b/pkg/mmath/infrection.go @@ -0,0 +1,84 @@ +package mmath + +import ( + "math" +) + +func gradient(values []float64) []float64 { + result := make([]float64, len(values)) + for i := 1; i < len(values)-1; i++ { + result[i] = (values[i+1] - values[i-1]) / 2.0 + } + result[0] = values[1] - values[0] + result[len(values)-1] = values[len(values)-1] - values[len(values)-2] + return result +} + +func FindInflectionPoints(values []float64, tolerance float64, space int) map[int]int { + ysPrime := gradient(values) + + primePoints := make(map[int]int) + prevInflectionPoint := 0 + for i, v := range ysPrime { + if i > 0 && math.Abs(v) > tolerance && ysPrime[i-1]*v < 0 && i-prevInflectionPoint > space { + // ゼロに近しい許容値範囲外で前回と符号が変わっている場合、変曲点と見なす + primePoints[prevInflectionPoint] = i + prevInflectionPoint = i + } + } + + nonMovingPoints := make(map[int]int) + startIdx := -1 + for i, v := range ysPrime { + if math.Abs(v) <= tolerance { + // ゼロに近しい許容範囲内 + if startIdx < 0 { + // 開始INDEXが未設定の場合、設定 + startIdx = i + } else { + continue + } + } else { + // 許容範囲外になった場合 + if startIdx >= 0 && i-startIdx > space { + // 開始地点と終了地点を記録 + nonMovingPoints[startIdx] = i + startIdx = -1 + } + } + } + + if startIdx > 0 && (len(ysPrime)-1)-startIdx > space { + // 最後に停止があった場合、最後のキーフレを保持 + nonMovingPoints[startIdx] = len(ysPrime) - 1 + } + + return MergeInflectionPoints(values, []map[int]int{primePoints, nonMovingPoints}, space) +} + +func MergeInflectionPoints(values []float64, inflectionPointsList []map[int]int, space int) map[int]int { + inflectionAllIndexes := make([]int, 0) + for _, iPoints := range inflectionPointsList { + for i, j := range iPoints { + inflectionAllIndexes = append(inflectionAllIndexes, i) + inflectionAllIndexes = append(inflectionAllIndexes, j) + } + } + + SortInts(inflectionAllIndexes) + + inflectionPoints := make(map[int]int) + prevIdx := 0 + for i, iIdx := range inflectionAllIndexes { + if i == 0 { + prevIdx = iIdx + continue + } + if iIdx-prevIdx > space { + inflectionPoints[prevIdx] = iIdx + prevIdx = iIdx + } + } + + return inflectionPoints +} diff --git a/pkg/mmath/math_bt.go b/pkg/mmath/math_bt.go new file mode 100644 index 00000000..43a8855f --- /dev/null +++ b/pkg/mmath/math_bt.go @@ -0,0 +1,51 @@ +//go:build windows +// +build windows + +package mmath + +import ( + "github.com/go-gl/mathgl/mgl32" + + "github.com/miu200521358/mlib_go/pkg/mphysics/mbt" +) + +// Gl OpenGL座標系に変換された3次元ベクトルを返します +func (v *MVec3) GL() mgl32.Vec3 { + return mgl32.Vec3{float32(-v.GetX()), float32(v.GetY()), float32(v.GetZ())} +} + +// Bullet+OpenGL座標系に変換された3次元ベクトルを返します +func (v *MVec3) Bullet() mbt.BtVector3 { + return mbt.NewBtVector3(float32(-v.GetX()), float32(v.GetY()), float32(v.GetZ())) +} + +// Bullet+OpenGL座標系に変換されたクォータニオンベクトルを返します +func (v *MRotation) Bullet() mbt.BtQuaternion { + rx := float32(v.GetRadians().GetX()) + ry := float32(-v.GetRadians().GetY()) + rz := float32(-v.GetRadians().GetZ()) + return mbt.NewBtQuaternion(ry, rx, rz) +} + +// GL OpenGL座標系に変換されたクォータニオンベクトルを返します +func (m *MMat4) GL() mgl32.Mat4 { + mat := mgl32.Mat4{ + float32(m[0]), float32(-m[4]), float32(-m[8]), float32(m[12]), + float32(-m[1]), float32(m[5]), float32(m[9]), float32(m[13]), + float32(-m[2]), float32(m[6]), float32(m[10]), float32(m[14]), + float32(-m[3]), float32(m[7]), float32(m[11]), float32(m[15]), + } + return mat +} + +// NewMMat4ByMgl OpenGL座標系からMMD座標系に変換された行列を返します +func NewMMat4ByMgl(m *mgl32.Mat4) *MMat4 { + mm := NewMMat4ByValues( + float64(m.Col(0).X()), float64(-m.Col(1).X()), float64(-m.Col(2).X()), float64(-m.Col(3).X()), + float64(-m.Col(0).Y()), float64(m.Col(1).Y()), float64(m.Col(2).Y()), float64(m.Col(3).Y()), + float64(-m.Col(0).Z()), float64(m.Col(1).Z()), float64(m.Col(2).Z()), float64(m.Col(3).Z()), + float64(m.Col(0).W()), float64(m.Col(1).W()), float64(m.Col(2).W()), float64(m.Col(3).W()), + ) + m = nil + return mm +} diff --git a/pkg/mmath/mmat3.go b/pkg/mmath/mmat3.go new file mode 100644 index 00000000..78b267df --- /dev/null +++ b/pkg/mmath/mmat3.go @@ -0,0 +1,65 @@ +package mmath + +import ( + "github.com/go-gl/mathgl/mgl64" +) + +type MMat3 mgl64.Mat3 + +func NewMMat3() *MMat3 { + return &MMat3{ + 1, 0, 0, + 0, 1, 0, + 0, 0, 1, + } +} + +var ( + // Zero holds a zero matrix. + MMat3Zero = MMat3{ + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, + } + + // Ident holds an ident matrix. + MMat3Ident = MMat3{ + 1, 0, 0, + 0, 1, 0, + 0, 0, 1, + } +) + +// IsZero +func (m *MMat3) IsZero() bool { + return *m == MMat3Zero +} + +// IsIdent +func (m *MMat3) IsIdent() bool { + return m.NearEquals(&MMat3Ident, 1e-10) +} + +// String +func (m *MMat3) String() string { + return mgl64.Mat3(*m).String() +} + +func (m *MMat3) Copy() *MMat3 { + copied := NewMMat3ByValues(m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]) + return copied +} + +func NewMMat3ByValues(m11, m12, m13, m21, m22, m23, m31, m32, m33 float64) *MMat3 { + return (*MMat3)(&mgl64.Mat3{m11, m12, m13, m21, m22, m23, m31, m32, m33}) +} + +func (m *MMat3) NearEquals(other *MMat3, tolerance float64) bool { + return mgl64.Mat3(*m).ApproxEqualThreshold(mgl64.Mat3(*other), tolerance) +} + +// Mul は行列の掛け算を行います +func (m1 *MMat3) Mul(m2 *MMat3) { + m := mgl64.Mat3(*m1).Mul3(mgl64.Mat3(*m2)) + *m1 = MMat3(m) +} diff --git a/pkg/mmath/mmat4.go b/pkg/mmath/mmat4.go new file mode 100644 index 00000000..02edb944 --- /dev/null +++ b/pkg/mmath/mmat4.go @@ -0,0 +1,218 @@ +package mmath + +import ( + "math" + + "github.com/go-gl/mathgl/mgl64" +) + +type MMat4 mgl64.Mat4 + +var ( + // Zero holds a zero matrix. + MMat4Zero = MMat4{ + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + } + + // Ident holds an ident matrix. + MMat4Ident = MMat4{ + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1, + } +) + +func NewMMat4() *MMat4 { + return &MMat4{ + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1, + } +} + +func NewMMat4ByValues(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44 float64) *MMat4 { + return &MMat4{ + m11, m12, m13, m14, + m21, m22, m23, m24, + m31, m32, m33, m34, + m41, m42, m43, m44, + } +} + +func NewMMat4FromAxisAngle(axis *MVec3, angle float64) *MMat4 { + m := MMat4(mgl64.HomogRotate3D(angle, mgl64.Vec3(*axis))) + return &m +} + +func NewMMat4FromLookAt(eye, center, up *MVec3) *MMat4 { + m := MMat4(mgl64.LookAtV(mgl64.Vec3(*eye), mgl64.Vec3(*center), mgl64.Vec3(*up))) + return &m +} + +// IsZero +func (m *MMat4) IsZero() bool { + return *m == MMat4Zero +} + +// IsIdent +func (m *MMat4) IsIdent() bool { + return m.NearEquals(&MMat4Ident, 1e-10) +} + +// String +func (m *MMat4) String() string { + return mgl64.Mat4(*m).String() +} + +func (m *MMat4) Copy() *MMat4 { + copied := NewMMat4ByValues( + m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8], m[9], m[10], m[11], m[12], m[13], m[14], m[15]) + return copied +} + +// NearEquals +func (m *MMat4) NearEquals(other *MMat4, tolerance float64) bool { + return mgl64.Mat4(*m).ApproxEqualThreshold(mgl64.Mat4(*other), tolerance) +} + +// Trace returns the trace value for the matrix. +func (mat *MMat4) Trace() float64 { + return mgl64.Mat4(*mat).Trace() +} + +// Trace3 returns the trace value for the 3x3 sub-matrix. +func (mat *MMat4) Trace3() float64 { + return mgl64.Mat4(*mat).Mat3().Trace() +} + +// MulVec3 multiplies v (converted to a vec4 as (v_1, v_2, v_3, 1)) +// with mat and divides the result by w. Returns a new vec3. +func (mat *MMat4) MulVec3(other *MVec3) *MVec3 { + return other.ToMat4().Mul(mat.Copy()).Translation() +} + +// Translate adds v to the translation part of the matrix. +func (mat *MMat4) Translate(v *MVec3) *MMat4 { + *mat = *v.ToMat4().Mul(mat) + return mat +} + +func (mat *MMat4) Translated(v *MVec3) *MMat4 { + return v.ToMat4().Mul(mat) +} + +// 行列の移動情報 +func (mat *MMat4) Translation() *MVec3 { + return &MVec3{mat[3], mat[7], mat[11]} +} + +func (mat *MMat4) Scale(s *MVec3) *MMat4 { + *mat = *s.ToScaleMat4().Mul(mat) + return mat +} + +func (mat *MMat4) Scaled(s *MVec3) *MMat4 { + return s.ToScaleMat4().Mul(mat) +} + +func (mat *MMat4) Scaling() *MVec3 { + return &MVec3{mat[0], mat[5], mat[10]} +} + +func (mat *MMat4) Rotate(quat *MQuaternion) *MMat4 { + *mat = *quat.ToMat4().Mul(mat) + return mat +} + +func (mat *MMat4) Rotated(quat *MQuaternion) *MMat4 { + return quat.ToMat4().Mul(mat) +} + +func (mat *MMat4) Quaternion() *MQuaternion { + q := mgl64.Mat4ToQuat(mgl64.Mat4(*mat)) + return &MQuaternion{q.W, q.V} +} + +func (mat *MMat4) Mat3() *MMat3 { + return &MMat3{ + mat[0], mat[1], mat[2], + mat[4], mat[5], mat[6], + mat[8], mat[9], mat[10], + } +} + +// Transpose transposes the matrix. +func (mat *MMat4) Transpose() *MMat4 { + tm := mgl64.Mat4(*mat).Transpose() + return (*MMat4)(&tm) +} + +// Mul は行列の掛け算を行います +func (m1 *MMat4) Mul(m2 *MMat4) *MMat4 { + m := mgl64.Mat4(*m1).Mul4(mgl64.Mat4(*m2)) + *m1 = MMat4(m) + return m1 +} + +func (m1 *MMat4) Muled(m2 *MMat4) *MMat4 { + m := MMat4(mgl64.Mat4(*m1).Mul4(mgl64.Mat4(*m2))) + return &m +} + +func (mat *MMat4) MulScalar(v float64) *MMat4 { + m := mgl64.Mat4(*mat.Copy()).Mul(v) + *mat = MMat4(m) + return mat +} + +func (mat *MMat4) MuledScalar(v float64) *MMat4 { + copied := mat.Copy() + copied.MulScalar(v) + return copied +} + +func (m *MMat4) Det() float64 { + return mgl64.Mat4(*m).Det() +} + +// 逆行列 +func (m *MMat4) Inverse() *MMat4 { + im := mgl64.Mat4(*m).Inv() + return (*MMat4)(&im) +} + +func (mat *MMat4) Inverted() *MMat4 { + copied := mat.Copy() + return copied.Inverse() +} + +// ClampIfVerySmall ベクトルの各要素がとても小さい場合、ゼロを設定する +func (mat *MMat4) ClampIfVerySmall() *MMat4 { + epsilon := 1e-6 + for i := range mat { + if math.Abs(mat[i]) < epsilon { + mat[i] = 0 + } + } + return mat +} + +func (mat *MMat4) AxisX() *MVec3 { + v := MVec3(mgl64.Mat4(*mat).Row(0).Vec3()) + return &v +} + +func (mat *MMat4) AxisY() *MVec3 { + v := MVec3(mgl64.Mat4(*mat).Row(1).Vec3()) + return &v +} + +func (mat *MMat4) AxisZ() *MVec3 { + v := MVec3(mgl64.Mat4(*mat).Row(2).Vec3()) + return &v +} diff --git a/pkg/mmath/mmat4_test.go b/pkg/mmath/mmat4_test.go new file mode 100644 index 00000000..4716bdbf --- /dev/null +++ b/pkg/mmath/mmat4_test.go @@ -0,0 +1,389 @@ +package mmath + +import ( + "testing" +) + +func TestMMat4_NearEquals(t *testing.T) { + mat1 := &MMat4{ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + 13, 14, 15, 16, + } + + mat2 := &MMat4{ + 1.00000001, 2.00000001, 3.00000001, 4.00000001, + 5.00000001, 6.00000001, 7.00000001, 8.00000001, + 9.00000001, 10.00000001, 11.00000001, 12.00000001, + 13.00000001, 14.00000001, 15.00000001, 16.00000001, + } + + if !mat1.NearEquals(mat2, 1e-8) { + t.Errorf("Expected mat1 to be practically equal to mat2") + } + + mat3 := &MMat4{ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + 13, 14, 15, 16, + } + + mat4 := &MMat4{ + 1.0001, 2.0001, 3.0001, 4.0001, + 5.0001, 6.0001, 7.0001, 8.0001, + 9.0001, 10.0001, 11.0001, 12.0001, + 13.0001, 14.0001, 15.0001, 16.0001, + } + + if mat3.NearEquals(mat4, 1e-8) { + t.Errorf("Expected mat3 to not be practically equal to mat4") + } +} + +func TestMMat4_Translate(t *testing.T) { + mat := &MMat4{ + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1, + } + + v := &MVec3{1, 2, 3} + expectedMat := &MMat4{ + 1, 0, 0, 1, + 0, 1, 0, 2, + 0, 0, 1, 3, + 0, 0, 0, 1, + } + + mat.Translate(v) + + // Verify the matrix values + if !mat.NearEquals(expectedMat, 1e-10) { + t.Errorf("Expected mat to be %v, got %v", expectedMat, mat) + } + + { + m := NewMMat4ByValues( + -0.28213944, 0.48809647, 0.82592928, 0.0, + 0.69636424, 0.69636424, -0.17364818, 0.0, + -0.65990468, 0.52615461, -0.53636474, 0.0, + 0.0, 0.0, 0.0, 1.0, + ) + m.Translate(&MVec3{10, 20, 30}) + + expectedMat := NewMMat4ByValues( + -0.28213944, 0.48809647, 0.82592928, 31.7184134, + 0.69636424, 0.69636424, -0.17364818, 15.6814818, + -0.65990468, 0.52615461, -0.53636474, -12.1668968, + 0.0, 0.0, 0.0, 1.0, + ) + + if !m.NearEquals(expectedMat, 1e-8) { + t.Errorf("Expected mat to be %v, got %v", expectedMat, m) + } + + m.Translate(&MVec3{-8, -12, 3}) + + expectedMat2 := NewMMat4ByValues( + -0.28213944, 0.48809647, 0.82592928, 30.59615912, + 0.69636424, 0.69636424, -0.17364818, 1.23325246, + -0.65990468, 0.52615461, -0.53636474, -14.8106089, + 0.0, 0.0, 0.0, 1.0, + ) + + if !m.NearEquals(expectedMat2, 1e-8) { + t.Errorf("Expected mat to be %v, got %v", expectedMat2, m) + } + } +} + +func TestMMat4_Rotate(t *testing.T) { + m := NewMMat4ByValues( + -0.28213944, 0.48809647, 0.82592928, 0.0, + 0.69636424, 0.69636424, -0.17364818, 0.0, + -0.65990468, 0.52615461, -0.53636474, 0.0, + 0.0, 0.0, 0.0, 1.0, + ) + q := NewMQuaternionFromDegrees(10, 20, 30) + expectedQ := NewMQuaternionByValues(0.127679440695781, 0.144878125417369, 0.2685358227515692, 0.943714364147489) + + if !q.NearEquals(expectedQ, 1e-10) { + t.Errorf("Expected q to be %v, got %v", expectedQ, q) + } + + m.Rotate(q) + + expectedMat := NewMMat4ByValues( + -0.13337049, 0.79765275, 0.58818569, 0.0, + 0.98098506, 0.19068573, -0.03615618, 0.0, + -0.14099869, 0.5721792, -0.80791727, 0.0, + 0.0, 0.0, 0.0, 1.0, + ) + + if !m.NearEquals(expectedMat, 1e-7) { + t.Errorf("Expected mat to be %v, got %v", expectedMat, m) + } + + q2 := NewMQuaternionFromDegrees(-40, 20, -32) + + expectedMat2 := NewMMat4ByValues( + -0.50913704, -0.04344393, 0.85958833, 0.0, + 0.66451052, 0.61488424, 0.42466828, 0.0, + -0.54699658, 0.78741983, -0.28419139, 0.0, + 0.0, 0.0, 0.0, 1.0, + ) + + m.Rotate(q2) + + if !m.NearEquals(expectedMat2, 1e-7) { + t.Errorf("Expected mat to be %v, got %v", expectedMat2, m) + } +} + +func TestMMat4_Scale(t *testing.T) { + m := NewMMat4() + m.Rotate(NewMQuaternionFromDegrees(10, 20, 30)) + + expectedMat := NewMMat4ByValues( + 0.81379768, -0.46984631, 0.34202014, 0.0, + 0.54383814, 0.82317294, -0.16317591, 0.0, + -0.20487413, 0.31879578, 0.92541658, 0.0, + 0.0, 0.0, 0.0, 1.0, + ) + + if !m.NearEquals(expectedMat, 1e-8) { + t.Errorf("Expected mat to be %v, got %v", expectedMat, m) + } + + m.Translate(&MVec3{1, 2, 3}) + + expectedMat2 := NewMMat4ByValues( + 0.81379768, -0.46984631, 0.34202014, 0.90016549, + 0.54383814, 0.82317294, -0.16317591, 1.7006563, + -0.20487413, 0.31879578, 0.92541658, 3.20896716, + 0.0, 0.0, 0.0, 1.0, + ) + + if !m.NearEquals(expectedMat2, 1e-8) { + t.Errorf("Expected mat to be %v, got %v", expectedMat2, m) + } + + m.Scale(&MVec3{4, 5, 6}) + + expectedMat3 := NewMMat4ByValues( + 3.25519073, -2.34923155, 2.05212086, 0.90016549, + 2.17535257, 4.11586472, -0.97905547, 1.7006563, + -0.81949651, 1.59397889, 5.55249947, 3.20896716, + 0.0, 0.0, 0.0, 1.0, + ) + + if !m.NearEquals(expectedMat3, 1e-8) { + t.Errorf("Expected mat to be %v, got %v", expectedMat3, m) + } + + m.Scale(&MVec3{-0.8, -0.12, 0.3}) + + expectedMat4 := NewMMat4ByValues( + -2.60415258, 0.28190779, 0.61563626, 0.90016549, + -1.74028206, -0.49390377, -0.29371664, 1.7006563, + 0.65559721, -0.19127747, 1.66574984, 3.20896716, + 0.0, 0.0, 0.0, 1.0, + ) + + if !m.NearEquals(expectedMat4, 1e-8) { + t.Errorf("Expected mat to be %v, got %v", expectedMat4, m) + } +} + +func TestMMat4_Quaternion(t *testing.T) { + { + mat := &MMat4{ + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1, + } + expectedQ := NewMQuaternionByValues(0, 0, 0, 1) + + q := mat.Quaternion().Shorten() + + // Verify the quaternion values + if !q.NearEquals(expectedQ, 1e-10) { + t.Errorf("Expected q to be %v, got %v", expectedQ, q) + } + } + + { + expectedQ := NewMQuaternionByValues( + -0.37345048680206483, -0.7929168335960588, -0.11114230870887896, 0.46847093448041827) + m := NewMMat4ByValues( + -0.28213944, 0.48809647, 0.82592928, 0.0, + 0.69636424, 0.69636424, -0.17364818, 0.0, + -0.65990468, 0.52615461, -0.53636474, 0.0, + 0.0, 0.0, 0.0, 1.0, + ) + q := m.Quaternion().Shorten() + + if !q.NearEquals(expectedQ, 1e-8) { + t.Errorf("Expected q to be %v, got %v", expectedQ, q) + } + } + + { + expectedQ := NewMQuaternionByValues( + -0.12767944069578063, -0.14487812541736916, -0.2392983377447303, 0.9515485246437885) + m := NewMMat4ByValues( + 0.84349327, -0.41841204, 0.33682409, 0.0, + 0.49240388, 0.85286853, -0.17364818, 0.0, + -0.21461018, 0.31232456, 0.92541658, 0.0, + 0.0, 0.0, 0.0, 1.0) + q := m.Quaternion().Shorten() + + if !q.NearEquals(expectedQ, 1e-8) { + t.Errorf("Expected q to be %v, got %v", expectedQ, q) + } + } +} + +func TestMMat4_Mul(t *testing.T) { + a := &MMat4{ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + 13, 14, 15, 16, + } + + mat := &MMat4{ + 17, 18, 19, 20, + 21, 22, 23, 24, + 25, 26, 27, 28, + 29, 30, 31, 32, + } + + expectedMat := &MMat4{ + 250, 260, 270, 280, + 618, 644, 670, 696, + 986, 1028, 1070, 1112, + 1354, 1412, 1470, 1528, + } + mat.Mul(a) + + // Verify the matrix values + if !mat.NearEquals(expectedMat, 1e-10) { + t.Errorf("Expected mat to be %v, got %v", expectedMat, mat) + } +} + +func TestMMat4_Translation(t *testing.T) { + mat := &MMat4{ + 1, 0, 0, 1, + 0, 1, 0, 2, + 0, 0, 1, 3, + 0, 0, 0, 1, + } + + expectedVec := MVec3{1, 2, 3} + + result := mat.Translation() + + // Verify the vector values + if !result.NearEquals(&expectedVec, 1e-8) { + t.Errorf("Expected translation to be %v, got %v", expectedVec, result) + } +} + +func TestMMat4_Inverse(t *testing.T) { + mat1 := &MMat4{ + -0.28213944, 0.48809647, 0.82592928, 0.0, + 0.69636424, 0.69636424, -0.17364818, 0.0, + -0.65990468, 0.52615461, -0.53636474, 0.0, + 0.0, 0.0, 0.0, 1.0, + } + + expected1 := MMat4{ + -0.28213944, 0.69636424, -0.65990468, 0.0, + 0.48809647, 0.69636424, 0.52615461, 0.0, + 0.82592928, -0.17364818, -0.53636474, 0.0, + 0.0, 0.0, 0.0, 1.0, + } + + result1 := mat1.Inverse() + + // Verify the matrix values + if !result1.NearEquals(&expected1, 1e-8) { + t.Errorf("Expected inverse matrix to be %v, got %v", expected1, result1) + } + + mat2 := &MMat4{ + 0.45487413, 0.87398231, -0.17101007, 0.0, + -0.49240388, 0.08682409, -0.8660254, 0.0, + -0.74204309, 0.47813857, 0.46984631, 0.0, + 0.0, 0.0, 0.0, 1.0, + } + + expected2 := MMat4{ + 0.45487413, -0.49240388, -0.74204309, 0.0, + 0.87398231, 0.08682409, 0.47813857, 0.0, + -0.17101007, -0.8660254, 0.46984631, 0.0, + 0.0, 0.0, 0.0, 1.0, + } + + result2 := mat2.Inverse() + + // Verify the matrix values + if !result2.NearEquals(&expected2, 1e-8) { + t.Errorf("Expected inverse matrix to be %v, got %v", expected2, result2) + } +} + +func TestMMat4Mul(t *testing.T) { + mat1 := &MMat4{ + -0.28213944, 0.48809647, 0.82592928, 0.0, + 0.69636424, 0.69636424, -0.17364818, 0.0, + -0.65990468, 0.52615461, -0.53636474, 0.0, + 0.0, 0.0, 0.0, 1.0, + } + + mat2 := &MMat4{ + 0.81379768, -0.46984631, 0.34202014, 0., + 0.54383814, 0.82317294, -0.16317591, 0., + -0.20487413, 0.31879578, 0.92541658, 0., + 0., 0., 0., 1., + } + + mat1.Mul(mat2) + + expected1 := MMat4{ + -0.7824892813287088, 0.24998307969608058, 0.5702797450534226, 0, + 0.5274705571536827, 0.7528179178495863, 0.3937511650919034, 0, + -0.330885678728, 0.6089118411450198, -0.720930672993596, 0, + 0, 0, 0, 1, + } + + if !mat1.NearEquals(&expected1, 1e-8) { + t.Errorf("Expected matrix to be %v, got %v", expected1, mat1) + } + + mat3 := &MMat4{ + 0.79690454, 0.49796122, 0.34202014, 0., + -0.59238195, 0.53314174, 0.60402277, 0., + 0.11843471, -0.68395505, 0.71984631, 0., + 0., 0., 0., 1., + } + + mat1.Mul(mat3) + + expected3 := MMat4{ + -0.47407894480040325, 0.7823468930993056, 0.40395851874113675, 0, + 0.5448866127486663, 0.6210698073823508, -0.5633567882156808, 0, + -0.6916268772680453, -0.046964001131448774, -0.7207264663039717, 0, + 0, 0, 0, 1, + } + + if !mat1.NearEquals(&expected3, 1e-8) { + t.Errorf("Expected matrix to be %v, got %v", expected3, mat1) + } +} diff --git a/pkg/mmath/mquaternion.go b/pkg/mmath/mquaternion.go new file mode 100644 index 00000000..16bc1e1c --- /dev/null +++ b/pkg/mmath/mquaternion.go @@ -0,0 +1,694 @@ +package mmath + +import ( + "fmt" + "math" + + "github.com/go-gl/mathgl/mgl64" +) + +type MQuaternion mgl64.Quat + +func NewMQuaternion() *MQuaternion { + return &MQuaternion{1., mgl64.Vec3{0, 0, 0}} +} + +// 指定された値でクォータニオンを作成します。 +// ただし必ず最短距離クォータニオンにします +func NewMQuaternionByValuesShort(x, y, z, w float64) *MQuaternion { + qq := &MQuaternion{w, mgl64.Vec3{x, y, z}} + if !MQuaternionIdent.IsShortestRotation(qq) { + qq.Negate() + } + return qq +} + +// NewMQuaternionByValuesOriginal は、指定された値でクォータニオンを作成します。 +// ただし、強制的に最短距離クォータニオンにはしません +func NewMQuaternionByValues(x, y, z, w float64) *MQuaternion { + return &MQuaternion{w, mgl64.Vec3{x, y, z}} +} + +var ( + // Zero holds a zero quaternion. + MQuaternionZero = MQuaternion{} + + // Ident holds an ident quaternion. + MQuaternionIdent = MQuaternion{1., mgl64.Vec3{0, 0, 0}} +) + +// GetX returns the value of the X coordinate +func (v *MQuaternion) GetX() float64 { + return v.V[0] +} + +// SetX sets the value of the X coordinate +func (v *MQuaternion) SetX(x float64) { + v.V[0] = x +} + +// GetY returns the value of the Y coordinate +func (v *MQuaternion) GetY() float64 { + return v.V[1] +} + +// SetY sets the value of the Y coordinate +func (v *MQuaternion) SetY(y float64) { + v.V[1] = y +} + +// GetZ returns the value of the Z coordinate +func (v *MQuaternion) GetZ() float64 { + return v.V[2] +} + +// SetZ sets the value of the Z coordinate +func (v *MQuaternion) SetZ(z float64) { + v.V[2] = z +} + +// GetW returns the value of the W coordinate +func (v *MQuaternion) GetW() float64 { + return v.W +} + +// SetW sets the value of the W coordinate +func (v *MQuaternion) SetW(w float64) { + v.W = w +} + +func (v *MQuaternion) GetXYZ() *MVec3 { + return &MVec3{v.GetX(), v.GetY(), v.GetZ()} +} + +func (v *MQuaternion) SetXYZ(vec3 *MVec3) { + v.SetX(vec3.GetX()) + v.SetY(vec3.GetY()) + v.SetZ(vec3.GetZ()) +} + +// String T の文字列表現を返します。 +func (v *MQuaternion) String() string { + return fmt.Sprintf("[x=%.5f, y=%.5f, z=%.5f, w=%.5f]", v.GetX(), v.GetY(), v.GetZ(), v.GetW()) +} + +// MMD MMD(MikuMikuDance)座標系に変換されたクォータニオンベクトルを返します +func (v *MQuaternion) MMD() *MQuaternion { + return &MQuaternion{v.GetW(), mgl64.Vec3{v.GetX(), v.GetY(), v.GetZ()}} +} + +// NewMQuaternionFromAxisAngles は、軸周りの回転を表す四元数を返します。 +func NewMQuaternionFromAxisAngles(axis *MVec3, angle float64) *MQuaternion { + m := MMat4(mgl64.HomogRotate3D(angle, mgl64.Vec3(*axis.Normalize()))) + return m.Quaternion() +} + +// NewMQuaternionFromAxisAnglesRotate は、軸周りの回転を表す四元数を返します。 +func NewMQuaternionFromAxisAnglesRotate(axis *MVec3, angle float64) *MQuaternion { + m := MQuaternion(mgl64.QuatRotate(angle, mgl64.Vec3(*axis.Normalize()))) + return m.Normalize() +} + +// NewMQuaternionFromRadiansは、オイラー角（ラジアン）回転を表す四元数を返します。 +func NewMQuaternionFromRadians(xPitch, yHead, zRoll float64) *MQuaternion { + q := mgl64.AnglesToQuat(xPitch, yHead, zRoll, mgl64.XYZ).Normalize() + return &MQuaternion{q.W, q.V} +} + +// 参考URL: +// https://qiita.com/aa_debdeb/items/abe90a9bd0b4809813da +// https://site.nicovideo.jp/ch/userblomaga_thanks/archive/ar805999 + +// ToRadiansは、クォータニオンを三軸のオイラー角（ラジアン）回転を返します。 +func (v *MQuaternion) ToRadians() *MVec3 { + sx := -(2*v.GetY()*v.GetZ() - 2*v.GetX()*v.GetW()) + unlocked := math.Abs(sx) < 0.99999 + xPitch := math.Asin(math.Max(-1, math.Min(1, sx))) + var yHead, zRoll float64 + if unlocked { + yHead = math.Atan2(2*v.GetX()*v.GetZ()+2*v.GetY()*v.GetW(), 2*v.GetW()*v.GetW()+2*v.GetZ()*v.GetZ()-1) + zRoll = math.Atan2(2*v.GetX()*v.GetY()+2*v.GetZ()*v.GetW(), 2*v.GetW()*v.GetW()+2*v.GetY()*v.GetY()-1) + } else { + yHead = math.Atan2(-(2*v.GetX()*v.GetZ() - 2*v.GetY()*v.GetW()), 2*v.GetW()*v.GetW()+2*v.GetX()*v.GetX()-1) + zRoll = 0 + } + + return &MVec3{xPitch, yHead, zRoll} +} + +const ( + GIMBAL1_RAD = 88.0 / 180.0 * math.Pi + GIMBAL2_RAD = GIMBAL1_RAD * 2 + ONE_RAD = math.Pi + HALF_RAD = math.Pi / 2 +) + +// ToRadiansWithGimbalは、クォータニオンを三軸のオイラー角（ラジアン）回転を返します。 +// ジンバルロックが発生しているか否かのフラグも返します +func (v *MQuaternion) ToRadiansWithGimbal(axisIndex int) (*MVec3, bool) { + r := v.ToRadians() + + var other1Rad, other2Rad float64 + if axisIndex == 0 { + other1Rad = math.Abs(r.GetY()) + other2Rad = math.Abs(r.GetZ()) + } else if axisIndex == 1 { + other1Rad = math.Abs(r.GetX()) + other2Rad = math.Abs(r.GetZ()) + } else { + other1Rad = math.Abs(r.GetX()) + other2Rad = math.Abs(r.GetY()) + } + + // ジンバルロックを判定する + if other1Rad >= GIMBAL2_RAD && other2Rad >= GIMBAL2_RAD { + return r, true + } + + return r, false +} + +// NewMQuaternionFromDegreesは、オイラー角（度）回転を表す四元数を返します。 +func NewMQuaternionFromDegrees(xPitch, yHead, zRoll float64) *MQuaternion { + xPitchRadian := DegToRad(xPitch) + yHeadRadian := DegToRad(yHead) + zRollRadian := DegToRad(zRoll) + return NewMQuaternionFromRadians(xPitchRadian, yHeadRadian, zRollRadian) +} + +// Utility functions to convert between degrees and radians +func DegToRad(deg float64) float64 { + return deg * math.Pi / 180 +} + +func RadToDeg(rad float64) float64 { + return rad * 180 / math.Pi +} + +func ThetaToRad(theta float64) float64 { + return math.Asin(math.Max(-1.0, math.Min(1.0, theta))) +} + +// ToDegreesは、クォータニオンのオイラー角（度）回転を返します。 +func (quat *MQuaternion) ToDegrees() *MVec3 { + vec := quat.ToRadians() + return &MVec3{ + RadToDeg(vec.GetX()), + RadToDeg(vec.GetY()), + RadToDeg(vec.GetZ()), + } +} + +// ToDegreesは、クォータニオンのオイラー角（度）回転を返します。 +func (quat *MQuaternion) ToMMDDegrees() *MVec3 { + vec := quat.MMD().ToRadians() + return &MVec3{ + RadToDeg(vec.GetX()), + RadToDeg(-vec.GetY()), + RadToDeg(-vec.GetZ()), + } +} + +// Vec4は四元数をvec4.Tに変換する +func (quat *MQuaternion) Vec4() *MVec4 { + return &MVec4{quat.GetX(), quat.GetY(), quat.GetZ(), quat.GetW()} +} + +// Vec3は、クォータニオンのベクトル部分を返します。 +func (quat *MQuaternion) Vec3() *MVec3 { + vec3 := MVec3{quat.GetX(), quat.GetY(), quat.GetZ()} + return &vec3 +} + +// Mulは、クォータニオンの積を返します。 +func (q1 *MQuaternion) MulShort(q2 *MQuaternion) *MQuaternion { + mat1 := q1.ToMat4() + mat2 := q2.ToMat4() + mat1.Mul(mat2) + qq := mat1.Quaternion() + + return NewMQuaternionByValues(qq.GetX(), qq.GetY(), qq.GetZ(), qq.GetW()) +} + +func (q1 *MQuaternion) MuledShort(q2 *MQuaternion) *MQuaternion { + copied := q1.Copy() + copied.Mul(q2) + return copied +} + +// Mulは、クォータニオンの積を返します。 +func (q1 *MQuaternion) Mul(q2 *MQuaternion) *MQuaternion { + *q1 = MQuaternion(mgl64.Quat(*q1).Mul(mgl64.Quat(*q2))) + return q1 +} + +func (q1 *MQuaternion) Muled(q2 *MQuaternion) *MQuaternion { + q := MQuaternion(mgl64.Quat(*q1).Mul(mgl64.Quat(*q2))) + return &q +} + +// Normはクォータニオンのノルム値を返します。 +func (quat *MQuaternion) Norm() float64 { + return mgl64.Quat(*quat).Norm() +} + +// Lengthはクォータニオンの長さ（ノルム）を返します。 +func (quat *MQuaternion) Length() float64 { + return mgl64.Quat(*quat).Len() +} + +// Normalizeは、単位四位数に正規化する。 +func (quat *MQuaternion) Normalize() *MQuaternion { + q := mgl64.Quat(*quat).Normalize() + return &MQuaternion{q.W, q.V} +} + +// Normalizedは、単位を4進数に正規化したコピーを返す。 +func (quat *MQuaternion) Normalized() *MQuaternion { + copied := quat.Copy() + return copied.Normalize() +} + +// Negateはクォータニオンを反転する。 +func (quat *MQuaternion) Negate() *MQuaternion { + quat.SetX(-quat.GetX()) + quat.SetY(-quat.GetY()) + quat.SetZ(-quat.GetZ()) + quat.SetW(-quat.GetW()) + return quat +} + +// Negatedは反転したクォータニオンを返します。 +func (quat *MQuaternion) Negated() *MQuaternion { + return NewMQuaternionByValues(-quat.GetX(), -quat.GetY(), -quat.GetZ(), -quat.GetW()) +} + +// Inverseは、クォータニオンを反転させます。 +func (quat *MQuaternion) Inverse() *MQuaternion { + *quat = MQuaternion(mgl64.Quat(*quat).Inverse()) + return quat +} + +// Invertedは反転したクォータニオンを返します。 +func (quat *MQuaternion) Inverted() *MQuaternion { + q := MQuaternion(mgl64.Quat(*quat).Inverse()) + return &q +} + +// SetShortestRotationは、クォータニオンが quat から other の方向への最短回転を表していない場合、そのクォータニオンを否定します。 +// (quatの向きからotherの向きへの回転には2つの方向があります) +func (quat *MQuaternion) SetShortestRotation(other *MQuaternion) *MQuaternion { + if !quat.IsShortestRotation(other) { + quat.Negate() + } + return quat +} + +// IsShortestRotationは、a から b への回転が可能な限り最短の回転かどうかを返します。 +// (quatの向きから他の向きへの回転には2つの方向があります) +func (quat *MQuaternion) IsShortestRotation(other *MQuaternion) bool { + return quat.Dot(other) >= 0 +} + +// IsUnitQuatは、クォータニオンが単位クォータニオンの許容範囲内にあるかどうかを返します。 +func (quat *MQuaternion) IsUnitQuat(tolerance float64) bool { + norm := quat.Norm() + return norm >= (1.0-tolerance) && norm <= (1.0+tolerance) +} + +// Shortenは、最短回転に変換します。 +func (quat *MQuaternion) Shorten() *MQuaternion { + if quat.GetW() < 0 { + quat.Negate() + } + return quat +} + +// Dotは2つのクォータニオンの内積を返します。 +func (quat *MQuaternion) Dot(other *MQuaternion) float64 { + return mgl64.Quat(*quat).Dot(mgl64.Quat(*other)) +} + +// MuledScalarはクォータニオンにスカラーを掛け算します。 +func (quat *MQuaternion) MuledScalar(factor float64) *MQuaternion { + if factor == 0.0 { + return NewMQuaternion() + } else if factor == 1.0 { + return quat + } else if factor == -1.0 { + return quat.Inverted() + } + + // factor をかけて角度を制限 + if factor > 0 { + return MQuaternionIdent.Slerp(quat, factor) + } else { + return MQuaternionIdent.Slerp(quat, math.Abs(factor)).Inverse() + } +} + +// ToAxisAngleは、クォータニオンを軸と角度に変換します。 +func (quat *MQuaternion) ToAxisAngle() (*MVec3, float64) { + // クォータニオンを正規化 + quat.Normalize() + + // 角度を計算 + angle := 2 * math.Acos(quat.GetW()) + + // 軸の成分を計算 + s := math.Sqrt(1 - quat.GetW()*quat.GetW()) + if s < 1e-9 { + s = 1 + } + axis := NewMVec3() + axis.SetX(quat.GetX() / s) + axis.SetY(quat.GetY() / s) + axis.SetZ(quat.GetZ() / s) + + return axis, angle +} + +// Slerpはt (0,1)におけるaとbの間の球面線形補間クォータニオンを返します。 +// See http://en.wikipedia.org/wiki/Slerp +func (a *MQuaternion) Slerp(b *MQuaternion, t float64) *MQuaternion { + q := mgl64.QuatSlerp(mgl64.Quat(*a), mgl64.Quat(*b), t) + return (*MQuaternion)(&q) +} + +func (q *MQuaternion) Lerp(other *MQuaternion, t float64) *MQuaternion { + qq := mgl64.QuatLerp(mgl64.Quat(*q), mgl64.Quat(*other), t) + return (*MQuaternion)(&qq) +} + +// Vec3Diffは、2つのベクトル間の回転四元数を返します。 +func (a *MVec3) Vec3Diff(b *MVec3) *MQuaternion { + cr := a.Cross(b) + sr := math.Sqrt(2 * (1 + a.Dot(b))) + oosr := 1 / sr + + q := NewMQuaternionByValues(cr[0]*oosr, cr[1]*oosr, cr[2]*oosr, sr*0.5) + return q.Normalize() +} + +// ToDegreeは、クォータニオンを度に変換します。 +func (quat *MQuaternion) ToDegree() float64 { + return RadToDeg(quat.ToRadian()) +} + +// ToRadianは、クォータニオンをラジアンに変換します。 +func (quat *MQuaternion) ToRadian() float64 { + return 2 * math.Acos(math.Min(1, math.Max(-1, quat.Normalize().GetW()))) +} + +// ToSignedDegreeは、符号付き角度に変換します。 +func (quat *MQuaternion) ToSignedDegree() float64 { + // スカラー部分から基本的な角度を計算 + basicAngle := quat.ToDegree() + + // ベクトルの長さを使って、角度の正負を決定 + if quat.Vec3().Length() > 0 { + // ベクトルの向きに基づいて角度を調整 + if quat.GetW() >= 0 { + return basicAngle + } else { + return -basicAngle + } + } + + // ベクトル部分がない場合は基本角度をそのまま使用 + return basicAngle +} + +// ToSignedRadianは、符号付きラジアンに変換します。 +func (quat *MQuaternion) ToSignedRadian() float64 { + // スカラー部分から基本的な角度を計算 + basicAngle := quat.ToRadian() + + // ベクトルの長さを使って、角度の正負を決定 + if quat.Vec3().Length() > 0 { + // ベクトルの向きに基づいて角度を調整 + if quat.GetW() >= 0 { + return basicAngle + } else { + return -basicAngle + } + } + + // ベクトル部分がない場合は基本角度をそのまま使用 + return basicAngle +} + +// ToThetaは、自分ともうひとつの値vとのtheta（変位量）を返します。 +func (quat *MQuaternion) ToTheta(v *MQuaternion) float64 { + return math.Acos(math.Min(1, math.Max(-1, quat.Normalize().Dot(v.Normalize())))) +} + +// NewMQuaternionFromDirectionは、軸と角度からクォータニオンに変換します。 +func NewMQuaternionFromDirection(direction *MVec3, up *MVec3) *MQuaternion { + if direction.Length() == 0 { + return NewMQuaternion() + } + + zAxis := direction.Normalized() + xAxis := up.Cross(zAxis).Normalized() + + if xAxis.LengthSqr() == 0 { + // collinear or invalid up vector derive shortest arc to new direction + return NewMQuaternionRotate(&MVec3{0.0, 0.0, 1.0}, zAxis) + } + + yAxis := zAxis.Cross(xAxis) + + return NewMQuaternionFromAxes(xAxis, yAxis, zAxis).Normalize() +} + +// NewMQuaternionRotateはfromベクトルからtoベクトルまでの回転量を計算します。 +func NewMQuaternionRotate(fromV, toV *MVec3) *MQuaternion { + v := mgl64.QuatBetweenVectors(mgl64.Vec3(*fromV), mgl64.Vec3(*toV)) + return NewMQuaternionByValues(v.V[0], v.V[1], v.V[2], v.W) +} + +// NewMQuaternionFromAxesは、3つの軸ベクトルからクォータニオンを作成します。 +func NewMQuaternionFromAxes(xAxis, yAxis, zAxis *MVec3) *MQuaternion { + mat := NewMMat4ByValues( + xAxis.GetX(), xAxis.GetY(), xAxis.GetZ(), 0, + yAxis.GetX(), yAxis.GetY(), yAxis.GetZ(), 0, + zAxis.GetX(), zAxis.GetY(), zAxis.GetZ(), 0, + 0, 0, 0, 1, + ) + qq := mat.Quaternion() + return qq +} + +// SeparateByAxisは、グローバル軸に基づいてクォータニオンを2つのクォータニオン(捩りとそれ以外)に分割します。 +func (quat *MQuaternion) SeparateTwistByAxis(globalAxis *MVec3) (*MQuaternion, *MQuaternion) { + globalXAxis := globalAxis.Normalize() + + // X成分を抽出する ------------ + + // グローバル軸方向に伸ばす + globalXVec := quat.MulVec3(globalXAxis) + // YZの回転量（自身のねじれを無視する） + yzQQ := NewMQuaternionRotate(globalXAxis, globalXVec.Normalize()) + // 元々の回転量 から YZ回転 を除去して、除去されたX成分を求める + xQQ := yzQQ.Inverted().Mul(quat) + + return xQQ, yzQQ +} + +// SeparateByAxisは、グローバル軸に基づいてクォータニオンを3つのクォータニオン(x, y, z)に分割します。 +func (quat *MQuaternion) SeparateByAxis(globalAxis *MVec3) (*MQuaternion, *MQuaternion, *MQuaternion) { + localZAxis := MVec3{0, 0, -1} + globalXAxis := globalAxis.Normalize() + globalYAxis := localZAxis.Cross(globalXAxis) + globalZAxis := globalXAxis.Cross(globalYAxis) + + if globalYAxis.Length() == 0 { + localYAxis := MVec3UnitY + globalZAxis = localYAxis.Cross(globalXAxis) + globalYAxis = globalXAxis.Cross(globalZAxis) + } + + // X成分を抽出する ------------ + + // グローバル軸方向に伸ばす + globalXVec := quat.MulVec3(globalXAxis) + // YZの回転量（自身のねじれを無視する） + yzQQ := NewMQuaternionRotate(globalXAxis, globalXVec.Normalize()) + // 元々の回転量 から YZ回転 を除去して、除去されたX成分を求める + xQQ := yzQQ.Inverse().Mul(quat) + + // Y成分を抽出する ------------ + // グローバル軸方向に伸ばす + globalYVec := quat.MulVec3(globalYAxis) + // XZの回転量（自身のねじれを無視する） + xzQQ := NewMQuaternionRotate(globalYAxis, globalYVec.Normalize()) + // 元々の回転量 から XZ回転 を除去して、除去されたY成分を求める + yQQ := xzQQ.Inverse().Mul(quat) + + // Z成分を抽出する ------------ + // グローバル軸方向に伸ばす + globalZVec := quat.MulVec3(globalZAxis) + // XYの回転量（自身のねじれを無視する） + xyQQ := NewMQuaternionRotate(globalZAxis, globalZVec.Normalize()) + // 元々の回転量 から XY回転 を除去して、除去されたZ成分を求める + zQQ := xyQQ.Inverse().Mul(quat) + + return xQQ, yQQ, zQQ +} + +// Copyはクォータニオンのコピーを返します。 +func (qq *MQuaternion) Copy() *MQuaternion { + return NewMQuaternionByValues(qq.GetX(), qq.GetY(), qq.GetZ(), qq.GetW()) +} + +// Vectorはクォータニオンをベクトルに変換します。 +func (v *MQuaternion) Vector() []float64 { + return []float64{v.GetX(), v.GetY(), v.GetZ(), v.GetW()} +} + +// ToMat4はクォータニオンを4x4行列に変換します。 +func (v *MQuaternion) ToMat4() *MMat4 { + m := mgl64.Quat(*v).Normalize().Mat4() + return NewMMat4ByValues( + m[0], m[4], m[8], m[12], + m[1], m[5], m[9], m[13], + m[2], m[6], m[10], m[14], + m[3], m[7], m[11], m[15], + ) +} + +// ToFixedAxisRotationは軸制限されたクォータニオンの回転を計算します。 +func (quat *MQuaternion) ToFixedAxisRotation(fixedAxis *MVec3) *MQuaternion { + normalizedFixedAxis := fixedAxis.Normalized() + quatAxis := quat.GetXYZ().Normalized() + rad := quat.ToRadian() + if normalizedFixedAxis.Dot(quatAxis) < 0 { + rad *= -1 + } + result := NewMQuaternionFromAxisAngles(normalizedFixedAxis, rad) + return result +} + +func (quat *MQuaternion) IsIdent() bool { + return quat.NearEquals(&MQuaternionIdent, 1e-6) +} + +// NearEqualsは2つのクォータニオンがほぼ等しいかどうかを判定します。 +func (quat *MQuaternion) NearEquals(other *MQuaternion, epsilon float64) bool { + return mgl64.Quat(*quat).ApproxEqualThreshold(mgl64.Quat(*other), epsilon) +} + +// MulVec3は、ベクトルvをクォータニオンで回転させた結果の新しいベクトルを返します。 +func (quat *MQuaternion) MulVec3(v *MVec3) *MVec3 { + r := mgl64.Quat(*quat).Rotate(mgl64.Vec3(*v)) + return &MVec3{r[0], r[1], r[2]} +} + +// VectorToDegreeは、与えられた2つのベクトルから角度に変換します。 +func VectorToDegree(a *MVec3, b *MVec3) float64 { + return RadToDeg(VectorToRadian(a, b)) +} + +// VectorToRadianは、与えられた2つのベクトルからラジアン角度に変換します。 +func VectorToRadian(a *MVec3, b *MVec3) float64 { + p := a.Dot(b) + normA := a.Length() + normB := b.Length() + + // 角度を計算 + cosAngle := p / (normA * normB) + rad := math.Acos(math.Min(1, math.Max(-1, cosAngle))) + + return rad +} + +// FindSlerpTは始点Q1、終点Q2、中間点Qtが与えられたとき、Slerp(Q1, Q2, t) ? Qtとなるtを見つけます。 +func FindSlerpT(Q1, Q2, Qt *MQuaternion) float64 { + tol := 1e-15 + return findSlerpTGoldenSection(Q1, Q2, Qt, tol) +} + +// findSlerpTGoldenSectionは一貫したクォータニオンサインを確保した上でtを見つけます。 +func findSlerpTGoldenSection(Q1, Q2, Qt *MQuaternion, tol float64) float64 { + phi := (1 + math.Sqrt(5)) / 2 + maxIterations := 100 + + // 初期範囲の設定 + a := 0.0 + b := 1.0 + c := b - (b-a)/phi + d := a + (b-a)/phi + + q2 := Q2 + if Q1.Dot(Q2) < 0 { + q2 = Q2.Negated() + } + Q2 = q2 + + // 誤差の計算関数 + errorFunc := func(t float64) float64 { + tQuat := Q1.Slerp(Q2, t) + dot := math.Abs(tQuat.Dot(Qt)) + return 1 - dot + } + + // 初期の誤差計算 + fc := errorFunc(c) + fd := errorFunc(d) + + for i := 0; i < maxIterations; i++ { + if math.Abs(b-a) < tol { + return (a + b) / 2 + } + if fc < fd { + b = d + d = c + fd = fc + c = b - (b-a)/phi + fc = errorFunc(c) + } else { + a = c + c = d + fc = fd + d = a + (b-a)/phi + fd = errorFunc(d) + } + } + + // 終了条件に達したら範囲の中間点を返す + return (a + b) / 2 +} + +// FindSlerpTBisectionは始点Q1、終点Q2、中間点Qtが与えられたとき、Slerp(Q1, Q2, t) ? Qtとなるtを二分法で見つけます。 +func FindSlerpTBisection(Q1, Q2, Qt *MQuaternion, tol float64) float64 { + low := 0.00001 + high := 0.99999 + mid := (low + high) / 2 + + maxIterations := 50 + + for i := 0; i < maxIterations; i++ { + // Slerpで中間のクオータニオンを計算し、誤差を測定 + midQuat := Q1.Slerp(Q2, mid) + dot := math.Abs(midQuat.Dot(Qt)) + err := 1 - dot + + // 誤差が許容範囲内であれば終了 + if err < tol { + return mid + } + + // 中間点の誤差に基づいて範囲を狭める + lowQuat := Q1.Slerp(Q2, low) + if lowQuat.Dot(Qt) < midQuat.Dot(Qt) { + low = mid + } else { + high = mid + } + + mid = (low + high) / 2 + } + + return mid +} diff --git a/pkg/mmath/mquaternion_test.go b/pkg/mmath/mquaternion_test.go new file mode 100644 index 00000000..d25db1e8 --- /dev/null +++ b/pkg/mmath/mquaternion_test.go @@ -0,0 +1,528 @@ +package mmath + +import ( + "math" + "testing" +) + +func TestMQuaternionToEulerAngles(t *testing.T) { + quat := NewMQuaternionByValues(0.7071067811865476, 0.0, 0.0, 0.7071067811865476) + expected := MVec3{1.5707963267948966, 0, 0} + + result := quat.ToRadians() + + if math.Abs(result.GetX()-expected.GetX()) > 1e-10 || math.Abs(result.GetY()-expected.GetY()) > 1e-10 || math.Abs(result.GetZ()-expected.GetZ()) > 1e-10 { + t.Errorf("ToEulerAngles failed. Expected %v, got %v", expected, result) + } +} + +func TestMQuaternionToDegree(t *testing.T) { + quat := NewMQuaternionByValues(0.08715574274765817, 0.0, 0.0, 0.9961946980917455) + expected := 10.0 + + result := quat.ToDegree() + + if math.Abs(result-expected) > 1e-10 { + t.Errorf("ToDegree failed. Expected %v, got %v", expected, result) + } +} + +func TestMQuaternionToDegree2(t *testing.T) { + quat := NewMQuaternionByValues(0.12767944069578063, 0.14487812541736916, 0.2392983377447303, 0.9515485246437885) + expected := 35.81710117358426 + + result := quat.ToDegree() + + if math.Abs(result-expected) > 1e-10 { + t.Errorf("ToDegree failed. Expected %v, got %v", expected, result) + } +} + +func TestMQuaternionToSignedDegree(t *testing.T) { + quat := NewMQuaternionByValues(0.08715574274765817, 0.0, 0.0, 0.9961946980917455) + expected := 10.0 + + result := quat.ToSignedDegree() + + if math.Abs(result-expected) > 1e-10 { + t.Errorf("ToDegree failed. Expected %v, got %v", expected, result) + } +} + +func TestMQuaternionToSignedDegree2(t *testing.T) { + quat := NewMQuaternionByValues(0.4738680537545347, 0.20131048764138487, -0.48170221425083437, 0.7091446481376844) + expected := 89.66927179998277 + + result := quat.ToSignedDegree() + + if math.Abs(result-expected) > 1e-10 { + t.Errorf("ToDegree failed. Expected %v, got %v", expected, result) + } +} + +func TestMQuaternionDot(t *testing.T) { + // np.array([60, -20, -80]), + quat1 := NewMQuaternionByValues(0.4738680537545347, 0.20131048764138487, -0.48170221425083437, 0.7091446481376844) + // np.array([10, 20, 30]), + quat2 := NewMQuaternionByValues(0.12767944069578063, 0.14487812541736916, 0.2392983377447303, 0.9515485246437885) + expected := 0.6491836986795888 + + result := quat1.Dot(quat2) + + if math.Abs(result-expected) > 1e-10 { + t.Errorf("ToDegree failed. Expected %v, got %v", expected, result) + } + + // np.array([10, 23, 45]), + quat3 := NewMQuaternionByValues(0.1549093965157679, 0.15080756177478563, 0.3575205710320892, 0.908536845412201) + // np.array([12, 20, 42]), + quat4 := NewMQuaternionByValues(0.15799222008931638, 0.1243359045760714, 0.33404459937562386, 0.9208654879256133) + + expected2 := 0.9992933154462645 + + result2 := quat3.Dot(quat4) + + if math.Abs(result2-expected2) > 1e-10 { + t.Errorf("ToDegree failed. Expected %v, got %v", expected2, result2) + } +} + +func TestMQuaternionSlerp(t *testing.T) { + // np.array([60, -20, -80]) + quat1 := NewMQuaternionByValues(0.4738680537545347, 0.20131048764138487, -0.48170221425083437, 0.7091446481376844) + // np.array([10, 20, 30]), + quat2 := NewMQuaternionByValues(0.12767944069578063, 0.14487812541736916, 0.2392983377447303, 0.9515485246437885) + tValue := 0.3 + expected := NewMQuaternionByValues(0.3973722198386427, 0.19936467087655246, -0.27953105525419597, 0.851006131620254) + + result := quat1.Slerp(quat2, tValue) + + if math.Abs(result.GetX()-expected.GetX()) > 1e-10 || math.Abs(result.GetY()-expected.GetY()) > 1e-10 || math.Abs(result.GetZ()-expected.GetZ()) > 1e-10 || math.Abs(result.GetW()-expected.GetW()) > 1e-10 { + t.Errorf("Slerp failed. Expected %v, got %v", expected, result) + } +} + +func TestMQuaternionToFixedAxisRotation(t *testing.T) { + { + quat := NewMQuaternionByValues(0.5, 0.5, 0.5, 0.5) + fixedAxis := MVec3{1, 0, 0} + expected := NewMQuaternionByValues(0.866025403784439, 0, 0, 0.5) + + result := quat.ToFixedAxisRotation(&fixedAxis) + + if !result.NearEquals(expected, 1e-10) { + t.Errorf("ToFixedAxisRotation failed. Expected %v, got %v", expected, result) + } + } + { + quat := NewMQuaternionByValues(0.5, 0.5, 0.5, 0.5) + fixedAxis := MVec3{0, 1, 0} + expected := NewMQuaternionByValues(0, 0.866025403784439, 0, 0.5) + + result := quat.ToFixedAxisRotation(&fixedAxis) + + if !result.NearEquals(expected, 1e-10) { + t.Errorf("ToFixedAxisRotation failed. Expected %v, got %v", expected, result) + } + } + { + quat := NewMQuaternionByValues(0.5, 0.5, 0.5, 0.5) + fixedAxis := MVec3{0, 0, 1} + expected := NewMQuaternionByValues(0, 0, 0.866025403784439, 0.5) + + result := quat.ToFixedAxisRotation(&fixedAxis) + + if !result.NearEquals(expected, 1e-10) { + t.Errorf("ToFixedAxisRotation failed. Expected %v, got %v", expected, result) + } + } + { + quat := NewMQuaternionByValues(0.5, 0.5, 0.5, 0.5) + fixedAxis := MVec3{0.5, 0.7, 0.2} + expected := NewMQuaternionByValues(0.49029033784546, 0.686406472983644, 0.196116135138184, 0.5) + + result := quat.ToFixedAxisRotation(&fixedAxis) + + if !result.NearEquals(expected, 1e-10) { + t.Errorf("ToFixedAxisRotation failed. Expected %v, got %v", expected, result) + } + } + { + quat := NewMQuaternionByValues(0.5, 0.5, 0.5, -0.5) + fixedAxis := MVec3{0.5, -0.7, 0.2} + expected := NewMQuaternionByValues(-0.49029033784546, 0.686406472983644, -0.196116135138184, 0.5) + + result := quat.ToFixedAxisRotation(&fixedAxis) + + if !result.NearEquals(expected, 1e-10) { + t.Errorf("ToFixedAxisRotation failed. Expected %v, got %v", expected, result) + } + } +} + +func TestMQuaternionNormalized(t *testing.T) { + quat1 := NewMQuaternionByValues(2, 3, 4, 1) + expected1 := NewMQuaternionByValues(0.36514837, 0.54772256, 0.73029674, 0.18257419) + + result1 := quat1.Normalized() + + if !result1.NearEquals(expected1, 1e-7) { + t.Errorf("Normalized failed. Expected %v, got %v", expected1, result1) + } + + quat2 := NewMQuaternionByValues(0, 0, 0, 1) + expected2 := NewMQuaternionByValues(0, 0, 0, 1) + + result2 := quat2.Normalized() + + if !result2.NearEquals(expected2, 1e-10) { + t.Errorf("Normalized failed. Expected %v, got %v", expected2, result2) + } + + quat3 := NewMQuaternion() + expected3 := NewMQuaternionByValues(0, 0, 0, 1) + + result3 := quat3.Normalized() + + if !result3.NearEquals(expected3, 1e-10) { + t.Errorf("Normalized failed. Expected %v, got %v", expected3, result3) + } +} + +func TestFromEulerAnglesDegrees(t *testing.T) { + expected1 := NewMQuaternionByValues(0, 0, 0, 1) + + result1 := NewMQuaternionFromDegrees(0, 0, 0) + + if !result1.NearEquals(expected1, 1e-8) { + t.Errorf("FromEulerAnglesDegrees failed. Expected %v, got %v", expected1, result1) + } + + expected2 := NewMQuaternionByValues(0.08715574, 0.0, 0.0, 0.9961947) + + result2 := NewMQuaternionFromDegrees(10, 0, 0) + + if !result2.NearEquals(expected2, 1e-6) { + t.Errorf("FromEulerAnglesDegrees failed. Expected %v, got %v", expected2, result2) + } + + expected3 := NewMQuaternionByValues(0.12767944069578063, 0.14487812541736914, 0.2685358227515692, 0.943714364147489) + + result3 := NewMQuaternionFromDegrees(10, 20, 30) + + if !result3.NearEquals(expected3, 1e-5) { + t.Errorf("FromEulerAnglesDegrees failed. Expected %v, got %v", expected3, result3) + } + + expected4 := NewMQuaternionByValues(0.47386805375453483, 0.20131048764138493, -0.6147244358103234, 0.5975257510887351) + + result4 := NewMQuaternionFromDegrees(60, -20, -80) + + if !result4.NearEquals(expected4, 1e-5) { + t.Errorf("FromEulerAnglesDegrees failed. Expected %v, got %v", expected4, result4) + } +} + +func TestMQuaternionToEulerAnglesDegrees(t *testing.T) { + expected1 := &MVec3{0, 0, 0} + + qq1 := NewMQuaternionByValues(0, 0, 0, 1) + result1 := qq1.ToDegrees() + + if !result1.NearEquals(expected1, 1e-8) { + t.Errorf("ToEulerAnglesDegrees failed. Expected %v, got %v", expected1, result1) + } + + expected2 := &MVec3{10, 0, 0} + + qq2 := NewMQuaternionByValues(0.08715574274765817, 0.0, 0.0, 0.9961946980917455) + result2 := qq2.ToDegrees() + + if !result2.NearEquals(expected2, 1e-5) { + t.Errorf("ToEulerAnglesDegrees failed. Expected %v, got %v", expected2, result2) + } + + expected3 := &MVec3{10, 20, 30} + + qq3 := NewMQuaternionByValues(0.12767944, 0.14487813, 0.23929834, 0.95154852) + result3 := qq3.ToDegrees() + + if !result3.NearEquals(expected3, 1e-5) { + t.Errorf("ToEulerAnglesDegrees failed. Expected %v, got %v", expected3, result3) + } + + expected4 := &MVec3{60, -20, -80} + + qq4 := NewMQuaternionByValues(0.47386805, 0.20131049, -0.48170221, 0.70914465) + result4 := qq4.ToDegrees() + + if !result4.NearEquals(expected4, 1e-5) { + t.Errorf("ToEulerAnglesDegrees failed. Expected %v, got %v", expected4, result4) + } +} + +func TestMQuaternionMultiply(t *testing.T) { + expected1 := NewMQuaternionByValues( + 0.6594130183457979, 0.11939693791117263, -0.24571599091322077, 0.7003873887093154) + q11 := NewMQuaternionByValues( + 0.4738680537545347, + 0.20131048764138487, + -0.48170221425083437, + 0.7091446481376844, + ) + q12 := NewMQuaternionByValues( + 0.12767944069578063, + 0.14487812541736916, + 0.2392983377447303, + 0.9515485246437885, + ) + result1 := q11.Mul(q12) + + if !result1.NearEquals(expected1, 1e-8) { + t.Errorf("MQuaternionMultiply failed. Expected %v, got %v", expected1, result1) + } + + expected2 := NewMQuaternionByValues( + 0.4234902605993554, 0.46919555165368526, -0.3316158006229952, 0.7003873887093154) + q21 := NewMQuaternionByValues( + 0.12767944069578063, + 0.14487812541736916, + 0.2392983377447303, + 0.9515485246437885, + ) + q22 := NewMQuaternionByValues( + 0.4738680537545347, + 0.20131048764138487, + -0.48170221425083437, + 0.7091446481376844, + ) + result2 := q21.Mul(q22) + + if !result2.NearEquals(expected2, 1e-8) { + t.Errorf("MQuaternionMultiply failed. Expected %v, got %v", expected2, result2) + } +} + +func TestNewMQuaternionFromAxisAngles(t *testing.T) { + expected1 := NewMQuaternionByValues( + 0.0691722994246875, 0.138344598849375, 0.207516898274062, 0.965925826289068) + result1 := NewMQuaternionFromAxisAnglesRotate(&MVec3{1, 2, 3}, DegToRad(30)) + + if !result1.NearEquals(expected1, 1e-5) { + t.Errorf("NewMQuaternionFromAxisAngles failed. Expected %v, got %v", expected1, result1) + } + + expected2 := NewMQuaternionByValues( + -0.116858651016609, 0.779057673444061, -0.389528836722031, 0.477158760259608) + result2 := NewMQuaternionFromAxisAnglesRotate(&MVec3{-3, 20, -10}, DegToRad(123)) + + if !result2.NearEquals(expected2, 1e-5) { + t.Errorf("NewMQuaternionFromAxisAngles failed. Expected %v, got %v", expected2, result2) + } + + axis := MVec3{1, 0, 0} + angle := math.Pi / 2 + expected := NewMQuaternionByValues(0.707106781186548, 0, 0, 0.7071067811865476) + + result := NewMQuaternionFromAxisAnglesRotate(&axis, angle) + + if !result.NearEquals(expected, 1e-10) { + t.Errorf("NewMQuaternionFromAxisAngles failed. Expected %v, got %v", expected, result) + } +} +func TestMQuaternionFromDirection(t *testing.T) { + expected1 := NewMQuaternionByValues( + -0.3115472173245163, -0.045237910083403, -0.5420603160713341, 0.7791421414666787) + result1 := NewMQuaternionFromDirection(&MVec3{1, 2, 3}, &MVec3{4, 5, 6}) + + if !result1.NearEquals(expected1, 1e-7) { + t.Errorf("MQuaternionFromDirection failed. Expected %v, got %v", expected1, result1) + } + + expected2 := NewMQuaternionByValues( + 0.543212292317204, 0.6953153333136457, 0.20212324833235548, -0.42497433477564167) + result2 := NewMQuaternionFromDirection(&MVec3{-10, 20, -15}, &MVec3{40, -5, 6}) + + if !result2.NearEquals(expected2, 1e-7) { + t.Errorf("MQuaternionFromDirection failed. Expected %v, got %v", expected2, result2) + } + +} + +func TestMQuaternionRotate(t *testing.T) { + expected1 := NewMQuaternionByValues( + -0.04597839511020707, 0.0919567902204141, -0.04597839511020706, 0.9936377222602503) + result1 := NewMQuaternionRotate(&MVec3{1, 2, 3}, &MVec3{4, 5, 6}) + + if !result1.NearEquals(expected1, 1e-5) { + t.Errorf("MQuaternionRotate failed. Expected %v, got %v", expected1, result1) + } + + expected2 := NewMQuaternionByValues( + 0.042643949239185255, -0.511727390870223, -0.7107324873197542, 0.48080755245182594) + result2 := NewMQuaternionRotate(&MVec3{-10, 20, -15}, &MVec3{40, -5, 6}) + + if !result2.NearEquals(expected2, 1e-5) { + t.Errorf("MQuaternionRotate failed. Expected %v, got %v", expected2, result2) + } +} + +func TestMQuaternionToMatrix4x4(t *testing.T) { + expected := NewMMat4ByValues( + 0.45487413, 0.87398231, -0.17101007, 0., -0.49240388, 0.08682409, -0.8660254, 0., + -0.74204309, 0.47813857, 0.46984631, 0., + 0., 0., 0., 1., + ) + + qq1 := NewMQuaternionByValues( + 0.4738680537545347, 0.20131048764138487, -0.48170221425083437, 0.7091446481376844) + result1 := qq1.ToMat4() + + if !result1.NearEquals(expected, 1e-5) { + t.Errorf("ToMatrix4x4 failed. Expected %v, got %v", expected, qq1) + } + + expected2 := NewMMat4ByValues( + -0.28213944, 0.48809647, 0.82592928, 0., + 0.69636424, 0.69636424, -0.17364818, 0., + -0.65990468, 0.52615461, -0.53636474, 0., + 0., 0., 0., 1., + ) + + // np.array([10, 123, 45]) + qq2 := NewMQuaternionByValues( + 0.3734504874442106, 0.7929168339527322, 0.11114231087966482, 0.4684709324967611) + result2 := qq2.ToMat4() + + if !result2.NearEquals(expected2, 1e-5) { + t.Errorf("ToMatrix4x4 failed. Expected %v, got %v", expected, qq1) + } +} + +func TestMQuaternionMulVec3(t *testing.T) { + expected := &MVec3{16.89808539, -29.1683191, 16.23772986} + // np.array([60, -20, -80]), + qq := NewMQuaternionByValues( + 0.4738680537545347, 0.20131048764138487, -0.48170221425083437, 0.7091446481376844) + result := qq.MulVec3(&MVec3{10, 20, 30}) + + if !result.NearEquals(expected, 1e-5) { + t.Errorf("MulVec3 failed. Expected %v, got %v", expected, result) + } +} + +func TestMQuaternionVectorToDegree(t *testing.T) { + expected := 81.78678929826181 + + result := VectorToDegree(&MVec3{10, 20, 30}, &MVec3{30, -20, 10}) + + if math.Abs(result-expected) > 1e-10 { + t.Errorf("VectorToDegree failed. Expected %v, got %v", expected, result) + } +} + +func TestMQuaternionMulScalar(t *testing.T) { + { + quat := NewMQuaternionFromDegrees(90, 0, 0) + factor := 0.5 + expected := NewMQuaternionFromDegrees(45, 0, 0) + + result := quat.MuledScalar(factor) + + if !result.NearEquals(expected, 1e-10) { + t.Errorf("MulScalar failed. Expected %v, got %v(%v)", expected, result, result.ToDegrees()) + } + } + + { + quat := NewMQuaternionFromDegrees(-24.53194, 180, 180) + factor := 0.5 + expected := NewMQuaternionFromDegrees(77.73403, 0, 0) + + result := quat.MuledScalar(factor) + + if !result.NearEquals(expected, 1e-6) { + t.Errorf("MulScalar failed. Expected %v, got %v(%v)", expected, result, result.ToDegrees()) + } + } + + { + quat := NewMQuaternionFromDegrees(-24.53194, 180, 180) + factor := -0.5 + expected := NewMQuaternionFromDegrees(-77.73403, 0, 0) + + result := quat.MuledScalar(factor) + + if !result.NearEquals(expected, 1e-6) { + t.Errorf("MulScalar failed. Expected %v, got %v(%v)", expected, result, result.ToDegrees()) + } + } + + { + quat := NewMQuaternionByValues(0, 0, 0, 1) + factor := 0.5 + expected := NewMQuaternionByValues(0, 0, 0, 1) + + result := quat.MuledScalar(factor) + + if !result.NearEquals(expected, 1e-10) { + t.Errorf("MulScalar failed. Expected %v, got %v(%v)", expected, result, result.ToDegrees()) + } + } + + { + quat := NewMQuaternionByValues(0.08715574274765817, 0.0, 0.0, 0.9961946980917455) + factor := 1.0 + expected := NewMQuaternionByValues(0.08715574274765817, 0.0, 0.0, 0.9961946980917455) + + result := quat.MuledScalar(factor) + + if !result.NearEquals(expected, 1e-10) { + t.Errorf("MulScalar failed. Expected %v, got %v(%v)", expected, result, result.ToDegrees()) + } + } +} + +func TestMQuaternion_ToMat4(t *testing.T) { + // Test case 1: Identity quaternion + quat := NewMQuaternionByValues(0, 0, 0, 1).Normalize() + expectedMat := NewMMat4ByValues( + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1, + ) + actualMat := quat.ToMat4() + + if !actualMat.NearEquals(expectedMat, 1e-10) { + t.Errorf("Test case 1 failed: Expected %v, but got %v", expectedMat, actualMat) + } + + // Test case 2: Non-identity quaternion + quat = NewMQuaternionByValues(0.5, 0.5, 0.5, 0.5) + expectedMat = NewMMat4ByValues( + 0., 0., 1., 0., + 1., 0., 0., 0., + 0., 1., 0., 0., + 0., 0., 0., 1.) + actualMat = quat.ToMat4() + + if !actualMat.NearEquals(expectedMat, 1e-10) { + t.Errorf("Test case 2 failed: Expected %v, but got %v", expectedMat, actualMat) + } + + // Test case 3: Random quaternion + quat = NewMQuaternionByValues(0.1, 0.2, 0.3, 0.4) + expectedMat = NewMMat4ByValues( + 0.13333333, -0.66666667, 0.73333333, 0., + 0.93333333, 0.33333333, 0.13333333, 0., + -0.33333333, 0.66666667, 0.66666667, 0., + 0., 0., 0., 1., + ) + actualMat = quat.ToMat4() + + if !actualMat.NearEquals(expectedMat, 1e-5) { + t.Errorf("Test case 3 failed: Expected %v, but got %v", expectedMat, actualMat) + } + +} diff --git a/pkg/mmath/mrect.go b/pkg/mmath/mrect.go new file mode 100644 index 00000000..b39b050e --- /dev/null +++ b/pkg/mmath/mrect.go @@ -0,0 +1,38 @@ +package mmath + +import ( + "fmt" +) + +type MRect struct { + Min *MVec2 + Max *MVec2 +} + +func NewMRect() MRect { + return MRect{Min: &MVec2{0, 0}, Max: &MVec2{0, 0}} +} + +// String は MRect の文字列表現を返します。 +func (v MRect) String() string { + return fmt.Sprintf("[min=(%.5f, %.5f), max=(%.5f, %.5f)]", v.Min[0], v.Min[1], v.Max[0], v.Max[1]) +} + +// ContainsPoint returns if a point is contained within the rectangle. +func (rect *MRect) ContainsPoint(p *MVec2) bool { + return p[0] >= rect.Min[0] && p[0] <= rect.Max[0] && + p[1] >= rect.Min[1] && p[1] <= rect.Max[1] +} + +// Contains returns if other Rect is contained within the rectangle. +func (rect *MRect) Contains(other *MRect) bool { + return rect.Min[0] <= other.Min[0] && + rect.Min[1] <= other.Min[1] && + rect.Max[0] >= other.Max[0] && + rect.Max[1] >= other.Max[1] +} + +// Area calculates the area of the rectangle. +func (rect *MRect) Area() float64 { + return (rect.Max[0] - rect.Min[0]) * (rect.Max[1] - rect.Min[1]) +} diff --git a/pkg/mmath/mrotation.go b/pkg/mmath/mrotation.go new file mode 100644 index 00000000..e1c5d298 --- /dev/null +++ b/pkg/mmath/mrotation.go @@ -0,0 +1,148 @@ +package mmath + +import ( + "fmt" + "math" + "reflect" +) + +type MRotation struct { + radians *MVec3 + degrees *MVec3 + quaternion *MQuaternion +} + +func NewRotation() *MRotation { + model := &MRotation{ + radians: nil, + degrees: nil, + quaternion: nil, + } + return model +} + +// NewRotationFromRadians はラジアン角度からで回転を表すモデルを生成します。 +func NewRotationFromRadians(vRadians *MVec3) *MRotation { + model := NewRotation() + model.SetRadians(vRadians) + return model +} + +// NewRotationFromDegrees は度数角度からで回転を表すモデルを生成します。 +func NewRotationFromDegrees(vDegrees *MVec3) *MRotation { + model := NewRotation() + model.SetDegrees(vDegrees) + return model +} + +// NewRotationFromQuaternion はクォータニオンからで回転を表すモデルを生成します。 +func NewRotationFromQuaternion(vQuaternion *MQuaternion) *MRotation { + model := NewRotation() + model.SetQuaternion(vQuaternion) + return model +} + +func (m *MRotation) GetQuaternion() *MQuaternion { + if m.quaternion == nil { + m.quaternion = NewMQuaternion() + } + return m.quaternion +} + +func (m *MRotation) SetQuaternion(v *MQuaternion) { + m.quaternion = v + m.radians = v.ToRadians() + m.degrees = &MVec3{ + 180.0 * m.radians.GetX() / math.Pi, + 180.0 * m.radians.GetY() / math.Pi, + 180.0 * m.radians.GetZ() / math.Pi, + } +} + +func (m *MRotation) GetRadians() *MVec3 { + if m.radians == nil { + m.radians = NewMVec3() + } + return m.radians +} + +func (m *MRotation) GetRadiansMMD() *MVec3 { + if m.radians == nil { + m.radians = NewMVec3() + } + return m.radians.MMD() +} + +func (m *MRotation) SetRadians(v *MVec3) { + m.radians = v + m.degrees = &MVec3{ + 180.0 * v.GetX() / math.Pi, + 180.0 * v.GetY() / math.Pi, + 180.0 * v.GetZ() / math.Pi, + } + m.quaternion = NewMQuaternionFromRadians(v.GetX(), v.GetY(), v.GetZ()) +} + +func (m *MRotation) GetDegrees() *MVec3 { + if m.degrees == nil { + m.degrees = NewMVec3() + } + return m.degrees +} + +func (m *MRotation) GetDegreesMMD() *MVec3 { + if m.degrees == nil { + m.degrees = NewMVec3() + } + return m.degrees.MMD() +} + +func (m *MRotation) SetDegrees(v *MVec3) { + m.degrees = v + m.radians = &MVec3{ + math.Pi * v.GetX() / 180.0, + math.Pi * v.GetY() / 180.0, + math.Pi * v.GetZ() / 180.0, + } + m.quaternion = NewMQuaternionFromRadians(m.radians.GetX(), m.radians.GetY(), m.radians.GetZ()) +} + +// Copy +func (rot *MRotation) Copy() *MRotation { + copied := NewRotation() + if rot.radians != nil { + copied.radians = &MVec3{rot.radians.GetX(), rot.radians.GetY(), rot.radians.GetZ()} + } + if rot.degrees != nil { + copied.degrees = &MVec3{rot.degrees.GetX(), rot.degrees.GetY(), rot.degrees.GetZ()} + } + if rot.quaternion != nil { + copied.quaternion = NewMQuaternionByValues( + rot.quaternion.GetX(), rot.quaternion.GetY(), rot.quaternion.GetZ(), rot.quaternion.GetW()) + } + return copied +} + +// Mul +func (rot *MRotation) Mul(v *MRotation) { + if rot.quaternion == nil { + rot.quaternion = NewMQuaternion() + } + if v.quaternion == nil { + v.quaternion = NewMQuaternion() + } + qq := rot.quaternion.Mul(v.quaternion) + rot.SetQuaternion(qq) +} + +func (rot *MRotation) String() string { + stringOrNil := func(v fmt.Stringer) string { + if v == nil || reflect.ValueOf(v).IsNil() { + return "nil" + } + return v.String() + } + + return fmt.Sprintf("degrees: %s, radians: %s, quat: %s", + stringOrNil(rot.degrees), stringOrNil(rot.radians), stringOrNil(rot.quaternion)) +} diff --git a/pkg/mmath/mrotation_test.go b/pkg/mmath/mrotation_test.go new file mode 100644 index 00000000..1c3b7163 --- /dev/null +++ b/pkg/mmath/mrotation_test.go @@ -0,0 +1,56 @@ +package mmath + +import ( + "testing" +) + +func TestNewRotationByRadians(t *testing.T) { + radians := &MVec3{1, 2, 3} + rotation := NewRotationFromRadians(radians) + + if rotation.GetRadians() != radians { + t.Errorf("Expected GetRadians() to return %v, but got %v", radians, rotation.radians.String()) + } +} + +func TestNewRotationByDegrees(t *testing.T) { + degrees := &MVec3{90, 180, 270} + rotation := NewRotationFromDegrees(degrees) + + if rotation.GetDegrees() != degrees { + t.Errorf("Expected GetDegrees() to return %v, but got %v", degrees, rotation.degrees.String()) + } +} + +func TestNewRotationByQuaternion(t *testing.T) { + quaternion := NewMQuaternionByValues(1, 0, 0, 0) + rotation := NewRotationFromQuaternion(quaternion) + + if rotation.GetQuaternion() != quaternion { + t.Errorf("Expected GetQuaternion() to return %v, but got %v", quaternion, rotation.quaternion.String()) + } +} + +func TestT_Copy(t *testing.T) { + rot := &MRotation{ + radians: &MVec3{1, 2, 3}, + degrees: &MVec3{90, 180, 270}, + quaternion: NewMQuaternionByValues(1, 0, 0, 0), + } + + copied := rot.Copy() + + if &copied == &rot { + t.Error("Expected Copy() to return a different instance") + } + + if !copied.GetRadians().NearEquals(rot.GetRadians(), 1e-10) { + t.Errorf("Copied instance does not match the original (radians) %s %s", copied.radians.String(), rot.radians.String()) + } + if !copied.GetDegrees().NearEquals(rot.GetDegrees(), 1e-10) { + t.Errorf("Copied instance does not match the original (degrees) %s %s", copied.degrees.String(), rot.degrees.String()) + } + if 1-copied.GetQuaternion().Dot(rot.GetQuaternion()) > 1e-10 { + t.Errorf("Copied instance does not match the original (quaternion) %s %s", copied.quaternion.String(), rot.quaternion.String()) + } +} diff --git a/pkg/mmath/mscalar.go b/pkg/mmath/mscalar.go new file mode 100644 index 00000000..f362eb34 --- /dev/null +++ b/pkg/mmath/mscalar.go @@ -0,0 +1,92 @@ +package mmath + +import "math" + +// 線形補間 +func LerpFloat(v1, v2 float64, t float64) float64 { + return v1 + ((v2 - v1) * t) +} + +func Sign(v float64) float64 { + if v < 0 { + return -1 + } + return 1 +} + +func NearEquals(v float64, other float64, epsilon float64) bool { + return math.Abs(v-other) <= epsilon +} + +func ToRadian(degree float64) float64 { + return degree * math.Pi / 180 +} + +func ToDegree(radian float64) float64 { + return radian * 180 / math.Pi +} + +// Clamp01 ベクトルの各要素をmin～maxの範囲内にクランプします +func ClampedFloat(v float64, min float64, max float64) float64 { + if v < min { + return min + } else if v > max { + return max + } + return v +} + +// Clamp01 ベクトルの各要素をmin～maxの範囲内にクランプします +func ClampedFloat32(v float32, min float32, max float32) float32 { + if v < min { + return min + } else if v > max { + return max + } + return v +} + +// ボーンから見た頂点ローカル位置を求める +// vertexPositions: グローバル頂点位置 +// startBonePosition: 親ボーン位置 +// endBonePosition: 子ボーン位置 +func GetVertexLocalPositions(vertexPositions []*MVec3, startBonePosition *MVec3, endBonePosition *MVec3) []*MVec3 { + vertexSize := len(vertexPositions) + boneVector := endBonePosition.Sub(startBonePosition) + boneDirection := boneVector.Normalized() + + localPositions := make([]*MVec3, vertexSize) + for i := 0; i < vertexSize; i++ { + vertexPosition := vertexPositions[i] + subedVertexPosition := vertexPosition.Subed(startBonePosition) + projection := subedVertexPosition.Project(boneDirection) + localPosition := endBonePosition.Added(projection) + localPositions[i] = localPosition + } + + return localPositions +} + +func ArgMin(distances []float64) int { + minValue := math.MaxFloat64 + minIndex := -1 + for i, d := range distances { + if d < minValue { + minValue = d + minIndex = i + } + } + return minIndex +} + +func ArgMax(distances []float64) int { + maxValue := -math.MaxFloat64 + maxIndex := -1 + for i, d := range distances { + if d > maxValue { + maxValue = d + maxIndex = i + } + } + return maxIndex +} diff --git a/pkg/mmath/mvec2.go b/pkg/mmath/mvec2.go new file mode 100644 index 00000000..27158c90 --- /dev/null +++ b/pkg/mmath/mvec2.go @@ -0,0 +1,453 @@ +package mmath + +import ( + "fmt" + "hash/fnv" + "math" + + "github.com/go-gl/mathgl/mgl64" +) + +var ( + MVec2Zero = MVec2{} + + // UnitX holds a vector with X set to one. + MVec2UnitX = MVec2{1, 0} + // UnitY holds a vector with Y set to one. + MVec2UnitY = MVec2{0, 1} + // UnitXY holds a vector with X and Y set to one. + MVec2UnitXY = MVec2{1, 1} + + // MinVal holds a vector with the smallest possible component values. + MVec2MinVal = MVec2{-math.MaxFloat64, -math.MaxFloat64} + // MaxVal holds a vector with the highest possible component values. + MVec2MaxVal = MVec2{+math.MaxFloat64, +math.MaxFloat64} +) + +type MVec2 mgl64.Vec2 + +func NewMVec2() *MVec2 { + return &MVec2{} +} + +// GetX returns the value of the X coordinate +func (v *MVec2) GetX() float64 { + return v[0] +} + +// SetX sets the value of the X coordinate +func (v *MVec2) SetX(x float64) { + v[0] = x +} + +func (v *MVec2) AddX(x float64) { + v[0] += x +} + +// GetY returns the value of the Y coordinate +func (v *MVec2) GetY() float64 { + return v[1] +} + +// SetY sets the value of the Y coordinate +func (v *MVec2) SetY(y float64) { + v[1] = y +} + +func (v *MVec2) AddY(y float64) { + v[1] += y +} + +// String 文字列表現を返します。 +func (v *MVec2) String() string { + return fmt.Sprintf("[x=%.5f, y=%.5f]", v.GetX(), v.GetY()) +} + +// MMD MMD(MikuMikuDance)座標系に変換された2次元ベクトルを返します +func (v *MVec2) MMD() *MVec2 { + return &MVec2{v.GetX(), v.GetY()} +} + +// Add ベクトルに他のベクトルを加算します +func (v *MVec2) Add(other *MVec2) *MVec2 { + v[0] += other[0] + v[1] += other[1] + return v +} + +// AddScalar ベクトルの各要素にスカラーを加算します +func (v *MVec2) AddScalar(s float64) *MVec2 { + v[0] += s + v[1] += s + return v +} + +// Added ベクトルに他のベクトルを加算した結果を返します +func (v *MVec2) Added(other *MVec2) *MVec2 { + return &MVec2{v[0] + other[0], v[1] + other[1]} +} + +func (v *MVec2) AddedScalar(s float64) *MVec2 { + return &MVec2{v[0] + s, v[1] + s} +} + +// Sub ベクトルから他のベクトルを減算します +func (v *MVec2) Sub(other *MVec2) *MVec2 { + v[0] -= other[0] + v[1] -= other[1] + return v +} + +// SubScalar ベクトルの各要素からスカラーを減算します +func (v *MVec2) SubScalar(s float64) *MVec2 { + v[0] -= s + v[1] -= s + return v +} + +// Subed ベクトルから他のベクトルを減算した結果を返します +func (v *MVec2) Subed(other *MVec2) *MVec2 { + return &MVec2{v[0] - other[0], v[1] - other[1]} +} + +func (v *MVec2) SubedScalar(s float64) *MVec2 { + return &MVec2{v[0] - s, v[1] - s} +} + +// Mul ベクトルの各要素に他のベクトルの各要素を乗算します +func (v *MVec2) Mul(other *MVec2) *MVec2 { + v[0] *= other[0] + v[1] *= other[1] + return v +} + +// MulScalar ベクトルの各要素にスカラーを乗算します +func (v *MVec2) MulScalar(s float64) *MVec2 { + v[0] *= s + v[1] *= s + return v +} + +// Muled ベクトルの各要素に他のベクトルの各要素を乗算した結果を返します +func (v *MVec2) Muled(other *MVec2) *MVec2 { + return &MVec2{v[0] * other[0], v[1] * other[1]} +} + +func (v *MVec2) MuledScalar(s float64) *MVec2 { + return &MVec2{v[0] * s, v[1] * s} +} + +// Div ベクトルの各要素を他のベクトルの各要素で除算します +func (v *MVec2) Div(other *MVec2) *MVec2 { + v[0] /= other[0] + v[1] /= other[1] + return v +} + +// DivScalar ベクトルの各要素をスカラーで除算します +func (v *MVec2) DivScalar(s float64) *MVec2 { + v[0] /= s + v[1] /= s + return v +} + +// Dived ベクトルの各要素を他のベクトルの各要素で除算した結果を返します +func (v *MVec2) Dived(other *MVec2) *MVec2 { + return &MVec2{v[0] / other[0], v[1] / other[1]} +} + +// DivedScalar ベクトルの各要素をスカラーで除算した結果を返します +func (v *MVec2) DivedScalar(s float64) *MVec2 { + return &MVec2{v[0] / s, v[1] / s} +} + +// Equal ベクトルが他のベクトルと等しいかどうかをチェックします +func (v *MVec2) Equals(other *MVec2) bool { + return v.GetX() == other.GetX() && v.GetY() == other.GetY() +} + +// NotEqual ベクトルが他のベクトルと等しくないかどうかをチェックします +func (v *MVec2) NotEquals(other MVec2) bool { + return v.GetX() != other.GetX() || v.GetY() != other.GetY() +} + +// NearEquals ベクトルが他のベクトルとほぼ等しいかどうかをチェックします +func (v *MVec2) NearEquals(other *MVec2, epsilon float64) bool { + return (math.Abs(v[0]-other[0]) <= epsilon) && + (math.Abs(v[1]-other[1]) <= epsilon) +} + +// LessThan ベクトルが他のベクトルより小さいかどうかをチェックします (<) +func (v *MVec2) LessThan(other *MVec2) bool { + return v.GetX() < other.GetX() && v.GetY() < other.GetY() +} + +// LessThanOrEqual ベクトルが他のベクトル以下かどうかをチェックします (<=) +func (v *MVec2) LessThanOrEquals(other *MVec2) bool { + return v.GetX() <= other.GetX() && v.GetY() <= other.GetY() +} + +// GreaterThan ベクトルが他のベクトルより大きいかどうかをチェックします (>) +func (v *MVec2) GreaterThan(other *MVec2) bool { + return v.GetX() > other.GetX() && v.GetY() > other.GetY() +} + +// GreaterThanOrEqual ベクトルが他のベクトル以上かどうかをチェックします (>=) +func (v *MVec2) GreaterThanOrEquals(other *MVec2) bool { + return v.GetX() >= other.GetX() && v.GetY() >= other.GetY() +} + +// Inverse ベクトルの各要素の符号を反転します (-v) +func (v *MVec2) Inverse() *MVec2 { + v[0] = -v[0] + v[1] = -v[1] + return v +} + +// Inverted ベクトルの各要素の符号を反転した結果を返します (-v) +func (v *MVec2) Inverted() *MVec2 { + return &MVec2{-v[0], -v[1]} +} + +// Abs ベクトルの各要素の絶対値を返します +func (v *MVec2) Abs() *MVec2 { + v[0] = math.Abs(v[0]) + v[1] = math.Abs(v[1]) + return v +} + +// Absed ベクトルの各要素の絶対値を返します +func (v *MVec2) Absed() *MVec2 { + return &MVec2{math.Abs(v[0]), math.Abs(v[1])} +} + +// Hash ベクトルのハッシュ値を計算します +func (v *MVec2) Hash() uint64 { + h := fnv.New64a() + h.Write([]byte(fmt.Sprintf("%.10f,%.10f", v.GetX(), v.GetY()))) + return h.Sum64() +} + +// IsZero ベクトルがゼロベクトルかどうかをチェックします +func (v *MVec2) IsZero() bool { + return v[0] == 0 && v[1] == 0 +} + +// Length ベクトルの長さを返します +func (v *MVec2) Length() float64 { + return math.Hypot(v[0], v[1]) +} + +// LengthSqr ベクトルの長さの2乗を返します +func (v *MVec2) LengthSqr() float64 { + return v[0]*v[0] + v[1]*v[1] +} + +// Normalize ベクトルを正規化します +func (v *MVec2) Normalize() *MVec2 { + sl := v.LengthSqr() + if sl == 0 || sl == 1 { + return v + } + return v.MulScalar(1 / math.Sqrt(sl)) +} + +// Normalized ベクトルを正規化した結果を返します +func (v *MVec2) Normalized() *MVec2 { + vec := *v + vec.Normalize() + return &vec +} + +// Angle ベクトルの角度(ラジアン角度)を返します +func (a *MVec2) Angle(b *MVec2) float64 { + v := a.Dot(b) / (a.Length() * b.Length()) + // prevent NaN + if v > 1. { + v = v - 2 + } else if v < -1. { + v = v + 2 + } + return math.Acos(v) +} + +// Degree ベクトルの角度(度数)を返します +func (v *MVec2) Degree(other *MVec2) float64 { + radian := v.Angle(other) + degree := radian * (180 / math.Pi) + return degree +} + +// Dot ベクトルの内積を返します +func (v *MVec2) Dot(other *MVec2) float64 { + return v[0]*other[0] + v[1]*other[1] +} + +// Cross ベクトルの外積を返します +func (v *MVec2) Cross(other *MVec2) *MVec2 { + return &MVec2{ + v[1]*other[0] - v[0]*other[1], + v[0]*other[1] - v[1]*other[0], + } +} + +// Min ベクトルの各要素の最小値をTの各要素に設定して返します +func (v *MVec2) Min() *MVec2 { + min := v.GetX() + if v.GetY() < min { + min = v.GetY() + } + return &MVec2{min, min} +} + +// Max ベクトルの各要素の最大値を返します +func (v *MVec2) Max() *MVec2 { + max := v.GetX() + if v.GetY() > max { + max = v.GetY() + } + return &MVec2{max, max} +} + +// Clamp ベクトルの各要素を指定された範囲内にクランプします +func (v *MVec2) Clamp(min, max *MVec2) *MVec2 { + for i := range v { + if v[i] < min[i] { + v[i] = min[i] + } else if v[i] > max[i] { + v[i] = max[i] + } + } + return v +} + +// Clamped ベクトルの各要素を指定された範囲内にクランプした結果を返します +func (v *MVec2) Clamped(min, max *MVec2) *MVec2 { + result := *v + result.Clamp(min, max) + return &result +} + +// Clamp01 ベクトルの各要素を0.0～1.0の範囲内にクランプします +func (v *MVec2) Clamp01() *MVec2 { + return v.Clamp(&MVec2Zero, &MVec2UnitXY) +} + +// Clamped01 ベクトルの各要素を0.0～1.0の範囲内にクランプした結果を返します +func (v *MVec2) Clamped01() *MVec2 { + result := *v + result.Clamp01() + return &result +} + +func (v *MVec2) Rotate(angle float64) *MVec2 { + sinus := math.Sin(angle) + cosinus := math.Cos(angle) + v[0] = v[0]*cosinus - v[1]*sinus + v[1] = v[0]*sinus + v[1]*cosinus + return v +} + +// Rotated ベクトルを回転します +func (v *MVec2) Rotated(angle float64) *MVec2 { + copied := v.Copy() + return copied.Rotate(angle) +} + +// RotateAroundPoint ベクトルを指定された点を中心に回転します +func (v *MVec2) RotateAroundPoint(point *MVec2, angle float64) *MVec2 { + return v.Sub(point).Rotate(angle).Add(point) +} + +// Rotate90DegLeft ベクトルを90度左回転します +func (v *MVec2) Rotate90DegLeft() *MVec2 { + temp := v[0] + v[0] = -v[1] + v[1] = temp + return v +} + +// Rotate90DegRight ベクトルを90度右回転します +func (v *MVec2) Rotate90DegRight() *MVec2 { + temp := v[0] + v[0] = v[1] + v[1] = -temp + return v +} + +// Copy +func (v *MVec2) Copy() *MVec2 { + return &MVec2{v.GetX(), v.GetY()} +} + +// Vector +func (v *MVec2) Vector() []float64 { + return []float64{v.GetX(), v.GetY()} +} + +// 線形補間 +func LerpVec2(v1, v2 *MVec2, t float64) *MVec2 { + return (v2.Sub(v1)).MulScalar(t).Added(v1) +} + +func (v *MVec2) Round() *MVec2 { + return &MVec2{ + math.Round(v.GetX()), + math.Round(v.GetY()), + } +} + +// 標準偏差を加味したmean処理 +func StdMeanVec2(values []MVec2, err float64) *MVec2 { + npStandardVectors := make([][]float64, len(values)) + npStandardLengths := make([]float64, len(values)) + + for i, v := range values { + npStandardVectors[i] = v.Vector() + npStandardLengths[i] = v.Length() + } + + medianStandardValues := Median(npStandardLengths) + stdStandardValues := Std(npStandardLengths) + + // 中央値から標準偏差の一定範囲までの値を取得 + var filteredStandardValues [][]float64 + for i := 0; i < len(npStandardVectors); i++ { + if npStandardLengths[i] >= medianStandardValues-err*stdStandardValues && + npStandardLengths[i] <= medianStandardValues+err*stdStandardValues { + filteredStandardValues = append(filteredStandardValues, npStandardVectors[i]) + } + } + + mean := Mean2DVertical(filteredStandardValues) + return &MVec2{mean[0], mean[1]} +} + +// One 0を1に変える +func (v *MVec2) One() *MVec2 { + vec := v.Vector() + epsilon := 1e-14 + for i := 0; i < len(vec); i++ { + if math.Abs(vec[i]) < epsilon { + vec[i] = 1 + } + } + return &MVec2{vec[0], vec[1]} +} + +func (v *MVec2) Distance(other *MVec2) float64 { + s := v.Subed(other) + return s.Length() +} + +// ClampIfVerySmall ベクトルの各要素がとても小さい場合、ゼロを設定する +func (v *MVec2) ClampIfVerySmall() *MVec2 { + epsilon := 1e-6 + if math.Abs(v.GetX()) < epsilon { + v.SetX(0) + } + if math.Abs(v.GetY()) < epsilon { + v.SetY(0) + } + return v +} diff --git a/pkg/mmath/mvec2_test.go b/pkg/mmath/mvec2_test.go new file mode 100644 index 00000000..af662315 --- /dev/null +++ b/pkg/mmath/mvec2_test.go @@ -0,0 +1,195 @@ +package mmath + +import ( + "math" + "testing" +) + +func TestMVec2LerpVec2(t *testing.T) { + v1 := &MVec2{1, 2} + v2 := &MVec2{3, 4} // Pass the address of v2 + t1 := 0.5 + expected := MVec2{2, 3} + + result := LerpVec2(v1, v2, t1) // Use v2 as a pointer + + if !result.NearEquals(&expected, 1e-8) { + t.Errorf("TestMVec2LerpVec2 failed. Expected %v, got %v", expected, result) + } +} + +func TestMVec2NearEquals(t *testing.T) { + v1 := MVec2{1, 2} + v2 := MVec2{1.000001, 2.000001} + epsilon := 0.00001 + + if !v1.NearEquals(&v2, epsilon) { + t.Errorf("NearEquals failed. Expected true, got false") + } + + v3 := MVec2{1, 2} + v4 := MVec2{1.0001, 2.0001} + + if v3.NearEquals(&v4, epsilon) { + t.Errorf("NearEquals failed. Expected false, got true") + } +} + +func TestMVec2LessThan(t *testing.T) { + v1 := MVec2{1, 2} + v2 := MVec2{3, 4} + + if !v1.LessThan(&v2) { + t.Errorf("LessThan failed. Expected true, got false") + } + + v3 := MVec2{3, 4} + v4 := MVec2{1, 2} + + if v3.LessThan(&v4) { + t.Errorf("LessThan failed. Expected false, got true") + } +} + +func TestMVec2LessThanOrEquals(t *testing.T) { + v1 := MVec2{1, 2} + v2 := MVec2{3, 4} + + if !v1.LessThanOrEquals(&v2) { + t.Errorf("LessThanOrEqual failed. Expected true, got false") + } + + v3 := MVec2{3, 4} + v4 := MVec2{1, 2} + + if v3.LessThanOrEquals(&v4) { + t.Errorf("LessThanOrEqual failed. Expected false, got true") + } + + v5 := MVec2{1, 2} + v6 := MVec2{1, 2} + + if !v5.LessThanOrEquals(&v6) { + t.Errorf("LessThanOrEqual failed. Expected true, got false") + } +} + +func TestMVec2GreaterThan(t *testing.T) { + v1 := MVec2{1, 2} + v2 := MVec2{3, 4} + + if v1.GreaterThan(&v2) { + t.Errorf("GreaterThan failed. Expected false, got true") + } + + v3 := MVec2{3, 4} + v4 := MVec2{1, 2} + + if !v3.GreaterThan(&v4) { + t.Errorf("GreaterThan failed. Expected true, got false") + } +} + +func TestMVec2GreaterThanOrEquals(t *testing.T) { + v1 := MVec2{1, 2} + v2 := MVec2{3, 4} + + if v1.GreaterThanOrEquals(&v2) { + t.Errorf("GreaterThanOrEqual failed. Expected false, got true") + } + + v3 := MVec2{3, 4} + v4 := MVec2{1, 2} + + if !v3.GreaterThanOrEquals(&v4) { + t.Errorf("GreaterThanOrEqual failed. Expected true, got false") + } + + v5 := MVec2{1, 2} + v6 := MVec2{1, 2} + + if !v5.GreaterThanOrEquals(&v6) { + t.Errorf("GreaterThanOrEqual failed. Expected true, got false") + } +} + +func TestMVec2Inverted(t *testing.T) { + v1 := MVec2{1, 2} + v2 := MVec2{3, 4} + + iv1 := v1.Inverted() + if iv1.GetX() != -1 || iv1.GetY() != -2 { + t.Errorf("Inverse failed. Expected (-1, -2), got (%v, %v)", iv1.GetX(), iv1.GetY()) + } + + iv2 := v2.Inverted() + if iv2.GetX() != -3 || iv2.GetY() != -4 { + t.Errorf("Inverse failed. Expected (-3, -4), got (%v, %v)", iv2.GetX(), iv2.GetY()) + } +} + +func TestMVec2Abs(t *testing.T) { + v1 := MVec2{-1, -2} + expected1 := MVec2{1, 2} + result1 := v1.Abs() + if !result1.Equals(&expected1) { + t.Errorf("Abs failed. Expected %v, got %v", expected1, result1) + } + + v2 := MVec2{3, -4} + expected2 := MVec2{3, 4} + result2 := v2.Abs() + if !result2.Equals(&expected2) { + t.Errorf("Abs failed. Expected %v, got %v", expected2, result2) + } + + v3 := MVec2{0, 0} + expected3 := MVec2{0, 0} + result3 := v3.Abs() + if !result3.Equals(&expected3) { + t.Errorf("Abs failed. Expected %v, got %v", expected3, result3) + } +} + +func TestMVec2Hash(t *testing.T) { + v := MVec2{1, 2} + expected := uint64(4921663092573786862) + result := v.Hash() + if result != expected { + t.Errorf("Hash failed. Expected %v, got %v", expected, result) + } +} + +func TestMVec2Angle(t *testing.T) { + v1 := MVec2{1, 0} + v2 := MVec2{0, 1} + expected := math.Pi / 2 + result := v1.Angle(&v2) + if math.Abs(result-expected) > 1e-10 { + t.Errorf("Angle failed. Expected %v, got %v", expected, result) + } + + v3 := MVec2{1, 1} + expected2 := math.Pi / 4 + result2 := v1.Angle(&v3) + if math.Abs(result2-expected2) > 1e-10 { + t.Errorf("Angle failed. Expected %v, got %v", expected2, result2) + } +} + +func TestMVec2Degree(t *testing.T) { + v1 := MVec2{1, 0} + v2 := MVec2{0, 1} + expected := 90.0 + result := v1.Degree(&v2) + if math.Abs(result-expected) > 0.00001 { + t.Errorf("Degree failed. Expected %v, got %v", expected, result) + } + + v3 := MVec2{1, 1} + expected2 := 45.0 + result2 := v1.Degree(&v3) + if math.Abs(result2-expected2) > 0.00001 { + t.Errorf("Degree failed. Expected %v, got %v", expected2, result2) + } +} diff --git a/pkg/mmath/mvec3.go b/pkg/mmath/mvec3.go new file mode 100644 index 00000000..9a9de522 --- /dev/null +++ b/pkg/mmath/mvec3.go @@ -0,0 +1,713 @@ +package mmath + +import ( + "fmt" + "hash/fnv" + "math" + + "github.com/go-gl/mathgl/mgl64" + + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" +) + +var ( + MVec3Zero = &MVec3{} + + MVec3UnitX = &MVec3{1, 0, 0} + MVec3UnitY = &MVec3{0, 1, 0} + MVec3UnitZ = &MVec3{0, 0, 1} + MVec3One = &MVec3{1, 1, 1} + + MVec3UnitXInv = &MVec3{-1, 0, 0} + MVec3UnitYInv = &MVec3{0, -1, 0} + MVec3UnitZInv = &MVec3{0, 0, -1} + MVec3OneInv = &MVec3{-1, -1, -1} + + MVec3MinVal = &MVec3{-math.MaxFloat64, -math.MaxFloat64, -math.MaxFloat64} + MVec3MaxVal = &MVec3{+math.MaxFloat64, +math.MaxFloat64, +math.MaxFloat64} +) + +type MVec3 mgl64.Vec3 + +func NewMVec3() *MVec3 { + return &MVec3{} +} + +// GetX returns the value of the X coordinate +func (v *MVec3) GetX() float64 { + return v[0] +} + +// SetX sets the value of the X coordinate +func (v *MVec3) SetX(x float64) { + v[0] = x +} + +func (v *MVec3) AddX(x float64) { + v[0] += x +} + +func (v *MVec3) SubX(x float64) { + v[0] -= x +} + +func (v *MVec3) MulX(x float64) { + v[0] *= x +} + +func (v *MVec3) DivX(x float64) { + v[0] /= x +} + +// GetY returns the value of the Y coordinate +func (v *MVec3) GetY() float64 { + return v[1] +} + +// SetY sets the value of the Y coordinate +func (v *MVec3) SetY(y float64) { + v[1] = y +} + +func (v *MVec3) AddY(y float64) { + v[1] += y +} + +func (v *MVec3) SubY(y float64) { + v[1] -= y +} + +func (v *MVec3) MulY(y float64) { + v[1] *= y +} + +func (v *MVec3) DivY(y float64) { + v[1] /= y +} + +// GetZ returns the value of the Z coordinate +func (v *MVec3) GetZ() float64 { + return v[2] +} + +// SetZ sets the value of the Z coordinate +func (v *MVec3) SetZ(z float64) { + v[2] = z +} + +func (v *MVec3) AddZ(z float64) { + v[2] += z +} + +func (v *MVec3) SubZ(z float64) { + v[2] -= z +} + +func (v *MVec3) MulZ(z float64) { + v[2] *= z +} + +func (v *MVec3) DivZ(z float64) { + v[2] /= z +} + +func (v *MVec3) GetXY() *MVec2 { + return &MVec2{v.GetX(), v.GetY()} +} + +func (v *MVec3) IsOnlyX() bool { + return !NearEquals(v.GetX(), 0, 1e-10) && + NearEquals(v.GetY(), 0, 1e-10) && + NearEquals(v.GetZ(), 0, 1e-10) +} + +func (v *MVec3) IsOnlyY() bool { + return NearEquals(v.GetX(), 0, 1e-10) && + !NearEquals(v.GetY(), 0, 1e-10) && + NearEquals(v.GetZ(), 0, 1e-10) +} + +func (v *MVec3) IsOnlyZ() bool { + return NearEquals(v.GetX(), 0, 1e-10) && + NearEquals(v.GetY(), 0, 1e-10) && + !NearEquals(v.GetZ(), 0, 1e-10) +} + +// String T の文字列表現を返します。 +func (v *MVec3) String() string { + return fmt.Sprintf("[x=%.5f, y=%.5f, z=%.5f]", v.GetX(), v.GetY(), v.GetZ()) +} + +// MMD MMD(MikuMikuDance)座標系に変換された3次元ベクトルを返します +func (v *MVec3) MMD() *MVec3 { + return &MVec3{v.GetX(), v.GetY(), v.GetZ()} +} + +// Add ベクトルに他のベクトルを加算します +func (v *MVec3) Add(other *MVec3) *MVec3 { + v[0] += other[0] + v[1] += other[1] + v[2] += other[2] + return v +} + +// AddScalar ベクトルの各要素にスカラーを加算します +func (v *MVec3) AddScalar(s float64) *MVec3 { + v[0] += s + v[1] += s + v[2] += s + return v +} + +// Added ベクトルに他のベクトルを加算した結果を返します +func (v *MVec3) Added(other *MVec3) *MVec3 { + return &MVec3{v[0] + other[0], v[1] + other[1], v[2] + other[2]} +} + +func (v *MVec3) AddedScalar(s float64) *MVec3 { + return &MVec3{v[0] + s, v[1] + s, v[2] + s} +} + +// Sub ベクトルから他のベクトルを減算します +func (v *MVec3) Sub(other *MVec3) *MVec3 { + v[0] -= other[0] + v[1] -= other[1] + v[2] -= other[2] + return v +} + +// SubScalar ベクトルの各要素からスカラーを減算します +func (v *MVec3) SubScalar(s float64) *MVec3 { + v[0] -= s + v[1] -= s + v[2] -= s + return v +} + +// Subed ベクトルから他のベクトルを減算した結果を返します +func (v *MVec3) Subed(other *MVec3) *MVec3 { + return &MVec3{v[0] - other[0], v[1] - other[1], v[2] - other[2]} +} + +func (v *MVec3) SubedScalar(s float64) *MVec3 { + return &MVec3{v[0] - s, v[1] - s, v[2] - s} +} + +// Mul ベクトルの各要素に他のベクトルの各要素を乗算します +func (v *MVec3) Mul(other *MVec3) *MVec3 { + v[0] *= other[0] + v[1] *= other[1] + v[2] *= other[2] + return v +} + +// MulScalar ベクトルの各要素にスカラーを乗算します +func (v *MVec3) MulScalar(s float64) *MVec3 { + v[0] *= s + v[1] *= s + v[2] *= s + return v +} + +// Muled ベクトルの各要素に他のベクトルの各要素を乗算した結果を返します +func (v *MVec3) Muled(other *MVec3) *MVec3 { + return &MVec3{v[0] * other[0], v[1] * other[1], v[2] * other[2]} +} + +func (v *MVec3) MuledScalar(s float64) *MVec3 { + return &MVec3{v[0] * s, v[1] * s, v[2] * s} +} + +// Div ベクトルの各要素を他のベクトルの各要素で除算します +func (v *MVec3) Div(other *MVec3) *MVec3 { + v[0] /= other[0] + v[1] /= other[1] + v[2] /= other[2] + return v +} + +// DivScalar ベクトルの各要素をスカラーで除算します +func (v *MVec3) DivScalar(s float64) *MVec3 { + v[0] /= s + v[1] /= s + v[2] /= s + return v +} + +// Dived ベクトルの各要素を他のベクトルの各要素で除算した結果を返します +func (v *MVec3) Dived(other *MVec3) *MVec3 { + return &MVec3{v[0] / other[0], v[1] / other[1], v[2] / other[2]} +} + +// DivedScalar ベクトルの各要素をスカラーで除算した結果を返します +func (v *MVec3) DivedScalar(s float64) *MVec3 { + return &MVec3{v[0] / s, v[1] / s, v[2] / s} +} + +// Equal ベクトルが他のベクトルと等しいかどうかをチェックします +func (v *MVec3) Equals(other *MVec3) bool { + return v.GetX() == other.GetX() && v.GetY() == other.GetY() && v.GetZ() == other.GetZ() +} + +// NotEqual ベクトルが他のベクトルと等しくないかどうかをチェックします +func (v *MVec3) NotEquals(other MVec3) bool { + return v.GetX() != other.GetX() || v.GetY() != other.GetY() || v.GetZ() != other.GetZ() +} + +// NearEquals ベクトルが他のベクトルとほぼ等しいかどうかをチェックします +func (v *MVec3) NearEquals(other *MVec3, epsilon float64) bool { + return (math.Abs(v[0]-other[0]) <= epsilon) && + (math.Abs(v[1]-other[1]) <= epsilon) && + (math.Abs(v[2]-other[2]) <= epsilon) +} + +// LessThan ベクトルが他のベクトルより小さいかどうかをチェックします (<) +func (v *MVec3) LessThan(other *MVec3) bool { + return v.GetX() < other.GetX() && v.GetY() < other.GetY() && v.GetZ() < other.GetZ() +} + +// LessThanOrEqual ベクトルが他のベクトル以下かどうかをチェックします (<=) +func (v *MVec3) LessThanOrEquals(other *MVec3) bool { + return v.GetX() <= other.GetX() && v.GetY() <= other.GetY() && v.GetZ() <= other.GetZ() +} + +// GreaterThan ベクトルが他のベクトルより大きいかどうかをチェックします (>) +func (v *MVec3) GreaterThan(other *MVec3) bool { + return v.GetX() > other.GetX() && v.GetY() > other.GetY() && v.GetZ() > other.GetZ() +} + +// GreaterThanOrEqual ベクトルが他のベクトル以上かどうかをチェックします (>=) +func (v *MVec3) GreaterThanOrEquals(other *MVec3) bool { + return v.GetX() >= other.GetX() && v.GetY() >= other.GetY() && v.GetZ() >= other.GetZ() +} + +// Inverse ベクトルの各要素の符号を反転します (-v) +func (v *MVec3) Inverse() *MVec3 { + v[0] = -v[0] + v[1] = -v[1] + v[2] = -v[2] + return v +} + +// Inverted ベクトルの各要素の符号を反転した結果を返します (-v) +func (v *MVec3) Inverted() *MVec3 { + return &MVec3{-v[0], -v[1], -v[2]} +} + +// Abs ベクトルの各要素の絶対値を返します +func (v *MVec3) Abs() *MVec3 { + v[0] = math.Abs(v[0]) + v[1] = math.Abs(v[1]) + v[2] = math.Abs(v[2]) + return v +} + +// Absed ベクトルの各要素の絶対値を返します +func (v *MVec3) Absed() *MVec3 { + return &MVec3{math.Abs(v[0]), math.Abs(v[1]), math.Abs(v[2])} +} + +// Hash ベクトルのハッシュ値を計算します +func (v *MVec3) Hash() uint64 { + h := fnv.New64a() + h.Write([]byte(fmt.Sprintf("%.10f,%.10f,%.10f", v.GetX(), v.GetY(), v.GetZ()))) + return h.Sum64() +} + +// IsZero ベクトルがゼロベクトルかどうかをチェックします +func (v *MVec3) IsZero() bool { + return v.NearEquals(MVec3Zero, 1e-10) +} + +// IsZero ベクトルが1ベクトルかどうかをチェックします +func (v *MVec3) IsOne() bool { + return v.NearEquals(MVec3One, 1e-10) +} + +// Length ベクトルの長さを返します +func (v *MVec3) Length() float64 { + return mgl64.Vec3(*v).Len() +} + +// LengthSqr ベクトルの長さの2乗を返します +func (v *MVec3) LengthSqr() float64 { + return mgl64.Vec3(*v).LenSqr() +} + +// Normalize ベクトルを正規化します +func (v *MVec3) Normalize() *MVec3 { + sl := v.LengthSqr() + if sl == 0 || sl == 1 { + return v + } + return v.MulScalar(1 / math.Sqrt(sl)) +} + +// Normalized ベクトルを正規化した結果を返します +func (v *MVec3) Normalized() *MVec3 { + vec := MVec3{v[0], v[1], v[2]} + vec.Normalize() + return &vec +} + +// Angle ベクトルの角度(ラジアン角度)を返します +func (v *MVec3) Angle(other *MVec3) float64 { + vec := v.Dot(other) / (v.Length() * other.Length()) + // prevent NaN + if vec > 1. { + return 0 + } else if vec < -1. { + return math.Pi + } + return math.Acos(vec) +} + +// Degree ベクトルの角度(度数)を返します +func (v *MVec3) Degree(other *MVec3) float64 { + radian := v.Angle(other) + degree := radian * (180 / math.Pi) + return degree +} + +// Dot ベクトルの内積を返します +func (v *MVec3) Dot(other *MVec3) float64 { + return mgl64.Vec3(*v).Dot(mgl64.Vec3(*other)) +} + +// Cross ベクトルの外積を返します +func (v1 *MVec3) Cross(v2 *MVec3) *MVec3 { + v := mgl64.Vec3(*v1).Cross(mgl64.Vec3(*v2)) + return &MVec3{v[0], v[1], v[2]} +} + +// Min ベクトルの各要素の最小値をTの各要素に設定して返します +func (v *MVec3) Min() *MVec3 { + min := v.GetX() + if v.GetY() < min { + min = v.GetY() + } + if v.GetZ() < min { + min = v.GetZ() + } + return &MVec3{min, min, min} +} + +// Max ベクトルの各要素の最大値を返します +func (v *MVec3) Max() *MVec3 { + max := v.GetX() + if v.GetY() > max { + max = v.GetY() + } + if v.GetZ() > max { + max = v.GetZ() + } + return &MVec3{max, max, max} +} + +// Interpolate ベクトルの線形補間を行います +func (v *MVec3) Interpolate(other *MVec3, t float64) *MVec3 { + t1 := 1 - t + return &MVec3{ + v[0]*t1 + other[0]*t, + v[1]*t1 + other[1]*t, + v[2]*t1 + other[2]*t, + } +} + +// Clamp ベクトルの各要素を指定された範囲内にクランプします +func (v *MVec3) Clamp(min, max *MVec3) *MVec3 { + for i := range v { + if v[i] < min[i] { + v[i] = min[i] + } else if v[i] > max[i] { + v[i] = max[i] + } + } + return v +} + +// Clamped ベクトルの各要素を指定された範囲内にクランプした結果を返します +func (v *MVec3) Clamped(min, max *MVec3) *MVec3 { + result := MVec3{v.GetX(), v.GetY(), v.GetZ()} + result.Clamp(min, max) + return &result +} + +// Clamp01 ベクトルの各要素を0.0～1.0の範囲内にクランプします +func (v *MVec3) Clamp01() *MVec3 { + return v.Clamp(MVec3Zero, MVec3One) +} + +// Clamped01 ベクトルの各要素を0.0～1.0の範囲内にクランプした結果を返します +func (v *MVec3) Clamped01() *MVec3 { + result := MVec3{v.GetX(), v.GetY(), v.GetZ()} + result.Clamp01() + return &result +} + +// Copy +func (v *MVec3) Copy() *MVec3 { + return &MVec3{v.GetX(), v.GetY(), v.GetZ()} +} + +// Vector +func (v *MVec3) Vector() []float64 { + return []float64{v.GetX(), v.GetY(), v.GetZ()} +} + +func (v *MVec3) ToMat4() *MMat4 { + mat := NewMMat4() + mat[3] = v.GetX() + mat[7] = v.GetY() + mat[11] = v.GetZ() + return mat +} + +func (v *MVec3) ToScaleMat4() *MMat4 { + mat := NewMMat4() + mat[0] = v.GetX() + mat[5] = v.GetY() + mat[10] = v.GetZ() + return mat +} + +// ClampIfVerySmall ベクトルの各要素がとても小さい場合、ゼロを設定する +func (v *MVec3) ClampIfVerySmall() *MVec3 { + epsilon := 1e-6 + if math.Abs(v.GetX()) < epsilon { + v.SetX(0) + } + if math.Abs(v.GetY()) < epsilon { + v.SetY(0) + } + if math.Abs(v.GetZ()) < epsilon { + v.SetZ(0) + } + return v +} + +// 線形補間 +func (v1 *MVec3) Lerp(v2 *MVec3, t float64) *MVec3 { + return (v2.Subed(v1)).MulScalar(t).Add(v1) +} + +func (v *MVec3) Round() *MVec3 { + return &MVec3{ + math.Round(v.GetX()), + math.Round(v.GetY()), + math.Round(v.GetZ()), + } +} + +// ToLocalMatrix4x4 自身をローカル軸とした場合の回転行列を取得します +func (v *MVec3) ToLocalMatrix4x4() *MMat4 { + if v.IsZero() { + return NewMMat4() + } + + // ローカルX軸の方向ベクトル + xAxis := v.Copy() + normXAxis := xAxis.Length() + if normXAxis == 0 { + return NewMMat4() + } + xAxis.DivScalar(normXAxis) + + if math.IsNaN(xAxis.GetX()) || math.IsNaN(xAxis.GetY()) || math.IsNaN(xAxis.GetZ()) { + return NewMMat4() + } + + // ローカルZ軸の方向ベクトル + zAxis := &MVec3{0.0, 0.0, -1.0} + if zAxis.Equals(v) { + // 自身がほぼZ軸ベクトルの場合、別ベクトルを与える + zAxis = &MVec3{0.0, 1.0, 0.0} + } + + // ローカルY軸の方向ベクトル + yAxis := zAxis.Cross(xAxis) + normYAxis := yAxis.Length() + if normYAxis == 0 { + return NewMMat4() + } + yAxis.DivScalar(normYAxis) + + if math.IsNaN(yAxis.GetX()) || math.IsNaN(yAxis.GetY()) || math.IsNaN(yAxis.GetZ()) { + return NewMMat4() + } + + zAxis = xAxis.Cross(yAxis) + normZAxis := zAxis.Length() + zAxis.DivScalar(normZAxis) + + // ローカル軸に合わせた回転行列を作成する + rotationMatrix := NewMMat4ByValues( + xAxis.GetX(), yAxis.GetX(), zAxis.GetX(), 0, + xAxis.GetY(), yAxis.GetY(), zAxis.GetY(), 0, + xAxis.GetZ(), yAxis.GetZ(), zAxis.GetZ(), 0, + 0, 0, 0, 1, + ) + + return rotationMatrix +} + +// One 0を1に変える +func (v *MVec3) One() *MVec3 { + vec := v.Vector() + epsilon := 1e-14 + for i := 0; i < len(vec); i++ { + if math.Abs(vec[i]) < epsilon { + vec[i] = 1 + } + } + return &MVec3{vec[0], vec[1], vec[2]} +} + +func (v *MVec3) Distance(other *MVec3) float64 { + return v.Subed(other).Length() +} + +func (v *MVec3) Distances(others []*MVec3) []float64 { + distances := make([]float64, len(others)) + for i, other := range others { + distances[i] = v.Distance(other) + } + return distances +} + +// 2点間のベクトルと点Pの直交距離を計算 +func DistanceFromPointToLine(a, b, p *MVec3) float64 { + lineVec := b.Subed(a) // 線分ABのベクトル + pointVec := p.Subed(a) // 点Pから点Aへのベクトル + crossVec := lineVec.Cross(pointVec) // 外積ベクトル + area := crossVec.Length() // 平行四辺形の面積 + lineLength := lineVec.Length() // 線分ABの長さ + return area / lineLength // 点Pから線分ABへの距離 +} + +// 2点間のベクトルと、点Pを含むカメラ平面と平行な面、との距離を計算 +func DistanceFromPlaneToLine(near, far, forward, right, up, p *MVec3) float64 { + // ステップ1: カメラ平面の法線ベクトルを計算 + normal := forward.Cross(right) + + // ステップ2: 点Pからカメラ平面へのベクトルを計算 + vectorToPlane := p.Subed(near) + + // ステップ3: 距離を計算 + distance := math.Abs(vectorToPlane.Dot(normal)) / normal.Length() + + return distance +} + +// 2点間のベクトルと、点Pを含むカメラ平面と平行な面、との交点を計算 +func IntersectLinePlane(near, far, forward, right, up, p *MVec3) *MVec3 { + // ステップ1: カメラ平面の法線ベクトルを計算 + normal := forward.Cross(right) + + // ステップ2: nearからfarへのベクトルを計算 + direction := far.Subed(near) + + // ステップ3: 平面の方程式のD成分を計算 + D := -normal.Dot(p) + + // ステップ4: 方向ベクトルと法線ベクトルが平行かどうかを確認 + denom := normal.Dot(direction) + if math.Abs(denom) < 1e-6 { // ほぼ0に近い場合、平行とみなす + return nil // 平行ならば交点は存在しない + } + + // ステップ5: 直線と平面の交点を計算 + t := -(normal.Dot(near) + D) / denom + intersection := near.Added(direction.MuledScalar(t)) + return intersection +} + +// DistanceLineToPoints 線分と点の距離を計算します +func DistanceLineToPoints(worldPos *MVec3, points []*MVec3) []float64 { + distances := make([]float64, len(points)) + + // worldPos の Z方向のベクトル + worldDirection := worldPos.Added(MVec3UnitZInv) + + for i, p := range points { + // 点PとworldPosのZ方向のベクトルとの距離を計算 + distances[i] = DistanceFromPointToLine(worldPos, worldDirection, p) + mlog.D("DistanceLineToPoints[%d]: d: %.3f\n", i, distances[i]) + } + + return distances +} + +func Distances(v *MVec3, others []*MVec3) []float64 { + distances := make([]float64, len(others)) + for i, other := range others { + distances[i] = v.Distance(other) + } + return distances +} + +func (v *MVec3) Project(other *MVec3) *MVec3 { + return other.MuledScalar(v.Dot(other) / other.LengthSqr()) +} + +// 標準偏差を加味したmean処理 +func StdMeanVec3(values []MVec3, err float64) *MVec3 { + npStandardVectors := make([][]float64, len(values)) + npStandardLengths := make([]float64, len(values)) + + for i, v := range values { + npStandardVectors[i] = v.Vector() + npStandardLengths[i] = v.Length() + } + + medianStandardValues := Median(npStandardLengths) + stdStandardValues := Std(npStandardLengths) + + // 中央値から標準偏差の一定範囲までの値を取得 + var filteredStandardValues [][]float64 + for i := 0; i < len(npStandardVectors); i++ { + if npStandardLengths[i] >= medianStandardValues-err*stdStandardValues && + npStandardLengths[i] <= medianStandardValues+err*stdStandardValues { + filteredStandardValues = append(filteredStandardValues, npStandardVectors[i]) + } + } + + mean := Mean2DVertical(filteredStandardValues) + return &MVec3{mean[0], mean[1], mean[2]} +} + +// 点が直方体内にあるかどうかを判定する関数 +func (point *MVec3) IsPointInsideBox(min, max *MVec3) bool { + return point.GetX() >= min.GetX() && point.GetX() <= max.GetX() && + point.GetY() >= min.GetY() && point.GetY() <= max.GetY() && + point.GetZ() >= min.GetZ() && point.GetZ() <= max.GetZ() +} + +// 直方体の境界を計算する関数 +func CalculateBoundingBox(points ...*MVec3) (minPos, maxPos *MVec3) { + minPos = &MVec3{math.Inf(1), math.Inf(1), math.Inf(1)} + maxPos = &MVec3{math.Inf(-1), math.Inf(-1), math.Inf(-1)} + + for _, p := range points { + if p.GetX() < minPos.GetX() { + minPos.SetX(p.GetX()) + } + if p.GetY() < minPos.GetY() { + minPos.SetY(p.GetY()) + } + if p.GetZ() < minPos.GetZ() { + minPos.SetZ(p.GetZ()) + } + if p.GetX() > maxPos.GetX() { + maxPos.SetX(p.GetX()) + } + if p.GetY() > maxPos.GetY() { + maxPos.SetY(p.GetY()) + } + if p.GetZ() > maxPos.GetZ() { + maxPos.SetZ(p.GetZ()) + } + } + + return minPos, maxPos +} diff --git a/pkg/mmath/mvec3_test.go b/pkg/mmath/mvec3_test.go new file mode 100644 index 00000000..f2e3d16f --- /dev/null +++ b/pkg/mmath/mvec3_test.go @@ -0,0 +1,376 @@ +package mmath + +import ( + "math" + "testing" +) + +func TestMVec3Interpolate(t *testing.T) { + v1 := MVec3{1, 2, 3} + v2 := &MVec3{4, 5, 6} // Pass the address of v2 + t1 := 0.5 + expected := MVec3{2.5, 3.5, 4.5} + + result := v1.Interpolate(v2, t1) // Use v2 as a pointer + + if !result.NearEquals(&expected, 1e-8) { + t.Errorf("Interpolation failed. Expected %v, got %v", expected, result) + } +} + +func TestMVec3NearEquals(t *testing.T) { + v1 := MVec3{1, 2, 3} + v2 := MVec3{1.000001, 2.000001, 3.000001} + epsilon := 0.00001 + + if !v1.NearEquals(&v2, epsilon) { + t.Errorf("NearEquals failed. Expected true, got false") + } + + v3 := MVec3{1, 2, 3} + v4 := MVec3{1.0001, 2.0001, 3.0001} + + if v3.NearEquals(&v4, epsilon) { + t.Errorf("NearEquals failed. Expected false, got true") + } +} + +func TestMVec3LessThan(t *testing.T) { + v1 := MVec3{1, 2, 3} + v2 := MVec3{4, 5, 6} + + if !v1.LessThan(&v2) { + t.Errorf("LessThan failed. Expected true, got false") + } + + v3 := MVec3{3, 4, 5} + v4 := MVec3{1, 2, 3} + + if v3.LessThan(&v4) { + t.Errorf("LessThan failed. Expected false, got true") + } +} + +func TestMVec3LessThanOrEquals(t *testing.T) { + v1 := MVec3{1, 2, 3} + v2 := MVec3{3, 4, 5} + + if !v1.LessThanOrEquals(&v2) { + t.Errorf("LessThanOrEqual failed. Expected true, got false") + } + + v3 := MVec3{3, 4, 5} + v4 := MVec3{1, 2, 3} + + if v3.LessThanOrEquals(&v4) { + t.Errorf("LessThanOrEqual failed. Expected false, got true") + } + + v5 := MVec3{1, 2} + v6 := MVec3{1, 2} + + if !v5.LessThanOrEquals(&v6) { + t.Errorf("LessThanOrEqual failed. Expected true, got false") + } +} + +func TestMVec3GreaterThan(t *testing.T) { + v1 := MVec3{1, 2, 3} + v2 := MVec3{3, 4, 5} + + if v1.GreaterThan(&v2) { + t.Errorf("GreaterThan failed. Expected false, got true") + } + + v3 := MVec3{3, 4, 5} + v4 := MVec3{1, 2, 3} + + if !v3.GreaterThan(&v4) { + t.Errorf("GreaterThan failed. Expected true, got false") + } +} + +func TestMVec3GreaterThanOrEquals(t *testing.T) { + v1 := MVec3{1, 2, 3} + v2 := MVec3{3, 4, 5} + + if v1.GreaterThanOrEquals(&v2) { + t.Errorf("GreaterThanOrEqual failed. Expected false, got true") + } + + v3 := MVec3{3, 4, 5} + v4 := MVec3{1, 2, 3} + + if !v3.GreaterThanOrEquals(&v4) { + t.Errorf("GreaterThanOrEqual failed. Expected true, got false") + } + + v5 := MVec3{1, 2, 3} + v6 := MVec3{1, 2, 3} + + if !v5.GreaterThanOrEquals(&v6) { + t.Errorf("GreaterThanOrEqual failed. Expected true, got false") + } +} + +func TestMVec3Inverted(t *testing.T) { + v1 := MVec3{1, 2, 3} + v2 := MVec3{3, 4, 5} + + iv1 := v1.Inverted() + if iv1.GetX() != -1 || iv1.GetY() != -2 || iv1.GetZ() != -3 { + t.Errorf("Inverse failed. Expected (-1, -2, -3), got (%v, %v, %v)", iv1.GetX(), iv1.GetY(), iv1.GetZ()) + } + + iv2 := v2.Inverted() + if iv2.GetX() != -3 || iv2.GetY() != -4 || iv2.GetZ() != -5 { + t.Errorf("Inverse failed. Expected (-3, -4, -5), got (%v, %v, %v)", iv2.GetX(), iv2.GetY(), iv2.GetZ()) + } +} + +func TestMVec3Abs(t *testing.T) { + v1 := MVec3{-1, -2, -3} + expected1 := MVec3{1, 2, 3} + result1 := v1.Abs() + if !result1.Equals(&expected1) { + t.Errorf("Abs failed. Expected %v, got %v", expected1, result1) + } + + v2 := MVec3{3, -4, 5} + expected2 := MVec3{3, 4, 5} + result2 := v2.Abs() + if !result2.Equals(&expected2) { + t.Errorf("Abs failed. Expected %v, got %v", expected2, result2) + } + + v3 := MVec3{0, 0} + expected3 := MVec3{0, 0} + result3 := v3.Abs() + if !result3.Equals(&expected3) { + t.Errorf("Abs failed. Expected %v, got %v", expected3, result3) + } +} + +func TestMVec3Hash(t *testing.T) { + v := MVec3{1, 2, 3} + expected := uint64(17648364615301650315) + result := v.Hash() + if result != expected { + t.Errorf("Hash failed. Expected %v, got %v", expected, result) + } +} + +func TestMVec3Angle(t *testing.T) { + v1 := MVec3{1, 0, 0} + v2 := MVec3{0, 1, 0} + expected := math.Pi / 2 + result := v1.Angle(&v2) + if result != expected { + t.Errorf("Angle failed. Expected %v, got %v", expected, result) + } + + v3 := MVec3{1, 1, 1} + expected2 := 0.9553166181245092 + result2 := v1.Angle(&v3) + if result2 != expected2 { + t.Errorf("Angle failed. Expected %v, got %v", expected2, result2) + } +} + +func TestMVec3Degree(t *testing.T) { + v1 := MVec3{1, 0, 0} + v2 := MVec3{0, 1, 0} + expected := 90.0 + result := v1.Degree(&v2) + if math.Abs(result-expected) > 0.00001 { + t.Errorf("Degree failed. Expected %v, got %v", expected, result) + } + + v3 := MVec3{1, 1, 1} + expected2 := 54.735610317245346 + result2 := v1.Degree(&v3) + if math.Abs(result2-expected2) > 0.00001 { + t.Errorf("Degree failed. Expected %v, got %v", expected2, result2) + } +} +func TestStdMean(t *testing.T) { + values := []MVec3{ + {1, 2, 3}, + {1.5, 1.2, 20.3}, + {1.8, 0.3, 1.3}, + {15, 0.2, 1.3}, + {1.3, 2.2, 2.3}, + } + + err := 1.5 + expected := MVec3{1.36666667, 1.5, 2.2} + + result := StdMeanVec3(values, err) + + if !result.NearEquals(&expected, 1e-8) { + t.Errorf("StdMean failed. Expected %v, got %v", expected, result) + } +} +func TestMVec3One(t *testing.T) { + v1 := MVec3{1, 2, 3.2} + expected1 := MVec3{1, 2, 3.2} + result1 := v1.One() + if !result1.NearEquals(&expected1, 1e-8) { + t.Errorf("One failed. Expected %v, got %v", expected1, result1) + } + + v2 := MVec3{0, 2, 3.2} + expected2 := MVec3{1, 2, 3.2} + result2 := v2.One() + if !result2.NearEquals(&expected2, 1e-8) { + t.Errorf("One failed. Expected %v, got %v", expected2, result2) + } + + v3 := MVec3{1, 0, 3.2} + expected3 := MVec3{1, 1, 3.2} + result3 := v3.One() + if !result3.NearEquals(&expected3, 1e-8) { + t.Errorf("One failed. Expected %v, got %v", expected3, result3) + } + + v4 := MVec3{2, 0, 0} + expected4 := MVec3{2, 1, 1} + result4 := v4.One() + if !result4.NearEquals(&expected4, 1e-8) { + t.Errorf("One failed. Expected %v, got %v", expected4, result4) + } +} + +func TestMVec3Length(t *testing.T) { + v1 := MVec3{1, 2, 3} + expected1 := 3.7416573867739413 + result1 := v1.Length() + if math.Abs(result1-expected1) > 1e-10 { + t.Errorf("Length failed. Expected %v, got %v", expected1, result1) + } + + v2 := MVec3{2.3, 0.2, 9} + expected2 := 9.291393867445294 + result2 := v2.Length() + if math.Abs(result2-expected2) > 1e-10 { + t.Errorf("Length failed. Expected %v, got %v", expected2, result2) + } +} + +func TestMVec3LengthSqr(t *testing.T) { + v1 := MVec3{1, 2, 3} + expected1 := 14.0 + result1 := v1.LengthSqr() + if math.Abs(result1-expected1) > 1e-10 { + t.Errorf("LengthSqr failed. Expected %v, got %v", expected1, result1) + } + + v2 := MVec3{2.3, 0.2, 9} + expected2 := 86.33000000000001 + result2 := v2.LengthSqr() + if math.Abs(result2-expected2) > 1e-10 { + t.Errorf("LengthSqr failed. Expected %v, got %v", expected2, result2) + } +} + +func TestMVec3Normalized(t *testing.T) { + v1 := MVec3{1, 2, 3} + expected1 := MVec3{0.2672612419124244, 0.5345224838248488, 0.8017837257372732} + result1 := v1.Normalized() + if !result1.NearEquals(&expected1, 1e-8) { + t.Errorf("Normalized failed. Expected %v, got %v", expected1, result1) + } + + v2 := MVec3{2.3, 0.2, 9} + expected2 := MVec3{0.24754089997827142, 0.021525295650284472, 0.9686383042628013} + result2 := v2.Normalized() + if !result2.NearEquals(&expected2, 1e-8) { + t.Errorf("Normalized failed. Expected %v, got %v", expected2, result2) + } +} +func TestMVec3Distance(t *testing.T) { + v1 := MVec3{1, 2, 3} + v2 := MVec3{2.3, 0.2, 9} + expected1 := 6.397655820689325 + result1 := v1.Distance(&v2) + if math.Abs(result1-expected1) > 1e-10 { + t.Errorf("Distance failed. Expected %v, got %v", expected1, result1) + } + + v3 := MVec3{-1, -0.3, 3} + v4 := MVec3{-2.3, 0.2, 9.33333333} + expected2 := 6.484682804030502 + result2 := v3.Distance(&v4) + if math.Abs(result2-expected2) > 1e-10 { + t.Errorf("Distance failed. Expected %v, got %v", expected2, result2) + } +} + +func TestMVector3DGetLocalMatrix(t *testing.T) { + v1 := MVec3{0.8, 0.6, 1} + localMatrix := v1.ToLocalMatrix4x4() + + expected1 := MMat4{ + 0.56568542, 0.6, 0.56568542, 0., + 0.42426407, -0.8, 0.42426407, 0., + 0.70710678, 0., -0.70710678, 0., + 0., 0., 0., 1., + } + + if !localMatrix.NearEquals(&expected1, 1e-8) { + t.Errorf("Local matrix calculation failed. Expected %v, got %v", expected1, localMatrix) + } + + v2 := MVec3{1, 0, 0} + localVector1 := localMatrix.MulVec3(&v2) + + expected2 := &MVec3{0.56568542, 0.42426407, 0.70710678} + if !localVector1.NearEquals(expected2, 1e-8) { + t.Errorf("Local vector calculation failed. Expected %v, got %v", expected2, localVector1) + } + + v3 := MVec3{1, 0, 1} + localVector2 := localMatrix.MulVec3(&v3) + + expected3 := MVec3{1.13137085, 0.848528137, -1.11022302e-16} + if !localVector2.NearEquals(&expected3, 1e-8) { + t.Errorf("Local vector calculation failed. Expected %v, got %v", expected3, localVector2) + } + + v4 := MVec3{0, 0, -0.5} + localMatrix2 := v4.ToLocalMatrix4x4() + + expected4 := MMat4{ + 1.0, 0.0, 0.0, 0.0, + 0.0, 1.0, 0.0, 0.0, + 0.0, 0.0, 1.0, 0.0, + 0.0, 0.0, 0.0, 1.0, + } + + if !localMatrix2.NearEquals(&expected4, 1e-8) { + t.Errorf("Local matrix calculation failed. Expected %v, got %v", expected4, localMatrix2) + } +} + +func TestGetVertexLocalPositions(t *testing.T) { + vertexLocalPositions := GetVertexLocalPositions( + []*MVec3{{1, 0, 0}, {0.5, 3, 2}, {-1, -2, 3}}, + &MVec3{0.5, 0.5, 1}, + &MVec3{0.7, 2, 1.5}, + ) + + expected := [][]float64{ + {0.10944881889763777, 0.8208661417322836, 0.2736220472440945}, + {0.5346456692913384, 4.009842519685039, 1.3366141732283463}, + {-0.04015748031496058, -0.3011811023622044, -0.10039370078740151}, + } + + for i := 0; i < 3; i++ { + for j := 0; j < 3; j++ { + if math.Abs(vertexLocalPositions[i][j]-expected[i][j]) > 1e-8 { + t.Errorf("GetVertexLocalPositions failed. Expected %v, got %v", expected, vertexLocalPositions) + break + } + } + } +} diff --git a/pkg/mmath/mvec4.go b/pkg/mmath/mvec4.go new file mode 100644 index 00000000..5e11ae3e --- /dev/null +++ b/pkg/mmath/mvec4.go @@ -0,0 +1,593 @@ +package mmath + +import ( + "fmt" + "hash/fnv" + "math" + + "github.com/go-gl/mathgl/mgl64" +) + +var ( + MVec4Zero = &MVec4{} + + // UnitXW holds a vector with X and W set to one. + MVec4UnitXW = &MVec4{1, 0, 0, 1} + // UnitYW holds a vector with Y and W set to one. + MVec4UnitYW = &MVec4{0, 1, 0, 1} + // UnitZW holds a vector with Z and W set to one. + MVec4UnitZW = &MVec4{0, 0, 1, 1} + // UnitW holds a vector with W set to one. + MVec4UnitW = &MVec4{0, 0, 0, 1} + // UnitXYZW holds a vector with X, Y, Z, W set to one. + MVec4One = &MVec4{1, 1, 1, 1} + + // MinVal holds a vector with the smallest possible component values. + MVec4MinVal = &MVec4{-math.MaxFloat64, -math.MaxFloat64, -math.MaxFloat64, 1} + // MaxVal holds a vector with the highest possible component values. + MVec4MaxVal = &MVec4{+math.MaxFloat64, +math.MaxFloat64, +math.MaxFloat64, 1} +) + +type MVec4 mgl64.Vec4 + +func NewMVec4() *MVec4 { + return &MVec4{} +} + +// GetX returns the value of the X coordinate +func (v *MVec4) GetX() float64 { + return v[0] +} + +// SetX sets the value of the X coordinate +func (v *MVec4) SetX(x float64) { + v[0] = x +} + +func (v *MVec4) AddX(x float64) { + v[0] += x +} + +func (v *MVec4) SubX(x float64) { + v[0] -= x +} + +func (v *MVec4) MulX(x float64) { + v[0] *= x +} + +func (v *MVec4) DivX(x float64) { + v[0] /= x +} + +// GetY returns the value of the Y coordinate +func (v *MVec4) GetY() float64 { + return v[1] +} + +// SetY sets the value of the Y coordinate +func (v *MVec4) SetY(y float64) { + v[1] = y +} + +func (v *MVec4) AddY(y float64) { + v[1] += y +} + +func (v *MVec4) SubY(y float64) { + v[1] -= y +} + +func (v *MVec4) MulY(y float64) { + v[1] *= y +} + +func (v *MVec4) DivY(y float64) { + v[1] /= y +} + +// GetZ returns the value of the Z coordinate +func (v *MVec4) GetZ() float64 { + return v[2] +} + +// SetZ sets the value of the Z coordinate +func (v *MVec4) SetZ(z float64) { + v[2] = z +} + +func (v *MVec4) AddZ(z float64) { + v[2] += z +} + +func (v *MVec4) SubZ(z float64) { + v[2] -= z +} + +func (v *MVec4) MulZ(z float64) { + v[2] *= z +} + +func (v *MVec4) DivZ(z float64) { + v[2] /= z +} + +// GetW returns the value of the W coordinate +func (v *MVec4) GetW() float64 { + return v[3] +} + +// SetW sets the value of the W coordinate +func (v *MVec4) SetW(w float64) { + v[3] = w +} + +func (v *MVec4) AddW(w float64) { + v[3] += w +} + +func (v *MVec4) SubW(w float64) { + v[3] -= w +} + +func (v *MVec4) MulW(w float64) { + v[3] *= w +} + +func (v *MVec4) DivW(w float64) { + v[3] /= w +} + +func (v *MVec4) GetXY() *MVec2 { + return &MVec2{v[0], v[1]} +} + +func (v *MVec4) GetXYZ() *MVec3 { + return &MVec3{v[0], v[1], v[2]} +} + +// String T の文字列表現を返します。 +func (v *MVec4) String() string { + return fmt.Sprintf("[x=%.5f, y=%.5f, z=%.5f, w=%.5f]", v.GetX(), v.GetY(), v.GetZ(), v.GetW()) +} + +// MMD MMD(MikuMikuDance)座標系に変換された2次元ベクトルを返します +func (v *MVec4) MMD() *MVec4 { + return &MVec4{v.GetX(), v.GetY(), v.GetZ(), v.GetW()} +} + +// Add ベクトルに他のベクトルを加算します +func (v *MVec4) Add(other *MVec4) *MVec4 { + v[0] += other[0] + v[1] += other[1] + v[2] += other[2] + v[3] += other[3] + return v +} + +// AddScalar ベクトルの各要素にスカラーを加算します +func (v *MVec4) AddScalar(s float64) *MVec4 { + v[0] += s + v[1] += s + v[2] += s + v[3] += s + return v +} + +// Added ベクトルに他のベクトルを加算した結果を返します +func (v *MVec4) Added(other *MVec4) *MVec4 { + return &MVec4{v[0] + other[0], v[1] + other[1], v[2] + other[2], v[3] + other[3]} +} + +func (v *MVec4) AddedScalar(s float64) *MVec4 { + return &MVec4{v[0] + s, v[1] + s, v[2] + s, v[3] + s} +} + +// Sub ベクトルから他のベクトルを減算します +func (v *MVec4) Sub(other *MVec4) *MVec4 { + v[0] -= other[0] + v[1] -= other[1] + v[2] -= other[2] + v[3] -= other[3] + return v +} + +// SubScalar ベクトルの各要素からスカラーを減算します +func (v *MVec4) SubScalar(s float64) *MVec4 { + v[0] -= s + v[1] -= s + v[2] -= s + v[3] -= s + return v +} + +// Subed ベクトルから他のベクトルを減算した結果を返します +func (v *MVec4) Subed(other *MVec4) *MVec4 { + return &MVec4{v[0] - other[0], v[1] - other[1], v[2] - other[2], v[3] - other[3]} +} + +func (v *MVec4) SubedScalar(s float64) *MVec4 { + return &MVec4{v[0] - s, v[1] - s, v[2] - s, v[3] - s} +} + +// Mul ベクトルの各要素に他のベクトルの各要素を乗算します +func (v *MVec4) Mul(other *MVec4) *MVec4 { + v[0] *= other[0] + v[1] *= other[1] + v[2] *= other[2] + v[3] *= other[3] + return v +} + +// MulScalar ベクトルの各要素にスカラーを乗算します +func (v *MVec4) MulScalar(s float64) *MVec4 { + v[0] *= s + v[1] *= s + v[2] *= s + v[3] *= s + return v +} + +// Muled ベクトルの各要素に他のベクトルの各要素を乗算した結果を返します +func (v *MVec4) Muled(other *MVec4) *MVec4 { + return &MVec4{v[0] * other[0], v[1] * other[1], v[2] * other[2], v[3] * other[3]} +} + +func (v *MVec4) MuledScalar(s float64) *MVec4 { + return &MVec4{v[0] * s, v[1] * s, v[2] * s, v[3] * s} +} + +// Div ベクトルの各要素を他のベクトルの各要素で除算します +func (v *MVec4) Div(other *MVec4) *MVec4 { + v[0] /= other[0] + v[1] /= other[1] + v[2] /= other[2] + v[3] /= other[3] + return v +} + +// DivScalar ベクトルの各要素をスカラーで除算します +func (v *MVec4) DivScalar(s float64) *MVec4 { + v[0] /= s + v[1] /= s + v[2] /= s + v[3] /= s + return v +} + +// Dived ベクトルの各要素を他のベクトルの各要素で除算した結果を返します +func (v *MVec4) Dived(other *MVec4) *MVec4 { + return &MVec4{v[0] / other[0], v[1] / other[1], v[2] / other[2], v[3] / other[3]} +} + +// DivedScalar ベクトルの各要素をスカラーで除算した結果を返します +func (v *MVec4) DivedScalar(s float64) *MVec4 { + return &MVec4{v[0] / s, v[1] / s, v[2] / s, v[3] / s} +} + +// Equal ベクトルが他のベクトルと等しいかどうかをチェックします +func (v *MVec4) Equals(other *MVec4) bool { + return v.GetX() == other.GetX() && v.GetY() == other.GetY() && v.GetZ() == other.GetZ() && v.GetW() == other.GetW() +} + +// NotEqual ベクトルが他のベクトルと等しくないかどうかをチェックします +func (v *MVec4) NotEquals(other MVec4) bool { + return v.GetX() != other.GetX() || v.GetY() != other.GetY() || v.GetZ() != other.GetZ() || v.GetW() != other.GetW() +} + +// NearEquals ベクトルが他のベクトルとほぼ等しいかどうかをチェックします +func (v *MVec4) NearEquals(other *MVec4, epsilon float64) bool { + return (math.Abs(v[0]-other[0]) <= epsilon) && + (math.Abs(v[1]-other[1]) <= epsilon) && + (math.Abs(v[2]-other[2]) <= epsilon) && + (math.Abs(v[3]-other[3]) <= epsilon) +} + +// LessThan ベクトルが他のベクトルより小さいかどうかをチェックします (<) +func (v *MVec4) LessThan(other *MVec4) bool { + return v.GetX() < other.GetX() && v.GetY() < other.GetY() && v.GetZ() < other.GetZ() && v.GetW() < other.GetW() +} + +// LessThanOrEqual ベクトルが他のベクトル以下かどうかをチェックします (<=) +func (v *MVec4) LessThanOrEquals(other *MVec4) bool { + return v.GetX() <= other.GetX() && v.GetY() <= other.GetY() && v.GetZ() <= other.GetZ() && v.GetW() <= other.GetW() +} + +// GreaterThan ベクトルが他のベクトルより大きいかどうかをチェックします (>) +func (v *MVec4) GreaterThan(other *MVec4) bool { + return v.GetX() > other.GetX() && v.GetY() > other.GetY() && v.GetZ() > other.GetZ() && v.GetW() > other.GetW() +} + +// GreaterThanOrEqual ベクトルが他のベクトル以上かどうかをチェックします (>=) +func (v *MVec4) GreaterThanOrEquals(other *MVec4) bool { + return v.GetX() >= other.GetX() && v.GetY() >= other.GetY() && v.GetZ() >= other.GetZ() && v.GetW() >= other.GetW() +} + +// Inverse ベクトルの各要素の符号を反転します (-v) +func (v *MVec4) Inverse() *MVec4 { + v[0] = -v[0] + v[1] = -v[1] + v[2] = -v[2] + v[3] = -v[3] + return v +} + +// Inverted ベクトルの各要素の符号を反転した結果を返します (-v) +func (v *MVec4) Inverted() *MVec4 { + return &MVec4{-v[0], -v[1], -v[2], -v[3]} +} + +// Abs ベクトルの各要素の絶対値を返します +func (v *MVec4) Abs() *MVec4 { + v[0] = math.Abs(v[0]) + v[1] = math.Abs(v[1]) + v[2] = math.Abs(v[2]) + v[3] = math.Abs(v[3]) + return v +} + +// Absed ベクトルの各要素の絶対値を返します +func (v *MVec4) Absed() *MVec4 { + return &MVec4{math.Abs(v[0]), math.Abs(v[1]), math.Abs(v[2]), math.Abs(v[3])} +} + +// Hash ベクトルのハッシュ値を計算します +func (v *MVec4) Hash() uint64 { + h := fnv.New64a() + h.Write([]byte(fmt.Sprintf("%.10f,%.10f,%.10f,%.10f", v.GetX(), v.GetY(), v.GetZ(), v.GetW()))) + return h.Sum64() +} + +// IsZero ベクトルがゼロベクトルかどうかをチェックします +func (v *MVec4) IsZero() bool { + return v[0] == 0 && v[1] == 0 && v[2] == 0 && v[3] == 0 +} + +// Length ベクトルの長さを返します +func (v *MVec4) Length() float64 { + v3 := v.Vec3DividedByW() + return v3.Length() +} + +// LengthSqr ベクトルの長さの2乗を返します +func (v *MVec4) LengthSqr() float64 { + v3 := v.Vec3DividedByW() + return v3.LengthSqr() +} + +// Normalize ベクトルを正規化します +func (v *MVec4) Normalize() *MVec4 { + v3 := v.Vec3DividedByW() + v3.Normalize() + v[0] = v3[0] + v[1] = v3[1] + v[2] = v3[2] + v[3] = 1 + return v +} + +// Normalized ベクトルを正規化した結果を返します +func (v *MVec4) Normalized() *MVec4 { + vec := *v + vec.Normalize() + return &vec +} + +// Angle ベクトルの角度(ラジアン角度)を返します +func (v *MVec4) Angle(other *MVec4) float64 { + vec := v.Dot(other) / (v.Length() * other.Length()) + // prevent NaN + if vec > 1. { + vec = vec - 2 + } else if vec < -1. { + vec = vec + 2 + } + return math.Acos(vec) +} + +// Degree ベクトルの角度(度数)を返します +func (v *MVec4) Degree(other *MVec4) float64 { + radian := v.Angle(other) + degree := radian * (180 / math.Pi) + return degree +} + +// Dot ベクトルの内積を返します +func (v *MVec4) Dot(other *MVec4) float64 { + a3 := v.Vec3DividedByW() + b3 := other.Vec3DividedByW() + return a3.Dot(b3) +} + +// Dot4 returns the 4 element vdot product of two vectors. +func Dot4(a, b *MVec4) float64 { + return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3] +} + +// Cross ベクトルの外積を返します +func (v *MVec4) Cross(other *MVec4) *MVec4 { + a3 := v.Vec3DividedByW() + b3 := other.Vec3DividedByW() + c3 := a3.Cross(b3) + return &MVec4{c3[0], c3[1], c3[2], 1} +} + +// Min ベクトルの各要素の最小値をTの各要素に設定して返します +func (v *MVec4) Min() *MVec4 { + min := v.GetX() + if v.GetY() < min { + min = v.GetY() + } + if v.GetZ() < min { + min = v.GetZ() + } + if v.GetW() < min { + min = v.GetW() + } + return &MVec4{min, min, min, min} +} + +// Max ベクトルの各要素の最大値を返します +func (v *MVec4) Max() *MVec4 { + max := v.GetX() + if v.GetY() > max { + max = v.GetY() + } + if v.GetZ() > max { + max = v.GetZ() + } + if v.GetW() > max { + max = v.GetW() + } + return &MVec4{max, max, max, max} +} + +// Interpolate ベクトルの線形補間を行います +func (v *MVec4) Interpolate(other *MVec4, t float64) *MVec4 { + t1 := 1 - t + return &MVec4{ + v[0]*t1 + other[0]*t, + v[1]*t1 + other[1]*t, + v[2]*t1 + other[2]*t, + v[3]*t1 + other[3]*t, + } +} + +// Clamp ベクトルの各要素を指定された範囲内にクランプします +func (v *MVec4) Clamp(min, max *MVec4) *MVec4 { + for i := range v { + if v[i] < min[i] { + v[i] = min[i] + } else if v[i] > max[i] { + v[i] = max[i] + } + } + return v +} + +// Clamped ベクトルの各要素を指定された範囲内にクランプした結果を返します +func (v *MVec4) Clamped(min, max *MVec4) *MVec4 { + result := *v + result.Clamp(min, max) + return &result +} + +// Clamp01 ベクトルの各要素を0.0～1.0の範囲内にクランプします +func (v *MVec4) Clamp01() *MVec4 { + return v.Clamp(MVec4Zero, MVec4One) +} + +// Clamped01 ベクトルの各要素を0.0～1.0の範囲内にクランプした結果を返します +func (v *MVec4) Clamped01() *MVec4 { + result := *v + result.Clamp01() + return &result +} + +// Copy +func (v *MVec4) Copy() *MVec4 { + copied := MVec4{v.GetX(), v.GetY(), v.GetZ(), v.GetW()} + return &copied +} + +// Vector +func (v *MVec4) Vector() []float64 { + return []float64{v.GetX(), v.GetY(), v.GetZ(), v.GetW()} +} + +// 線形補間 +func (v1 *MVec4) Lerp(v2 *MVec4, t float64) *MVec4 { + return (v2.Subed(v1)).MulScalar(t).Add(v1) +} + +func (v *MVec4) Round() *MVec4 { + return &MVec4{ + math.Round(v.GetX()), + math.Round(v.GetY()), + math.Round(v.GetZ()), + math.Round(v.GetW()), + } +} + +// Vec3DividedByW returns a vec3.T version of the vector by dividing the first three vector components (XYZ) by the last one (W). +func (vec *MVec4) Vec3DividedByW() *MVec3 { + oow := 1 / vec[3] + return &MVec3{vec[0] * oow, vec[1] * oow, vec[2] * oow} +} + +// DividedByW returns a copy of the vector with the first three components (XYZ) divided by the last one (W). +func (vec *MVec4) DividedByW() *MVec4 { + oow := 1 / vec[3] + return &MVec4{vec[0] * oow, vec[1] * oow, vec[2] * oow, 1} +} + +// DivideByW divides the first three components (XYZ) by the last one (W). +func (vec *MVec4) DivideByW() *MVec4 { + oow := 1 / vec[3] + vec[0] *= oow + vec[1] *= oow + vec[2] *= oow + vec[3] = 1 + return vec +} + +// 標準偏差を加味したmean処理 +func StdMeanVec4(values []MVec4, err float64) *MVec4 { + npStandardVectors := make([][]float64, len(values)) + npStandardLengths := make([]float64, len(values)) + + for i, v := range values { + npStandardVectors[i] = v.Vector() + npStandardLengths[i] = v.Length() + } + + medianStandardValues := Median(npStandardLengths) + stdStandardValues := Std(npStandardLengths) + + // 中央値から標準偏差の一定範囲までの値を取得 + var filteredStandardValues [][]float64 + for i := 0; i < len(npStandardVectors); i++ { + if npStandardLengths[i] >= medianStandardValues-err*stdStandardValues && + npStandardLengths[i] <= medianStandardValues+err*stdStandardValues { + filteredStandardValues = append(filteredStandardValues, npStandardVectors[i]) + } + } + + mean := Mean2DVertical(filteredStandardValues) + return &MVec4{mean[0], mean[1], mean[2], mean[3]} +} + +// One 0を1に変える +func (v *MVec4) One() *MVec4 { + vec := v.Vector() + epsilon := 1e-14 + for i := 0; i < len(vec); i++ { + if math.Abs(vec[i]) < epsilon { + vec[i] = 1 + } + } + return &MVec4{vec[0], vec[1], vec[2], vec[3]} +} + +func (v *MVec4) Distance(other *MVec4) float64 { + s := v.Subed(other) + return s.Length() +} + +// ClampIfVerySmall ベクトルの各要素がとても小さい場合、ゼロを設定する +func (v *MVec4) ClampIfVerySmall() *MVec4 { + epsilon := 1e-6 + if math.Abs(v.GetX()) < epsilon { + v.SetX(0) + } + if math.Abs(v.GetY()) < epsilon { + v.SetY(0) + } + if math.Abs(v.GetZ()) < epsilon { + v.SetZ(0) + } + if math.Abs(v.GetW()) < epsilon { + v.SetW(0) + } + return v +} diff --git a/pkg/mmath/mvec4_test.go b/pkg/mmath/mvec4_test.go new file mode 100644 index 00000000..cf7567a3 --- /dev/null +++ b/pkg/mmath/mvec4_test.go @@ -0,0 +1,195 @@ +package mmath + +import ( + "math" + "testing" +) + +func TestMVec4Interpolate(t *testing.T) { + v1 := MVec4{1, 2, 3} + v2 := &MVec4{4, 5, 6} // Pass the address of v2 + t1 := 0.5 + expected := MVec4{2.5, 3.5, 4.5} + + result := v1.Interpolate(v2, t1) // Use v2 as a pointer + + if !result.NearEquals(&expected, 1e-8) { + t.Errorf("Interpolation failed. Expected %v, got %v", expected, result) + } +} + +func TestMVec4NearEquals(t *testing.T) { + v1 := MVec4{1, 2, 3} + v2 := MVec4{1.000001, 2.000001, 3.000001} + epsilon := 0.00001 + + if !v1.NearEquals(&v2, epsilon) { + t.Errorf("NearEquals failed. Expected true, got false") + } + + v3 := MVec4{1, 2, 3} + v4 := MVec4{1.0001, 2.0001, 3.0001} + + if v3.NearEquals(&v4, epsilon) { + t.Errorf("NearEquals failed. Expected false, got true") + } +} + +func TestMVec4LessThan(t *testing.T) { + v1 := MVec4{1, 2, 3, 4} + v2 := MVec4{4, 5, 6, 7} + + if !v1.LessThan(&v2) { + t.Errorf("LessThan failed. Expected true, got false") + } + + v3 := MVec4{3, 4, 5, 6} + v4 := MVec4{1, 2, 3, 4} + + if v3.LessThan(&v4) { + t.Errorf("LessThan failed. Expected false, got true") + } +} + +func TestMVec4LessThanOrEquals(t *testing.T) { + v1 := MVec4{1, 2, 3, 4} + v2 := MVec4{3, 4, 5, 6} + + if !v1.LessThanOrEquals(&v2) { + t.Errorf("LessThanOrEqual failed. Expected true, got false") + } + + v3 := MVec4{3, 4, 5, 6} + v4 := MVec4{1, 2, 3, 4} + + if v3.LessThanOrEquals(&v4) { + t.Errorf("LessThanOrEqual failed. Expected false, got true") + } + + v5 := MVec4{1, 2, 3, 4} + v6 := MVec4{1, 2, 3, 4} + + if !v5.LessThanOrEquals(&v6) { + t.Errorf("LessThanOrEqual failed. Expected true, got false") + } +} + +func TestMVec4GreaterThan(t *testing.T) { + v1 := MVec4{1, 2, 3, 4} + v2 := MVec4{3, 4, 5, 6} + + if v1.GreaterThan(&v2) { + t.Errorf("GreaterThan failed. Expected false, got true") + } + + v3 := MVec4{3, 4, 5, 6} + v4 := MVec4{1, 2, 3, 4} + + if !v3.GreaterThan(&v4) { + t.Errorf("GreaterThan failed. Expected true, got false") + } +} + +func TestMVec4GreaterThanOrEquals(t *testing.T) { + v1 := MVec4{1, 2, 3} + v2 := MVec4{3, 4, 5} + + if v1.GreaterThanOrEquals(&v2) { + t.Errorf("GreaterThanOrEqual failed. Expected false, got true") + } + + v3 := MVec4{3, 4, 5} + v4 := MVec4{1, 2, 3} + + if !v3.GreaterThanOrEquals(&v4) { + t.Errorf("GreaterThanOrEqual failed. Expected true, got false") + } + + v5 := MVec4{1, 2, 3} + v6 := MVec4{1, 2, 3} + + if !v5.GreaterThanOrEquals(&v6) { + t.Errorf("GreaterThanOrEqual failed. Expected true, got false") + } +} + +func TestMVec4Inverted(t *testing.T) { + v1 := MVec4{1, 2, 3} + v2 := MVec4{3, 4, 5} + + iv1 := v1.Inverted() + if iv1.GetX() != -1 || iv1.GetY() != -2 || iv1.GetZ() != -3 { + t.Errorf("Inverse failed. Expected (-1, -2, -3), got (%v, %v, %v)", iv1.GetX(), iv1.GetY(), iv1.GetZ()) + } + + iv2 := v2.Inverted() + if iv2.GetX() != -3 || iv2.GetY() != -4 || iv2.GetZ() != -5 { + t.Errorf("Inverse failed. Expected (-3, -4, -5), got (%v, %v, %v)", iv2.GetX(), iv2.GetY(), iv2.GetZ()) + } +} + +func TestMVec4Abs(t *testing.T) { + v1 := MVec4{-1, -2, -3} + expected1 := MVec4{1, 2, 3} + result1 := v1.Abs() + if !result1.Equals(&expected1) { + t.Errorf("Abs failed. Expected %v, got %v", expected1, result1) + } + + v2 := MVec4{3, -4, 5} + expected2 := MVec4{3, 4, 5} + result2 := v2.Abs() + if !result2.Equals(&expected2) { + t.Errorf("Abs failed. Expected %v, got %v", expected2, result2) + } + + v3 := MVec4{0, 0} + expected3 := MVec4{0, 0} + result3 := v3.Abs() + if !result3.Equals(&expected3) { + t.Errorf("Abs failed. Expected %v, got %v", expected3, result3) + } +} + +func TestMVec4Hash(t *testing.T) { + v := MVec4{1, 2, 3, 4} + expected := uint64(13473159861922604751) + result := v.Hash() + if result != expected { + t.Errorf("Hash failed. Expected %v, got %v", expected, result) + } +} + +func TestMVec4Angle(t *testing.T) { + v1 := MVec4{1, 0, 0, 1} + v2 := MVec4{0, 1, 0, 1} + expected := math.Pi / 2 + result := v1.Angle(&v2) + if result != expected { + t.Errorf("Angle failed. Expected %v, got %v", expected, result) + } + + v3 := MVec4{1, 1, 1, 1} + expected2 := 0.9553166181245092 + result2 := v1.Angle(&v3) + if result2 != expected2 { + t.Errorf("Angle failed. Expected %v, got %v", expected2, result2) + } +} + +func TestMVec4Degree(t *testing.T) { + v1 := MVec4{1, 0, 0} + v2 := MVec4{0, 1, 0} + expected := 90.0 + result := v1.Degree(&v2) + if math.Abs(result-expected) > 0.00001 { + t.Errorf("Degree failed. Expected %v, got %v", expected, result) + } + + v3 := MVec4{1, 1, 1} + expected2 := 54.735610317245346 + result2 := v1.Degree(&v3) + if math.Abs(result2-expected2) > 0.00001 { + t.Errorf("Degree failed. Expected %v, got %v", expected2, result2) + } +} diff --git a/pkg/mmath/utils.go b/pkg/mmath/utils.go new file mode 100644 index 00000000..280e3323 --- /dev/null +++ b/pkg/mmath/utils.go @@ -0,0 +1,206 @@ +package mmath + +import ( + "math" + "slices" + "sort" +) + +func IsPowerOfTwo(n int) bool { + if n <= 0 { + return false + } + return (n & (n - 1)) == 0 +} + +func BoolToInt(b bool) int { + if b { + return 1 + } + return 0 +} + +func BoolToFlag(b bool) float64 { + if b { + return 1.0 + } + return -1.0 +} + +// slices.Contains の高速版 +func Contains[S ~[]E, E comparable](s S, v E) bool { + if len(s) <= 20 { + return slices.Contains(s, v) + } + + set := make(map[E]bool, len(s)) + for _, s := range s { + set[s] = true + } + + _, exists := set[v] + return exists +} + +func MaxInt(arr []int) int { + max := math.MinInt64 + for _, v := range arr { + if v > max { + max = v + } + } + return max +} + +func MaxFloat(arr []float64) float64 { + max := math.SmallestNonzeroFloat64 + for _, v := range arr { + if v > max { + max = v + } + } + return max +} + +// 中央値計算 +func Median(nums []float64) float64 { + sortedNums := make([]float64, len(nums)) + copy(sortedNums, nums) + sort.Float64s(sortedNums) + middle := len(sortedNums) / 2 + if len(sortedNums)%2 == 0 { + return (sortedNums[middle-1] + sortedNums[middle]) / 2 + } else { + return sortedNums[middle] + } +} + +// 標準偏差計算 +func Std(nums []float64) float64 { + mean := Mean(nums) + variance := 0.0 + for _, num := range nums { + variance += math.Pow(num-mean, 2) + } + return math.Sqrt(variance / float64(len(nums))) +} + +// 平均値計算 +func Mean(nums []float64) float64 { + total := 0.0 + for _, num := range nums { + total += num + } + return total / float64(len(nums)) +} + +// 二次元配列の平均値計算(列基準) +func Mean2DVertical(nums [][]float64) []float64 { + vertical := make([]float64, len(nums[0])) + for _, num := range nums { + for i, n := range num { + vertical[i] += n + } + } + for i, n := range vertical { + vertical[i] = n / float64(len(nums)) + } + return vertical +} + +// 二次元配列の平均値計算(行基準) +func Mean2DHorizontal(nums [][]float64) []float64 { + horizontal := make([]float64, len(nums)) + for i, num := range nums { + horizontal[i] = Mean(num) + } + return horizontal +} + +// ------------------ + +func SearchFloat32s(a []float32, x float32) int { + return sort.Search(len(a), func(i int) bool { return a[i] >= x }) +} + +func SortFloat32s(x []float32) { sort.Sort(Float32Slice(x)) } + +// Float32Slice implements Interface for a []float32, sorting in increasing order, +// with not-a-number (NaN) values ordered before other values. +type Float32Slice []float32 + +func (x Float32Slice) Len() int { return len(x) } + +// Less reports whether x[i] should be ordered before x[j], as required by the sort Interface. +// Note that floating-point comparison by itself is not a transitive relation: it does not +// report a consistent ordering for not-a-number (NaN) values. +// This implementation of Less places NaN values before any others, by using: +// +// x[i] < x[j] || (math.IsNaN(x[i]) && !math.IsNaN(x[j])) +func (x Float32Slice) Less(i, j int) bool { return x[i] < x[j] || (isNaN32(x[i]) && !isNaN32(x[j])) } +func (x Float32Slice) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +// isNaN32 is a copy of math.IsNaN to avoid a dependency on the math package. +func isNaN32(f float32) bool { + return math.IsNaN(float64(f)) +} + +// Sort is a convenience method: x.Sort() calls Sort(x). +func (x Float32Slice) Sort() { sort.Sort(x) } + +// ------------------ + +func SearchFloat64s(a []float64, x float64) int { + return sort.Search(len(a), func(i int) bool { return a[i] >= x }) +} + +func SortFloat64s(x []float64) { sort.Sort(Float64Slice(x)) } + +// Float64Slice implements Interface for a []float64, sorting in increasing order, +// with not-a-number (NaN) values ordered before other values. +type Float64Slice []float64 + +func (x Float64Slice) Len() int { return len(x) } + +// Less reports whether x[i] should be ordered before x[j], as required by the sort Interface. +// Note that floating-point comparison by itself is not a transitive relation: it does not +// report a consistent ordering for not-a-number (NaN) values. +// This implementation of Less places NaN values before any others, by using: +// +// x[i] < x[j] || (math.IsNaN(x[i]) && !math.IsNaN(x[j])) +func (x Float64Slice) Less(i, j int) bool { return x[i] < x[j] || (isNaN64(x[i]) && !isNaN64(x[j])) } +func (x Float64Slice) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +// isNaN64 is a copy of math.IsNaN to avoid a dependency on the math package. +func isNaN64(f float64) bool { + return math.IsNaN(f) +} + +// Sort is a convenience method: x.Sort() calls Sort(x). +func (x Float64Slice) Sort() { sort.Sort(x) } + +// ------------------ + +func SearchInts(a []int, x int) int { + return sort.Search(len(a), func(i int) bool { return a[i] >= x }) +} + +func SortInts(x []int) { sort.Sort(IntSlice(x)) } + +// IntSlice implements Interface for a []int, sorting in increasing order, +// with not-a-number (NaN) values ordered before other values. +type IntSlice []int + +func (x IntSlice) Len() int { return len(x) } + +// Less reports whether x[i] should be ordered before x[j], as required by the sort Interface. +// Note that floating-point comparison by itself is not a transitive relation: it does not +// report a consistent ordering for not-a-number (NaN) values. +// This implementation of Less places NaN values before any others, by using: +// +// x[i] < x[j] || (math.IsNaN(x[i]) && !math.IsNaN(x[j])) +func (x IntSlice) Less(i, j int) bool { return x[i] < x[j] } +func (x IntSlice) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +// Sort is a convenience method: x.Sort() calls Sort(x). +func (x IntSlice) Sort() { sort.Sort(x) } diff --git a/pkg/mphysics/debug_view.go b/pkg/mphysics/debug_view.go new file mode 100644 index 00000000..c3f5feef --- /dev/null +++ b/pkg/mphysics/debug_view.go @@ -0,0 +1,85 @@ +//go:build windows +// +build windows + +package mphysics + +import ( + "github.com/go-gl/gl/v4.4-core/gl" + + "github.com/miu200521358/mlib_go/pkg/mphysics/mbt" + "github.com/miu200521358/mlib_go/pkg/mview" +) + +func NewConstBtMDefaultColors() mbt.BtMDefaultColors { + return mbt.NewBtMDefaultColors( + mbt.NewBtVector3(float32(1.0), float32(0.0), float32(0.0)), // activeObject (物理剛体) + mbt.NewBtVector3(float32(0.5), float32(0.5), float32(0.0)), // deactivatedObject + mbt.NewBtVector3(float32(0.5), float32(0.0), float32(0.5)), // wantsDeactivationObject + mbt.NewBtVector3(float32(0.0), float32(0.5), float32(0.5)), // disabledDeactivationObject + mbt.NewBtVector3(float32(0.0), float32(1.0), float32(0.0)), // disabledSimulationObject (ボーン追従剛体) + mbt.NewBtVector3(float32(1.0), float32(1.0), float32(0.0)), // aabb + mbt.NewBtVector3(float32(0.0), float32(0.0), float32(1.0)), // contactPoint + ) +} + +type MDebugDrawLiner struct { + mbt.BtMDebugDrawLiner + shader *mview.MShader + vao *mview.VAO + vbo *mview.VBO + vertices []float32 + count int +} + +func NewMDebugDrawLiner(shader *mview.MShader) *MDebugDrawLiner { + ddl := &MDebugDrawLiner{ + shader: shader, + vertices: make([]float32, 0), + } + + ddl.vao = mview.NewVAO() + ddl.vao.Bind() + ddl.vbo = mview.NewVBOForDebug() + ddl.vbo.Unbind() + ddl.vao.Unbind() + + ddl.BtMDebugDrawLiner = mbt.NewDirectorBtMDebugDrawLiner(ddl) + + return ddl +} + +func (ddl *MDebugDrawLiner) DrawLine(from mbt.BtVector3, to mbt.BtVector3, color mbt.BtVector3) { + ddl.vertices = append(ddl.vertices, from.GetX(), from.GetY(), from.GetZ()) + ddl.vertices = append(ddl.vertices, color.GetX(), color.GetY(), color.GetZ(), 0.6) + ddl.count++ + + ddl.vertices = append(ddl.vertices, to.GetX(), to.GetY(), to.GetZ()) + ddl.vertices = append(ddl.vertices, color.GetX(), color.GetY(), color.GetZ(), 0.6) + ddl.count++ +} + +func (ddl *MDebugDrawLiner) DrawDebugLines() { + if ddl.shader.IsDrawRigidBodyFront { + // モデルメッシュの前面に描画するために深度テストを無効化 + gl.Enable(gl.DEPTH_TEST) + gl.DepthFunc(gl.ALWAYS) + } + + ddl.shader.Use(mview.PROGRAM_TYPE_PHYSICS) + + // 線を引く + ddl.vao.Bind() + ddl.vbo.BindDebug(ddl.vertices) + + // ライン描画 + gl.DrawArrays(gl.LINES, 0, int32(ddl.count)) + + ddl.vbo.Unbind() + ddl.vao.Unbind() + + ddl.shader.Unuse() + + // 深度テストを有効に戻す + gl.Enable(gl.DEPTH_TEST) + gl.DepthFunc(gl.LEQUAL) +} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp new file mode 100644 index 00000000..29310ec0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp @@ -0,0 +1,33 @@ + +//Bullet Continuous Collision Detection and Physics Library +//Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +// +// btAxisSweep3 +// +// Copyright (c) 2006 Simon Hobbs +// +// This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +#include "btAxisSweep3.h" + +btAxisSweep3::btAxisSweep3(const btVector3& worldAabbMin, const btVector3& worldAabbMax, unsigned short int maxHandles, btOverlappingPairCache* pairCache, bool disableRaycastAccelerator) + : btAxisSweep3Internal(worldAabbMin, worldAabbMax, 0xfffe, 0xffff, maxHandles, pairCache, disableRaycastAccelerator) +{ + // 1 handle is reserved as sentinel + btAssert(maxHandles > 1 && maxHandles < 32767); +} + +bt32BitAxisSweep3::bt32BitAxisSweep3(const btVector3& worldAabbMin, const btVector3& worldAabbMax, unsigned int maxHandles, btOverlappingPairCache* pairCache, bool disableRaycastAccelerator) + : btAxisSweep3Internal(worldAabbMin, worldAabbMax, 0xfffffffe, 0x7fffffff, maxHandles, pairCache, disableRaycastAccelerator) +{ + // 1 handle is reserved as sentinel + btAssert(maxHandles > 1 && maxHandles < 2147483647); +} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp.i new file mode 100644 index 00000000..a7daa36a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btAxisSweep3.cpp ---------------- + +%include "BulletCollision/BroadphaseCollision/btAxisSweep3.cpp" + +%{ +#include "BulletCollision/BroadphaseCollision/btAxisSweep3.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.h new file mode 100644 index 00000000..4f5f614e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.h @@ -0,0 +1,48 @@ +//Bullet Continuous Collision Detection and Physics Library +//Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +// +// btAxisSweep3.h +// +// Copyright (c) 2006 Simon Hobbs +// +// 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_AXIS_SWEEP_3_H +#define BT_AXIS_SWEEP_3_H + +#include "LinearMath/btVector3.h" +#include "btOverlappingPairCache.h" +#include "btBroadphaseInterface.h" +#include "btBroadphaseProxy.h" +#include "btOverlappingPairCallback.h" +#include "btDbvtBroadphase.h" +#include "btAxisSweep3Internal.h" + +/// The btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase. +/// It uses arrays rather then lists for storage of the 3 axis. Also it operates using 16 bit integer coordinates instead of floats. +/// For large worlds and many objects, use bt32BitAxisSweep3 or btDbvtBroadphase instead. bt32BitAxisSweep3 has higher precision and allows more then 16384 objects at the cost of more memory and bit of performance. +class btAxisSweep3 : public btAxisSweep3Internal +{ +public: + btAxisSweep3(const btVector3& worldAabbMin, const btVector3& worldAabbMax, unsigned short int maxHandles = 16384, btOverlappingPairCache* pairCache = 0, bool disableRaycastAccelerator = false); +}; + +/// The bt32BitAxisSweep3 allows higher precision quantization and more objects compared to the btAxisSweep3 sweep and prune. +/// This comes at the cost of more memory per handle, and a bit slower performance. +/// It uses arrays rather then lists for storage of the 3 axis. +class bt32BitAxisSweep3 : public btAxisSweep3Internal +{ +public: + bt32BitAxisSweep3(const btVector3& worldAabbMin, const btVector3& worldAabbMax, unsigned int maxHandles = 1500000, btOverlappingPairCache* pairCache = 0, bool disableRaycastAccelerator = false); +}; + +#endif diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.h.i new file mode 100644 index 00000000..d8ed5dbc --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btAxisSweep3.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btAxisSweep3.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btAxisSweep3.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h new file mode 100644 index 00000000..e481fdc2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h @@ -0,0 +1,954 @@ +//Bullet Continuous Collision Detection and Physics Library +//Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +// +// btAxisSweep3.h +// +// Copyright (c) 2006 Simon Hobbs +// +// 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_AXIS_SWEEP_3_INTERNAL_H +#define BT_AXIS_SWEEP_3_INTERNAL_H + +#include "LinearMath/btVector3.h" +#include "btOverlappingPairCache.h" +#include "btBroadphaseInterface.h" +#include "btBroadphaseProxy.h" +#include "btOverlappingPairCallback.h" +#include "btDbvtBroadphase.h" + +//#define DEBUG_BROADPHASE 1 +#define USE_OVERLAP_TEST_ON_REMOVES 1 + +/// The internal templace class btAxisSweep3Internal implements the sweep and prune broadphase. +/// It uses quantized integers to represent the begin and end points for each of the 3 axis. +/// Dont use this class directly, use btAxisSweep3 or bt32BitAxisSweep3 instead. +template +class btAxisSweep3Internal : public btBroadphaseInterface +{ +protected: + BP_FP_INT_TYPE m_bpHandleMask; + BP_FP_INT_TYPE m_handleSentinel; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + class Edge + { + public: + BP_FP_INT_TYPE m_pos; // low bit is min/max + BP_FP_INT_TYPE m_handle; + + BP_FP_INT_TYPE IsMax() const { return static_cast(m_pos & 1); } + }; + +public: + class Handle : public btBroadphaseProxy + { + public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + // indexes into the edge arrays + BP_FP_INT_TYPE m_minEdges[3], m_maxEdges[3]; // 6 * 2 = 12 + // BP_FP_INT_TYPE m_uniqueId; + btBroadphaseProxy* m_dbvtProxy; //for faster raycast + //void* m_pOwner; this is now in btBroadphaseProxy.m_clientObject + + SIMD_FORCE_INLINE void SetNextFree(BP_FP_INT_TYPE next) { m_minEdges[0] = next; } + SIMD_FORCE_INLINE BP_FP_INT_TYPE GetNextFree() const { return m_minEdges[0]; } + }; // 24 bytes + 24 for Edge structures = 44 bytes total per entry + +protected: + btVector3 m_worldAabbMin; // overall system bounds + btVector3 m_worldAabbMax; // overall system bounds + + btVector3 m_quantize; // scaling factor for quantization + + BP_FP_INT_TYPE m_numHandles; // number of active handles + BP_FP_INT_TYPE m_maxHandles; // max number of handles + Handle* m_pHandles; // handles pool + + BP_FP_INT_TYPE m_firstFreeHandle; // free handles list + + Edge* m_pEdges[3]; // edge arrays for the 3 axes (each array has m_maxHandles * 2 + 2 sentinel entries) + void* m_pEdgesRawPtr[3]; + + btOverlappingPairCache* m_pairCache; + + ///btOverlappingPairCallback is an additional optional user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache. + btOverlappingPairCallback* m_userPairCallback; + + bool m_ownsPairCache; + + int m_invalidPair; + + ///additional dynamic aabb structure, used to accelerate ray cast queries. + ///can be disabled using a optional argument in the constructor + btDbvtBroadphase* m_raycastAccelerator; + btOverlappingPairCache* m_nullPairCache; + + // allocation/deallocation + BP_FP_INT_TYPE allocHandle(); + void freeHandle(BP_FP_INT_TYPE handle); + + bool testOverlap2D(const Handle* pHandleA, const Handle* pHandleB, int axis0, int axis1); + +#ifdef DEBUG_BROADPHASE + void debugPrintAxis(int axis, bool checkCardinality = true); +#endif //DEBUG_BROADPHASE + + //Overlap* AddOverlap(BP_FP_INT_TYPE handleA, BP_FP_INT_TYPE handleB); + //void RemoveOverlap(BP_FP_INT_TYPE handleA, BP_FP_INT_TYPE handleB); + + void sortMinDown(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps); + void sortMinUp(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps); + void sortMaxDown(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps); + void sortMaxUp(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps); + +public: + btAxisSweep3Internal(const btVector3& worldAabbMin, const btVector3& worldAabbMax, BP_FP_INT_TYPE handleMask, BP_FP_INT_TYPE handleSentinel, BP_FP_INT_TYPE maxHandles = 16384, btOverlappingPairCache* pairCache = 0, bool disableRaycastAccelerator = false); + + virtual ~btAxisSweep3Internal(); + + BP_FP_INT_TYPE getNumHandles() const + { + return m_numHandles; + } + + virtual void calculateOverlappingPairs(btDispatcher* dispatcher); + + BP_FP_INT_TYPE addHandle(const btVector3& aabbMin, const btVector3& aabbMax, void* pOwner, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher); + void removeHandle(BP_FP_INT_TYPE handle, btDispatcher* dispatcher); + void updateHandle(BP_FP_INT_TYPE handle, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher); + SIMD_FORCE_INLINE Handle* getHandle(BP_FP_INT_TYPE index) const { return m_pHandles + index; } + + virtual void resetPool(btDispatcher* dispatcher); + + void processAllOverlappingPairs(btOverlapCallback* callback); + + //Broadphase Interface + virtual btBroadphaseProxy* createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher); + virtual void destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher); + virtual void setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher); + virtual void getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin = btVector3(0, 0, 0), const btVector3& aabbMax = btVector3(0, 0, 0)); + virtual void aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback); + + void quantize(BP_FP_INT_TYPE* out, const btVector3& point, int isMax) const; + ///unQuantize should be conservative: aabbMin/aabbMax should be larger then 'getAabb' result + void unQuantize(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const; + + bool testAabbOverlap(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1); + + btOverlappingPairCache* getOverlappingPairCache() + { + return m_pairCache; + } + const btOverlappingPairCache* getOverlappingPairCache() const + { + return m_pairCache; + } + + void setOverlappingPairUserCallback(btOverlappingPairCallback* pairCallback) + { + m_userPairCallback = pairCallback; + } + const btOverlappingPairCallback* getOverlappingPairUserCallback() const + { + return m_userPairCallback; + } + + ///getAabb returns the axis aligned bounding box in the 'global' coordinate frame + ///will add some transform later + virtual void getBroadphaseAabb(btVector3& aabbMin, btVector3& aabbMax) const + { + aabbMin = m_worldAabbMin; + aabbMax = m_worldAabbMax; + } + + virtual void printStats() + { + /* printf("btAxisSweep3.h\n"); + printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_maxHandles); + printf("aabbMin=%f,%f,%f,aabbMax=%f,%f,%f\n",m_worldAabbMin.getX(),m_worldAabbMin.getY(),m_worldAabbMin.getZ(), + m_worldAabbMax.getX(),m_worldAabbMax.getY(),m_worldAabbMax.getZ()); + */ + } +}; + +//////////////////////////////////////////////////////////////////// + +#ifdef DEBUG_BROADPHASE +#include + +template +void btAxisSweep3::debugPrintAxis(int axis, bool checkCardinality) +{ + int numEdges = m_pHandles[0].m_maxEdges[axis]; + printf("SAP Axis %d, numEdges=%d\n", axis, numEdges); + + int i; + for (i = 0; i < numEdges + 1; i++) + { + Edge* pEdge = m_pEdges[axis] + i; + Handle* pHandlePrev = getHandle(pEdge->m_handle); + int handleIndex = pEdge->IsMax() ? pHandlePrev->m_maxEdges[axis] : pHandlePrev->m_minEdges[axis]; + char beginOrEnd; + beginOrEnd = pEdge->IsMax() ? 'E' : 'B'; + printf(" [%c,h=%d,p=%x,i=%d]\n", beginOrEnd, pEdge->m_handle, pEdge->m_pos, handleIndex); + } + + if (checkCardinality) + btAssert(numEdges == m_numHandles * 2 + 1); +} +#endif //DEBUG_BROADPHASE + +template +btBroadphaseProxy* btAxisSweep3Internal::createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher) +{ + (void)shapeType; + BP_FP_INT_TYPE handleId = addHandle(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask, dispatcher); + + Handle* handle = getHandle(handleId); + + if (m_raycastAccelerator) + { + btBroadphaseProxy* rayProxy = m_raycastAccelerator->createProxy(aabbMin, aabbMax, shapeType, userPtr, collisionFilterGroup, collisionFilterMask, dispatcher); + handle->m_dbvtProxy = rayProxy; + } + return handle; +} + +template +void btAxisSweep3Internal::destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher) +{ + Handle* handle = static_cast(proxy); + if (m_raycastAccelerator) + m_raycastAccelerator->destroyProxy(handle->m_dbvtProxy, dispatcher); + removeHandle(static_cast(handle->m_uniqueId), dispatcher); +} + +template +void btAxisSweep3Internal::setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher) +{ + Handle* handle = static_cast(proxy); + handle->m_aabbMin = aabbMin; + handle->m_aabbMax = aabbMax; + updateHandle(static_cast(handle->m_uniqueId), aabbMin, aabbMax, dispatcher); + if (m_raycastAccelerator) + m_raycastAccelerator->setAabb(handle->m_dbvtProxy, aabbMin, aabbMax, dispatcher); +} + +template +void btAxisSweep3Internal::rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin, const btVector3& aabbMax) +{ + if (m_raycastAccelerator) + { + m_raycastAccelerator->rayTest(rayFrom, rayTo, rayCallback, aabbMin, aabbMax); + } + else + { + //choose axis? + BP_FP_INT_TYPE axis = 0; + //for each proxy + for (BP_FP_INT_TYPE i = 1; i < m_numHandles * 2 + 1; i++) + { + if (m_pEdges[axis][i].IsMax()) + { + rayCallback.process(getHandle(m_pEdges[axis][i].m_handle)); + } + } + } +} + +template +void btAxisSweep3Internal::aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback) +{ + if (m_raycastAccelerator) + { + m_raycastAccelerator->aabbTest(aabbMin, aabbMax, callback); + } + else + { + //choose axis? + BP_FP_INT_TYPE axis = 0; + //for each proxy + for (BP_FP_INT_TYPE i = 1; i < m_numHandles * 2 + 1; i++) + { + if (m_pEdges[axis][i].IsMax()) + { + Handle* handle = getHandle(m_pEdges[axis][i].m_handle); + if (TestAabbAgainstAabb2(aabbMin, aabbMax, handle->m_aabbMin, handle->m_aabbMax)) + { + callback.process(handle); + } + } + } + } +} + +template +void btAxisSweep3Internal::getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const +{ + Handle* pHandle = static_cast(proxy); + aabbMin = pHandle->m_aabbMin; + aabbMax = pHandle->m_aabbMax; +} + +template +void btAxisSweep3Internal::unQuantize(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const +{ + Handle* pHandle = static_cast(proxy); + + unsigned short vecInMin[3]; + unsigned short vecInMax[3]; + + vecInMin[0] = m_pEdges[0][pHandle->m_minEdges[0]].m_pos; + vecInMax[0] = m_pEdges[0][pHandle->m_maxEdges[0]].m_pos + 1; + vecInMin[1] = m_pEdges[1][pHandle->m_minEdges[1]].m_pos; + vecInMax[1] = m_pEdges[1][pHandle->m_maxEdges[1]].m_pos + 1; + vecInMin[2] = m_pEdges[2][pHandle->m_minEdges[2]].m_pos; + vecInMax[2] = m_pEdges[2][pHandle->m_maxEdges[2]].m_pos + 1; + + aabbMin.setValue((btScalar)(vecInMin[0]) / (m_quantize.getX()), (btScalar)(vecInMin[1]) / (m_quantize.getY()), (btScalar)(vecInMin[2]) / (m_quantize.getZ())); + aabbMin += m_worldAabbMin; + + aabbMax.setValue((btScalar)(vecInMax[0]) / (m_quantize.getX()), (btScalar)(vecInMax[1]) / (m_quantize.getY()), (btScalar)(vecInMax[2]) / (m_quantize.getZ())); + aabbMax += m_worldAabbMin; +} + +template +btAxisSweep3Internal::btAxisSweep3Internal(const btVector3& worldAabbMin, const btVector3& worldAabbMax, BP_FP_INT_TYPE handleMask, BP_FP_INT_TYPE handleSentinel, BP_FP_INT_TYPE userMaxHandles, btOverlappingPairCache* pairCache, bool disableRaycastAccelerator) + : m_bpHandleMask(handleMask), + m_handleSentinel(handleSentinel), + m_pairCache(pairCache), + m_userPairCallback(0), + m_ownsPairCache(false), + m_invalidPair(0), + m_raycastAccelerator(0) +{ + BP_FP_INT_TYPE maxHandles = static_cast(userMaxHandles + 1); //need to add one sentinel handle + + if (!m_pairCache) + { + void* ptr = btAlignedAlloc(sizeof(btHashedOverlappingPairCache), 16); + m_pairCache = new (ptr) btHashedOverlappingPairCache(); + m_ownsPairCache = true; + } + + if (!disableRaycastAccelerator) + { + m_nullPairCache = new (btAlignedAlloc(sizeof(btNullPairCache), 16)) btNullPairCache(); + m_raycastAccelerator = new (btAlignedAlloc(sizeof(btDbvtBroadphase), 16)) btDbvtBroadphase(m_nullPairCache); //m_pairCache); + m_raycastAccelerator->m_deferedcollide = true; //don't add/remove pairs + } + + //btAssert(bounds.HasVolume()); + + // init bounds + m_worldAabbMin = worldAabbMin; + m_worldAabbMax = worldAabbMax; + + btVector3 aabbSize = m_worldAabbMax - m_worldAabbMin; + + BP_FP_INT_TYPE maxInt = m_handleSentinel; + + m_quantize = btVector3(btScalar(maxInt), btScalar(maxInt), btScalar(maxInt)) / aabbSize; + + // allocate handles buffer, using btAlignedAlloc, and put all handles on free list + m_pHandles = new Handle[maxHandles]; + + m_maxHandles = maxHandles; + m_numHandles = 0; + + // handle 0 is reserved as the null index, and is also used as the sentinel + m_firstFreeHandle = 1; + { + for (BP_FP_INT_TYPE i = m_firstFreeHandle; i < maxHandles; i++) + m_pHandles[i].SetNextFree(static_cast(i + 1)); + m_pHandles[maxHandles - 1].SetNextFree(0); + } + + { + // allocate edge buffers + for (int i = 0; i < 3; i++) + { + m_pEdgesRawPtr[i] = btAlignedAlloc(sizeof(Edge) * maxHandles * 2, 16); + m_pEdges[i] = new (m_pEdgesRawPtr[i]) Edge[maxHandles * 2]; + } + } + //removed overlap management + + // make boundary sentinels + + m_pHandles[0].m_clientObject = 0; + + for (int axis = 0; axis < 3; axis++) + { + m_pHandles[0].m_minEdges[axis] = 0; + m_pHandles[0].m_maxEdges[axis] = 1; + + m_pEdges[axis][0].m_pos = 0; + m_pEdges[axis][0].m_handle = 0; + m_pEdges[axis][1].m_pos = m_handleSentinel; + m_pEdges[axis][1].m_handle = 0; +#ifdef DEBUG_BROADPHASE + debugPrintAxis(axis); +#endif //DEBUG_BROADPHASE + } +} + +template +btAxisSweep3Internal::~btAxisSweep3Internal() +{ + if (m_raycastAccelerator) + { + m_nullPairCache->~btOverlappingPairCache(); + btAlignedFree(m_nullPairCache); + m_raycastAccelerator->~btDbvtBroadphase(); + btAlignedFree(m_raycastAccelerator); + } + + for (int i = 2; i >= 0; i--) + { + btAlignedFree(m_pEdgesRawPtr[i]); + } + delete[] m_pHandles; + + if (m_ownsPairCache) + { + m_pairCache->~btOverlappingPairCache(); + btAlignedFree(m_pairCache); + } +} + +template +void btAxisSweep3Internal::quantize(BP_FP_INT_TYPE* out, const btVector3& point, int isMax) const +{ +#ifdef OLD_CLAMPING_METHOD + ///problem with this clamping method is that the floating point during quantization might still go outside the range [(0|isMax) .. (m_handleSentinel&m_bpHandleMask]|isMax] + ///see http://code.google.com/p/bullet/issues/detail?id=87 + btVector3 clampedPoint(point); + clampedPoint.setMax(m_worldAabbMin); + clampedPoint.setMin(m_worldAabbMax); + btVector3 v = (clampedPoint - m_worldAabbMin) * m_quantize; + out[0] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getX() & m_bpHandleMask) | isMax); + out[1] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getY() & m_bpHandleMask) | isMax); + out[2] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getZ() & m_bpHandleMask) | isMax); +#else + btVector3 v = (point - m_worldAabbMin) * m_quantize; + out[0] = (v[0] <= 0) ? (BP_FP_INT_TYPE)isMax : (v[0] >= m_handleSentinel) ? (BP_FP_INT_TYPE)((m_handleSentinel & m_bpHandleMask) | isMax) : (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v[0] & m_bpHandleMask) | isMax); + out[1] = (v[1] <= 0) ? (BP_FP_INT_TYPE)isMax : (v[1] >= m_handleSentinel) ? (BP_FP_INT_TYPE)((m_handleSentinel & m_bpHandleMask) | isMax) : (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v[1] & m_bpHandleMask) | isMax); + out[2] = (v[2] <= 0) ? (BP_FP_INT_TYPE)isMax : (v[2] >= m_handleSentinel) ? (BP_FP_INT_TYPE)((m_handleSentinel & m_bpHandleMask) | isMax) : (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v[2] & m_bpHandleMask) | isMax); +#endif //OLD_CLAMPING_METHOD +} + +template +BP_FP_INT_TYPE btAxisSweep3Internal::allocHandle() +{ + btAssert(m_firstFreeHandle); + + BP_FP_INT_TYPE handle = m_firstFreeHandle; + m_firstFreeHandle = getHandle(handle)->GetNextFree(); + m_numHandles++; + + return handle; +} + +template +void btAxisSweep3Internal::freeHandle(BP_FP_INT_TYPE handle) +{ + btAssert(handle > 0 && handle < m_maxHandles); + + getHandle(handle)->SetNextFree(m_firstFreeHandle); + m_firstFreeHandle = handle; + + m_numHandles--; +} + +template +BP_FP_INT_TYPE btAxisSweep3Internal::addHandle(const btVector3& aabbMin, const btVector3& aabbMax, void* pOwner, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher) +{ + // quantize the bounds + BP_FP_INT_TYPE min[3], max[3]; + quantize(min, aabbMin, 0); + quantize(max, aabbMax, 1); + + // allocate a handle + BP_FP_INT_TYPE handle = allocHandle(); + + Handle* pHandle = getHandle(handle); + + pHandle->m_uniqueId = static_cast(handle); + //pHandle->m_pOverlaps = 0; + pHandle->m_clientObject = pOwner; + pHandle->m_collisionFilterGroup = collisionFilterGroup; + pHandle->m_collisionFilterMask = collisionFilterMask; + + // compute current limit of edge arrays + BP_FP_INT_TYPE limit = static_cast(m_numHandles * 2); + + // insert new edges just inside the max boundary edge + for (BP_FP_INT_TYPE axis = 0; axis < 3; axis++) + { + m_pHandles[0].m_maxEdges[axis] += 2; + + m_pEdges[axis][limit + 1] = m_pEdges[axis][limit - 1]; + + m_pEdges[axis][limit - 1].m_pos = min[axis]; + m_pEdges[axis][limit - 1].m_handle = handle; + + m_pEdges[axis][limit].m_pos = max[axis]; + m_pEdges[axis][limit].m_handle = handle; + + pHandle->m_minEdges[axis] = static_cast(limit - 1); + pHandle->m_maxEdges[axis] = limit; + } + + // now sort the new edges to their correct position + sortMinDown(0, pHandle->m_minEdges[0], dispatcher, false); + sortMaxDown(0, pHandle->m_maxEdges[0], dispatcher, false); + sortMinDown(1, pHandle->m_minEdges[1], dispatcher, false); + sortMaxDown(1, pHandle->m_maxEdges[1], dispatcher, false); + sortMinDown(2, pHandle->m_minEdges[2], dispatcher, true); + sortMaxDown(2, pHandle->m_maxEdges[2], dispatcher, true); + + return handle; +} + +template +void btAxisSweep3Internal::removeHandle(BP_FP_INT_TYPE handle, btDispatcher* dispatcher) +{ + Handle* pHandle = getHandle(handle); + + //explicitly remove the pairs containing the proxy + //we could do it also in the sortMinUp (passing true) + ///@todo: compare performance + if (!m_pairCache->hasDeferredRemoval()) + { + m_pairCache->removeOverlappingPairsContainingProxy(pHandle, dispatcher); + } + + // compute current limit of edge arrays + int limit = static_cast(m_numHandles * 2); + + int axis; + + for (axis = 0; axis < 3; axis++) + { + m_pHandles[0].m_maxEdges[axis] -= 2; + } + + // remove the edges by sorting them up to the end of the list + for (axis = 0; axis < 3; axis++) + { + Edge* pEdges = m_pEdges[axis]; + BP_FP_INT_TYPE max = pHandle->m_maxEdges[axis]; + pEdges[max].m_pos = m_handleSentinel; + + sortMaxUp(axis, max, dispatcher, false); + + BP_FP_INT_TYPE i = pHandle->m_minEdges[axis]; + pEdges[i].m_pos = m_handleSentinel; + + sortMinUp(axis, i, dispatcher, false); + + pEdges[limit - 1].m_handle = 0; + pEdges[limit - 1].m_pos = m_handleSentinel; + +#ifdef DEBUG_BROADPHASE + debugPrintAxis(axis, false); +#endif //DEBUG_BROADPHASE + } + + // free the handle + freeHandle(handle); +} + +template +void btAxisSweep3Internal::resetPool(btDispatcher* /*dispatcher*/) +{ + if (m_numHandles == 0) + { + m_firstFreeHandle = 1; + { + for (BP_FP_INT_TYPE i = m_firstFreeHandle; i < m_maxHandles; i++) + m_pHandles[i].SetNextFree(static_cast(i + 1)); + m_pHandles[m_maxHandles - 1].SetNextFree(0); + } + } +} + +//#include + +template +void btAxisSweep3Internal::calculateOverlappingPairs(btDispatcher* dispatcher) +{ + if (m_pairCache->hasDeferredRemoval()) + { + btBroadphasePairArray& overlappingPairArray = m_pairCache->getOverlappingPairArray(); + + //perform a sort, to find duplicates and to sort 'invalid' pairs to the end + overlappingPairArray.quickSort(btBroadphasePairSortPredicate()); + + overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair); + m_invalidPair = 0; + + int i; + + btBroadphasePair previousPair; + previousPair.m_pProxy0 = 0; + previousPair.m_pProxy1 = 0; + previousPair.m_algorithm = 0; + + for (i = 0; i < overlappingPairArray.size(); i++) + { + btBroadphasePair& pair = overlappingPairArray[i]; + + bool isDuplicate = (pair == previousPair); + + previousPair = pair; + + bool needsRemoval = false; + + if (!isDuplicate) + { + ///important to use an AABB test that is consistent with the broadphase + bool hasOverlap = testAabbOverlap(pair.m_pProxy0, pair.m_pProxy1); + + if (hasOverlap) + { + needsRemoval = false; //callback->processOverlap(pair); + } + else + { + needsRemoval = true; + } + } + else + { + //remove duplicate + needsRemoval = true; + //should have no algorithm + btAssert(!pair.m_algorithm); + } + + if (needsRemoval) + { + m_pairCache->cleanOverlappingPair(pair, dispatcher); + + // m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1); + // m_overlappingPairArray.pop_back(); + pair.m_pProxy0 = 0; + pair.m_pProxy1 = 0; + m_invalidPair++; + } + } + +///if you don't like to skip the invalid pairs in the array, execute following code: +#define CLEAN_INVALID_PAIRS 1 +#ifdef CLEAN_INVALID_PAIRS + + //perform a sort, to sort 'invalid' pairs to the end + overlappingPairArray.quickSort(btBroadphasePairSortPredicate()); + + overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair); + m_invalidPair = 0; +#endif //CLEAN_INVALID_PAIRS + + //printf("overlappingPairArray.size()=%d\n",overlappingPairArray.size()); + } +} + +template +bool btAxisSweep3Internal::testAabbOverlap(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) +{ + const Handle* pHandleA = static_cast(proxy0); + const Handle* pHandleB = static_cast(proxy1); + + //optimization 1: check the array index (memory address), instead of the m_pos + + for (int axis = 0; axis < 3; axis++) + { + if (pHandleA->m_maxEdges[axis] < pHandleB->m_minEdges[axis] || + pHandleB->m_maxEdges[axis] < pHandleA->m_minEdges[axis]) + { + return false; + } + } + return true; +} + +template +bool btAxisSweep3Internal::testOverlap2D(const Handle* pHandleA, const Handle* pHandleB, int axis0, int axis1) +{ + //optimization 1: check the array index (memory address), instead of the m_pos + + if (pHandleA->m_maxEdges[axis0] < pHandleB->m_minEdges[axis0] || + pHandleB->m_maxEdges[axis0] < pHandleA->m_minEdges[axis0] || + pHandleA->m_maxEdges[axis1] < pHandleB->m_minEdges[axis1] || + pHandleB->m_maxEdges[axis1] < pHandleA->m_minEdges[axis1]) + { + return false; + } + return true; +} + +template +void btAxisSweep3Internal::updateHandle(BP_FP_INT_TYPE handle, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher) +{ + // btAssert(bounds.IsFinite()); + //btAssert(bounds.HasVolume()); + + Handle* pHandle = getHandle(handle); + + // quantize the new bounds + BP_FP_INT_TYPE min[3], max[3]; + quantize(min, aabbMin, 0); + quantize(max, aabbMax, 1); + + // update changed edges + for (int axis = 0; axis < 3; axis++) + { + BP_FP_INT_TYPE emin = pHandle->m_minEdges[axis]; + BP_FP_INT_TYPE emax = pHandle->m_maxEdges[axis]; + + int dmin = (int)min[axis] - (int)m_pEdges[axis][emin].m_pos; + int dmax = (int)max[axis] - (int)m_pEdges[axis][emax].m_pos; + + m_pEdges[axis][emin].m_pos = min[axis]; + m_pEdges[axis][emax].m_pos = max[axis]; + + // expand (only adds overlaps) + if (dmin < 0) + sortMinDown(axis, emin, dispatcher, true); + + if (dmax > 0) + sortMaxUp(axis, emax, dispatcher, true); + + // shrink (only removes overlaps) + if (dmin > 0) + sortMinUp(axis, emin, dispatcher, true); + + if (dmax < 0) + sortMaxDown(axis, emax, dispatcher, true); + +#ifdef DEBUG_BROADPHASE + debugPrintAxis(axis); +#endif //DEBUG_BROADPHASE + } +} + +// sorting a min edge downwards can only ever *add* overlaps +template +void btAxisSweep3Internal::sortMinDown(int axis, BP_FP_INT_TYPE edge, btDispatcher* /* dispatcher */, bool updateOverlaps) +{ + Edge* pEdge = m_pEdges[axis] + edge; + Edge* pPrev = pEdge - 1; + Handle* pHandleEdge = getHandle(pEdge->m_handle); + + while (pEdge->m_pos < pPrev->m_pos) + { + Handle* pHandlePrev = getHandle(pPrev->m_handle); + + if (pPrev->IsMax()) + { + // if previous edge is a maximum check the bounds and add an overlap if necessary + const int axis1 = (1 << axis) & 3; + const int axis2 = (1 << axis1) & 3; + if (updateOverlaps && testOverlap2D(pHandleEdge, pHandlePrev, axis1, axis2)) + { + m_pairCache->addOverlappingPair(pHandleEdge, pHandlePrev); + if (m_userPairCallback) + m_userPairCallback->addOverlappingPair(pHandleEdge, pHandlePrev); + + //AddOverlap(pEdge->m_handle, pPrev->m_handle); + } + + // update edge reference in other handle + pHandlePrev->m_maxEdges[axis]++; + } + else + pHandlePrev->m_minEdges[axis]++; + + pHandleEdge->m_minEdges[axis]--; + + // swap the edges + Edge swap = *pEdge; + *pEdge = *pPrev; + *pPrev = swap; + + // decrement + pEdge--; + pPrev--; + } + +#ifdef DEBUG_BROADPHASE + debugPrintAxis(axis); +#endif //DEBUG_BROADPHASE +} + +// sorting a min edge upwards can only ever *remove* overlaps +template +void btAxisSweep3Internal::sortMinUp(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps) +{ + Edge* pEdge = m_pEdges[axis] + edge; + Edge* pNext = pEdge + 1; + Handle* pHandleEdge = getHandle(pEdge->m_handle); + + while (pNext->m_handle && (pEdge->m_pos >= pNext->m_pos)) + { + Handle* pHandleNext = getHandle(pNext->m_handle); + + if (pNext->IsMax()) + { + Handle* handle0 = getHandle(pEdge->m_handle); + Handle* handle1 = getHandle(pNext->m_handle); + const int axis1 = (1 << axis) & 3; + const int axis2 = (1 << axis1) & 3; + + // if next edge is maximum remove any overlap between the two handles + if (updateOverlaps +#ifdef USE_OVERLAP_TEST_ON_REMOVES + && testOverlap2D(handle0, handle1, axis1, axis2) +#endif //USE_OVERLAP_TEST_ON_REMOVES + ) + { + m_pairCache->removeOverlappingPair(handle0, handle1, dispatcher); + if (m_userPairCallback) + m_userPairCallback->removeOverlappingPair(handle0, handle1, dispatcher); + } + + // update edge reference in other handle + pHandleNext->m_maxEdges[axis]--; + } + else + pHandleNext->m_minEdges[axis]--; + + pHandleEdge->m_minEdges[axis]++; + + // swap the edges + Edge swap = *pEdge; + *pEdge = *pNext; + *pNext = swap; + + // increment + pEdge++; + pNext++; + } +} + +// sorting a max edge downwards can only ever *remove* overlaps +template +void btAxisSweep3Internal::sortMaxDown(int axis, BP_FP_INT_TYPE edge, btDispatcher* dispatcher, bool updateOverlaps) +{ + Edge* pEdge = m_pEdges[axis] + edge; + Edge* pPrev = pEdge - 1; + Handle* pHandleEdge = getHandle(pEdge->m_handle); + + while (pEdge->m_pos < pPrev->m_pos) + { + Handle* pHandlePrev = getHandle(pPrev->m_handle); + + if (!pPrev->IsMax()) + { + // if previous edge was a minimum remove any overlap between the two handles + Handle* handle0 = getHandle(pEdge->m_handle); + Handle* handle1 = getHandle(pPrev->m_handle); + const int axis1 = (1 << axis) & 3; + const int axis2 = (1 << axis1) & 3; + + if (updateOverlaps +#ifdef USE_OVERLAP_TEST_ON_REMOVES + && testOverlap2D(handle0, handle1, axis1, axis2) +#endif //USE_OVERLAP_TEST_ON_REMOVES + ) + { + //this is done during the overlappingpairarray iteration/narrowphase collision + + m_pairCache->removeOverlappingPair(handle0, handle1, dispatcher); + if (m_userPairCallback) + m_userPairCallback->removeOverlappingPair(handle0, handle1, dispatcher); + } + + // update edge reference in other handle + pHandlePrev->m_minEdges[axis]++; + ; + } + else + pHandlePrev->m_maxEdges[axis]++; + + pHandleEdge->m_maxEdges[axis]--; + + // swap the edges + Edge swap = *pEdge; + *pEdge = *pPrev; + *pPrev = swap; + + // decrement + pEdge--; + pPrev--; + } + +#ifdef DEBUG_BROADPHASE + debugPrintAxis(axis); +#endif //DEBUG_BROADPHASE +} + +// sorting a max edge upwards can only ever *add* overlaps +template +void btAxisSweep3Internal::sortMaxUp(int axis, BP_FP_INT_TYPE edge, btDispatcher* /* dispatcher */, bool updateOverlaps) +{ + Edge* pEdge = m_pEdges[axis] + edge; + Edge* pNext = pEdge + 1; + Handle* pHandleEdge = getHandle(pEdge->m_handle); + + while (pNext->m_handle && (pEdge->m_pos >= pNext->m_pos)) + { + Handle* pHandleNext = getHandle(pNext->m_handle); + + const int axis1 = (1 << axis) & 3; + const int axis2 = (1 << axis1) & 3; + + if (!pNext->IsMax()) + { + // if next edge is a minimum check the bounds and add an overlap if necessary + if (updateOverlaps && testOverlap2D(pHandleEdge, pHandleNext, axis1, axis2)) + { + Handle* handle0 = getHandle(pEdge->m_handle); + Handle* handle1 = getHandle(pNext->m_handle); + m_pairCache->addOverlappingPair(handle0, handle1); + if (m_userPairCallback) + m_userPairCallback->addOverlappingPair(handle0, handle1); + } + + // update edge reference in other handle + pHandleNext->m_minEdges[axis]--; + } + else + pHandleNext->m_maxEdges[axis]--; + + pHandleEdge->m_maxEdges[axis]++; + + // swap the edges + Edge swap = *pEdge; + *pEdge = *pNext; + *pNext = swap; + + // increment + pEdge++; + pNext++; + } +} + +#endif diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h.i new file mode 100644 index 00000000..f9962124 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h new file mode 100644 index 00000000..4176256f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h @@ -0,0 +1,79 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_BROADPHASE_INTERFACE_H +#define BT_BROADPHASE_INTERFACE_H + +struct btDispatcherInfo; +class btDispatcher; +#include "btBroadphaseProxy.h" + +class btOverlappingPairCache; + +struct btBroadphaseAabbCallback +{ + virtual ~btBroadphaseAabbCallback() {} + virtual bool process(const btBroadphaseProxy* proxy) = 0; +}; + +struct btBroadphaseRayCallback : public btBroadphaseAabbCallback +{ + ///added some cached data to accelerate ray-AABB tests + btVector3 m_rayDirectionInverse; + unsigned int m_signs[3]; + btScalar m_lambda_max; + + virtual ~btBroadphaseRayCallback() {} + +protected: + btBroadphaseRayCallback() {} +}; + +#include "LinearMath/btVector3.h" + +///The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs. +///Some implementations for this broadphase interface include btAxisSweep3, bt32BitAxisSweep3 and btDbvtBroadphase. +///The actual overlapping pair management, storage, adding and removing of pairs is dealt by the btOverlappingPairCache class. +class btBroadphaseInterface +{ +public: + virtual ~btBroadphaseInterface() {} + + virtual btBroadphaseProxy* createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher) = 0; + virtual void destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher) = 0; + virtual void setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher) = 0; + virtual void getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const = 0; + + virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin = btVector3(0, 0, 0), const btVector3& aabbMax = btVector3(0, 0, 0)) = 0; + + virtual void aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback) = 0; + + ///calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb + virtual void calculateOverlappingPairs(btDispatcher* dispatcher) = 0; + + virtual btOverlappingPairCache* getOverlappingPairCache() = 0; + virtual const btOverlappingPairCache* getOverlappingPairCache() const = 0; + + ///getAabb returns the axis aligned bounding box in the 'global' coordinate frame + ///will add some transform later + virtual void getBroadphaseAabb(btVector3& aabbMin, btVector3& aabbMax) const = 0; + + ///reset broadphase internal structures, to ensure determinism/reproducability + virtual void resetPool(btDispatcher* dispatcher) { (void)dispatcher; }; + + virtual void printStats() = 0; +}; + +#endif //BT_BROADPHASE_INTERFACE_H diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h.i new file mode 100644 index 00000000..44796c4d --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btBroadphaseInterface.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp new file mode 100644 index 00000000..317c3f62 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp @@ -0,0 +1,18 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btBroadphaseProxy.h" + +BT_NOT_EMPTY_FILE // fix warning LNK4221: This object file does not define any previously undefined public symbols, so it will not be used by any link operation that consumes this library diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp.i new file mode 100644 index 00000000..54d49518 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp ---------------- + +// %include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp" + +%{ +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h new file mode 100644 index 00000000..fb23281a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h @@ -0,0 +1,248 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_BROADPHASE_PROXY_H +#define BT_BROADPHASE_PROXY_H + +#include "LinearMath/btScalar.h" //for SIMD_FORCE_INLINE +#include "LinearMath/btVector3.h" +#include "LinearMath/btAlignedAllocator.h" + +/// btDispatcher uses these types +/// IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave +/// to facilitate type checking +/// CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code +enum BroadphaseNativeTypes +{ + // polyhedral convex shapes + BOX_SHAPE_PROXYTYPE, + TRIANGLE_SHAPE_PROXYTYPE, + TETRAHEDRAL_SHAPE_PROXYTYPE, + CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE, + CONVEX_HULL_SHAPE_PROXYTYPE, + CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE, + CUSTOM_POLYHEDRAL_SHAPE_TYPE, + //implicit convex shapes + IMPLICIT_CONVEX_SHAPES_START_HERE, + SPHERE_SHAPE_PROXYTYPE, + MULTI_SPHERE_SHAPE_PROXYTYPE, + CAPSULE_SHAPE_PROXYTYPE, + CONE_SHAPE_PROXYTYPE, + CONVEX_SHAPE_PROXYTYPE, + CYLINDER_SHAPE_PROXYTYPE, + UNIFORM_SCALING_SHAPE_PROXYTYPE, + MINKOWSKI_SUM_SHAPE_PROXYTYPE, + MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE, + BOX_2D_SHAPE_PROXYTYPE, + CONVEX_2D_SHAPE_PROXYTYPE, + CUSTOM_CONVEX_SHAPE_TYPE, + //concave shapes + CONCAVE_SHAPES_START_HERE, + //keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy! + TRIANGLE_MESH_SHAPE_PROXYTYPE, + SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE, + ///used for demo integration FAST/Swift collision library and Bullet + FAST_CONCAVE_MESH_PROXYTYPE, + //terrain + TERRAIN_SHAPE_PROXYTYPE, + ///Used for GIMPACT Trimesh integration + GIMPACT_SHAPE_PROXYTYPE, + ///Multimaterial mesh + MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE, + + EMPTY_SHAPE_PROXYTYPE, + STATIC_PLANE_PROXYTYPE, + CUSTOM_CONCAVE_SHAPE_TYPE, + SDF_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE, + CONCAVE_SHAPES_END_HERE, + + COMPOUND_SHAPE_PROXYTYPE, + + SOFTBODY_SHAPE_PROXYTYPE, + HFFLUID_SHAPE_PROXYTYPE, + HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE, + INVALID_SHAPE_PROXYTYPE, + + MAX_BROADPHASE_COLLISION_TYPES + +}; + +///The btBroadphaseProxy is the main class that can be used with the Bullet broadphases. +///It stores collision shape type information, collision filter information and a client object, typically a btCollisionObject or btRigidBody. +ATTRIBUTE_ALIGNED16(struct) +btBroadphaseProxy +{ + BT_DECLARE_ALIGNED_ALLOCATOR(); + + ///optional filtering to cull potential collisions + enum CollisionFilterGroups + { + DefaultFilter = 1, + StaticFilter = 2, + KinematicFilter = 4, + DebrisFilter = 8, + SensorTrigger = 16, + CharacterFilter = 32, + AllFilter = -1 //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger + }; + + //Usually the client btCollisionObject or Rigidbody class + void* m_clientObject; + int m_collisionFilterGroup; + int m_collisionFilterMask; + + int m_uniqueId; //m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. + + btVector3 m_aabbMin; + btVector3 m_aabbMax; + + SIMD_FORCE_INLINE int getUid() const + { + return m_uniqueId; + } + + //used for memory pools + btBroadphaseProxy() : m_clientObject(0) + { + } + + btBroadphaseProxy(const btVector3& aabbMin, const btVector3& aabbMax, void* userPtr, int collisionFilterGroup, int collisionFilterMask) + : m_clientObject(userPtr), + m_collisionFilterGroup(collisionFilterGroup), + m_collisionFilterMask(collisionFilterMask), + m_aabbMin(aabbMin), + m_aabbMax(aabbMax) + { + } + + static SIMD_FORCE_INLINE bool isPolyhedral(int proxyType) + { + return (proxyType < IMPLICIT_CONVEX_SHAPES_START_HERE); + } + + static SIMD_FORCE_INLINE bool isConvex(int proxyType) + { + return (proxyType < CONCAVE_SHAPES_START_HERE); + } + + static SIMD_FORCE_INLINE bool isNonMoving(int proxyType) + { + return (isConcave(proxyType) && !(proxyType == GIMPACT_SHAPE_PROXYTYPE)); + } + + static SIMD_FORCE_INLINE bool isConcave(int proxyType) + { + return ((proxyType > CONCAVE_SHAPES_START_HERE) && + (proxyType < CONCAVE_SHAPES_END_HERE)); + } + static SIMD_FORCE_INLINE bool isCompound(int proxyType) + { + return (proxyType == COMPOUND_SHAPE_PROXYTYPE); + } + + static SIMD_FORCE_INLINE bool isSoftBody(int proxyType) + { + return (proxyType == SOFTBODY_SHAPE_PROXYTYPE); + } + + static SIMD_FORCE_INLINE bool isInfinite(int proxyType) + { + return (proxyType == STATIC_PLANE_PROXYTYPE); + } + + static SIMD_FORCE_INLINE bool isConvex2d(int proxyType) + { + return (proxyType == BOX_2D_SHAPE_PROXYTYPE) || (proxyType == CONVEX_2D_SHAPE_PROXYTYPE); + } +}; + +class btCollisionAlgorithm; + +struct btBroadphaseProxy; + +///The btBroadphasePair class contains a pair of aabb-overlapping objects. +///A btDispatcher can search a btCollisionAlgorithm that performs exact/narrowphase collision detection on the actual collision shapes. +ATTRIBUTE_ALIGNED16(struct) +btBroadphasePair +{ + btBroadphasePair() + : m_pProxy0(0), + m_pProxy1(0), + m_algorithm(0), + m_internalInfo1(0) + { + } + + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btBroadphasePair(btBroadphaseProxy & proxy0, btBroadphaseProxy & proxy1) + { + //keep them sorted, so the std::set operations work + if (proxy0.m_uniqueId < proxy1.m_uniqueId) + { + m_pProxy0 = &proxy0; + m_pProxy1 = &proxy1; + } + else + { + m_pProxy0 = &proxy1; + m_pProxy1 = &proxy0; + } + + m_algorithm = 0; + m_internalInfo1 = 0; + } + + btBroadphaseProxy* m_pProxy0; + btBroadphaseProxy* m_pProxy1; + + mutable btCollisionAlgorithm* m_algorithm; + union { + void* m_internalInfo1; + int m_internalTmpValue; + }; //don't use this data, it will be removed in future version. +}; + +/* +//comparison for set operation, see Solid DT_Encounter +SIMD_FORCE_INLINE bool operator<(const btBroadphasePair& a, const btBroadphasePair& b) +{ + return a.m_pProxy0 < b.m_pProxy0 || + (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1); +} +*/ + +class btBroadphasePairSortPredicate +{ +public: + bool operator()(const btBroadphasePair& a, const btBroadphasePair& b) const + { + const int uidA0 = a.m_pProxy0 ? a.m_pProxy0->m_uniqueId : -1; + const int uidB0 = b.m_pProxy0 ? b.m_pProxy0->m_uniqueId : -1; + const int uidA1 = a.m_pProxy1 ? a.m_pProxy1->m_uniqueId : -1; + const int uidB1 = b.m_pProxy1 ? b.m_pProxy1->m_uniqueId : -1; + + return uidA0 > uidB0 || + (a.m_pProxy0 == b.m_pProxy0 && uidA1 > uidB1) || + (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 == b.m_pProxy1 && a.m_algorithm > b.m_algorithm); + } +}; + +SIMD_FORCE_INLINE bool operator==(const btBroadphasePair& a, const btBroadphasePair& b) +{ + return (a.m_pProxy0 == b.m_pProxy0) && (a.m_pProxy1 == b.m_pProxy1); +} + +#endif //BT_BROADPHASE_PROXY_H diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h.i new file mode 100644 index 00000000..fb9647e5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btBroadphaseProxy.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp new file mode 100644 index 00000000..9cb62250 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp @@ -0,0 +1,22 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btCollisionAlgorithm.h" +#include "btDispatcher.h" + +btCollisionAlgorithm::btCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci) +{ + m_dispatcher = ci.m_dispatcher1; +} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..8fc03b16 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp ---------------- + +%include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h new file mode 100644 index 00000000..25a347e2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h @@ -0,0 +1,75 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COLLISION_ALGORITHM_H +#define BT_COLLISION_ALGORITHM_H + +#include "LinearMath/btScalar.h" +#include "LinearMath/btAlignedObjectArray.h" + +struct btBroadphaseProxy; +class btDispatcher; +class btManifoldResult; +class btCollisionObject; +struct btCollisionObjectWrapper; +struct btDispatcherInfo; +class btPersistentManifold; + +typedef btAlignedObjectArray btManifoldArray; + +struct btCollisionAlgorithmConstructionInfo +{ + btCollisionAlgorithmConstructionInfo() + : m_dispatcher1(0), + m_manifold(0) + { + } + btCollisionAlgorithmConstructionInfo(btDispatcher* dispatcher, int temp) + : m_dispatcher1(dispatcher) + { + (void)temp; + } + + btDispatcher* m_dispatcher1; + btPersistentManifold* m_manifold; + + // int getDispatcherId(); +}; + +///btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatcher. +///It is persistent over frames +class btCollisionAlgorithm +{ +protected: + btDispatcher* m_dispatcher; + +protected: + // int getDispatcherId(); + +public: + btCollisionAlgorithm(){}; + + btCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci); + + virtual ~btCollisionAlgorithm(){}; + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) = 0; + + virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) = 0; + + virtual void getAllContactManifolds(btManifoldArray& manifoldArray) = 0; +}; + +#endif //BT_COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h.i new file mode 100644 index 00000000..cb5cbdf2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.cpp b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.cpp new file mode 100644 index 00000000..ae087c8b --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.cpp @@ -0,0 +1,1357 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +///btDbvt implementation by Nathanael Presson + +#include "btDbvt.h" + +// +typedef btAlignedObjectArray tNodeArray; +typedef btAlignedObjectArray tConstNodeArray; + +// +struct btDbvtNodeEnumerator : btDbvt::ICollide +{ + tConstNodeArray nodes; + void Process(const btDbvtNode* n) { nodes.push_back(n); } +}; + +// +static DBVT_INLINE int indexof(const btDbvtNode* node) +{ + return (node->parent->childs[1] == node); +} + +// +static DBVT_INLINE btDbvtVolume merge(const btDbvtVolume& a, + const btDbvtVolume& b) +{ +#ifdef BT_USE_SSE + ATTRIBUTE_ALIGNED16(char locals[sizeof(btDbvtAabbMm)]); + btDbvtVolume* ptr = (btDbvtVolume*)locals; + btDbvtVolume& res = *ptr; +#else + btDbvtVolume res; +#endif + Merge(a, b, res); + return (res); +} + +// volume+edge lengths +static DBVT_INLINE btScalar size(const btDbvtVolume& a) +{ + const btVector3 edges = a.Lengths(); + return (edges.x() * edges.y() * edges.z() + + edges.x() + edges.y() + edges.z()); +} + +// +static void getmaxdepth(const btDbvtNode* node, int depth, int& maxdepth) +{ + if (node->isinternal()) + { + getmaxdepth(node->childs[0], depth + 1, maxdepth); + getmaxdepth(node->childs[1], depth + 1, maxdepth); + } + else + maxdepth = btMax(maxdepth, depth); +} + +// +static DBVT_INLINE void deletenode(btDbvt* pdbvt, + btDbvtNode* node) +{ + btAlignedFree(pdbvt->m_free); + pdbvt->m_free = node; +} + +// +static void recursedeletenode(btDbvt* pdbvt, + btDbvtNode* node) +{ + if (node == 0) return; + if (!node->isleaf()) + { + recursedeletenode(pdbvt, node->childs[0]); + recursedeletenode(pdbvt, node->childs[1]); + } + if (node == pdbvt->m_root) pdbvt->m_root = 0; + deletenode(pdbvt, node); +} + +// +static DBVT_INLINE btDbvtNode* createnode(btDbvt* pdbvt, + btDbvtNode* parent, + void* data) +{ + btDbvtNode* node; + if (pdbvt->m_free) + { + node = pdbvt->m_free; + pdbvt->m_free = 0; + } + else + { + node = new (btAlignedAlloc(sizeof(btDbvtNode), 16)) btDbvtNode(); + } + node->parent = parent; + node->data = data; + node->childs[1] = 0; + return (node); +} + +// +static DBVT_INLINE btDbvtNode* createnode(btDbvt* pdbvt, + btDbvtNode* parent, + const btDbvtVolume& volume, + void* data) +{ + btDbvtNode* node = createnode(pdbvt, parent, data); + node->volume = volume; + return (node); +} + +// +static DBVT_INLINE btDbvtNode* createnode(btDbvt* pdbvt, + btDbvtNode* parent, + const btDbvtVolume& volume0, + const btDbvtVolume& volume1, + void* data) +{ + btDbvtNode* node = createnode(pdbvt, parent, data); + Merge(volume0, volume1, node->volume); + return (node); +} + +// +static void insertleaf(btDbvt* pdbvt, + btDbvtNode* root, + btDbvtNode* leaf) +{ + if (!pdbvt->m_root) + { + pdbvt->m_root = leaf; + leaf->parent = 0; + } + else + { + if (!root->isleaf()) + { + do + { + root = root->childs[Select(leaf->volume, + root->childs[0]->volume, + root->childs[1]->volume)]; + } while (!root->isleaf()); + } + btDbvtNode* prev = root->parent; + btDbvtNode* node = createnode(pdbvt, prev, leaf->volume, root->volume, 0); + if (prev) + { + prev->childs[indexof(root)] = node; + node->childs[0] = root; + root->parent = node; + node->childs[1] = leaf; + leaf->parent = node; + do + { + if (!prev->volume.Contain(node->volume)) + Merge(prev->childs[0]->volume, prev->childs[1]->volume, prev->volume); + else + break; + node = prev; + } while (0 != (prev = node->parent)); + } + else + { + node->childs[0] = root; + root->parent = node; + node->childs[1] = leaf; + leaf->parent = node; + pdbvt->m_root = node; + } + } +} + +// +static btDbvtNode* removeleaf(btDbvt* pdbvt, + btDbvtNode* leaf) +{ + if (leaf == pdbvt->m_root) + { + pdbvt->m_root = 0; + return (0); + } + else + { + btDbvtNode* parent = leaf->parent; + btDbvtNode* prev = parent->parent; + btDbvtNode* sibling = parent->childs[1 - indexof(leaf)]; + if (prev) + { + prev->childs[indexof(parent)] = sibling; + sibling->parent = prev; + deletenode(pdbvt, parent); + while (prev) + { + const btDbvtVolume pb = prev->volume; + Merge(prev->childs[0]->volume, prev->childs[1]->volume, prev->volume); + if (NotEqual(pb, prev->volume)) + { + prev = prev->parent; + } + else + break; + } + return (prev ? prev : pdbvt->m_root); + } + else + { + pdbvt->m_root = sibling; + sibling->parent = 0; + deletenode(pdbvt, parent); + return (pdbvt->m_root); + } + } +} + +// +static void fetchleaves(btDbvt* pdbvt, + btDbvtNode* root, + tNodeArray& leaves, + int depth = -1) +{ + if (root->isinternal() && depth) + { + fetchleaves(pdbvt, root->childs[0], leaves, depth - 1); + fetchleaves(pdbvt, root->childs[1], leaves, depth - 1); + deletenode(pdbvt, root); + } + else + { + leaves.push_back(root); + } +} + +// +static bool leftOfAxis(const btDbvtNode* node, + const btVector3& org, + const btVector3& axis) +{ + return btDot(axis, node->volume.Center() - org) <= 0; +} + +// Partitions leaves such that leaves[0, n) are on the +// left of axis, and leaves[n, count) are on the right +// of axis. returns N. +static int split(btDbvtNode** leaves, + int count, + const btVector3& org, + const btVector3& axis) +{ + int begin = 0; + int end = count; + for (;;) + { + while (begin != end && leftOfAxis(leaves[begin], org, axis)) + { + ++begin; + } + + if (begin == end) + { + break; + } + + while (begin != end && !leftOfAxis(leaves[end - 1], org, axis)) + { + --end; + } + + if (begin == end) + { + break; + } + + // swap out of place nodes + --end; + btDbvtNode* temp = leaves[begin]; + leaves[begin] = leaves[end]; + leaves[end] = temp; + ++begin; + } + + return begin; +} + +// +static btDbvtVolume bounds(btDbvtNode** leaves, + int count) +{ +#ifdef BT_USE_SSE + ATTRIBUTE_ALIGNED16(char locals[sizeof(btDbvtVolume)]); + btDbvtVolume* ptr = (btDbvtVolume*)locals; + btDbvtVolume& volume = *ptr; + volume = leaves[0]->volume; +#else + btDbvtVolume volume = leaves[0]->volume; +#endif + for (int i = 1, ni = count; i < ni; ++i) + { + Merge(volume, leaves[i]->volume, volume); + } + return (volume); +} + +// +static void bottomup(btDbvt* pdbvt, + btDbvtNode** leaves, + int count) +{ + while (count > 1) + { + btScalar minsize = SIMD_INFINITY; + int minidx[2] = {-1, -1}; + for (int i = 0; i < count; ++i) + { + for (int j = i + 1; j < count; ++j) + { + const btScalar sz = size(merge(leaves[i]->volume, leaves[j]->volume)); + if (sz < minsize) + { + minsize = sz; + minidx[0] = i; + minidx[1] = j; + } + } + } + btDbvtNode* n[] = {leaves[minidx[0]], leaves[minidx[1]]}; + btDbvtNode* p = createnode(pdbvt, 0, n[0]->volume, n[1]->volume, 0); + p->childs[0] = n[0]; + p->childs[1] = n[1]; + n[0]->parent = p; + n[1]->parent = p; + leaves[minidx[0]] = p; + leaves[minidx[1]] = leaves[count - 1]; + --count; + } +} + +// +static btDbvtNode* topdown(btDbvt* pdbvt, + btDbvtNode** leaves, + int count, + int bu_treshold) +{ + static const btVector3 axis[] = {btVector3(1, 0, 0), + btVector3(0, 1, 0), + btVector3(0, 0, 1)}; + btAssert(bu_treshold > 2); + if (count > 1) + { + if (count > bu_treshold) + { + const btDbvtVolume vol = bounds(leaves, count); + const btVector3 org = vol.Center(); + int partition; + int bestaxis = -1; + int bestmidp = count; + int splitcount[3][2] = {{0, 0}, {0, 0}, {0, 0}}; + int i; + for (i = 0; i < count; ++i) + { + const btVector3 x = leaves[i]->volume.Center() - org; + for (int j = 0; j < 3; ++j) + { + ++splitcount[j][btDot(x, axis[j]) > 0 ? 1 : 0]; + } + } + for (i = 0; i < 3; ++i) + { + if ((splitcount[i][0] > 0) && (splitcount[i][1] > 0)) + { + const int midp = (int)btFabs(btScalar(splitcount[i][0] - splitcount[i][1])); + if (midp < bestmidp) + { + bestaxis = i; + bestmidp = midp; + } + } + } + if (bestaxis >= 0) + { + partition = split(leaves, count, org, axis[bestaxis]); + btAssert(partition != 0 && partition != count); + } + else + { + partition = count / 2 + 1; + } + btDbvtNode* node = createnode(pdbvt, 0, vol, 0); + node->childs[0] = topdown(pdbvt, &leaves[0], partition, bu_treshold); + node->childs[1] = topdown(pdbvt, &leaves[partition], count - partition, bu_treshold); + node->childs[0]->parent = node; + node->childs[1]->parent = node; + return (node); + } + else + { + bottomup(pdbvt, leaves, count); + return (leaves[0]); + } + } + return (leaves[0]); +} + +// +static DBVT_INLINE btDbvtNode* sort(btDbvtNode* n, btDbvtNode*& r) +{ + btDbvtNode* p = n->parent; + btAssert(n->isinternal()); + if (p > n) + { + const int i = indexof(n); + const int j = 1 - i; + btDbvtNode* s = p->childs[j]; + btDbvtNode* q = p->parent; + btAssert(n == p->childs[i]); + if (q) + q->childs[indexof(p)] = n; + else + r = n; + s->parent = n; + p->parent = n; + n->parent = q; + p->childs[0] = n->childs[0]; + p->childs[1] = n->childs[1]; + n->childs[0]->parent = p; + n->childs[1]->parent = p; + n->childs[i] = p; + n->childs[j] = s; + btSwap(p->volume, n->volume); + return (p); + } + return (n); +} + +#if 0 +static DBVT_INLINE btDbvtNode* walkup(btDbvtNode* n,int count) +{ + while(n&&(count--)) n=n->parent; + return(n); +} +#endif + +// +// Api +// + +// +btDbvt::btDbvt() +{ + m_root = 0; + m_free = 0; + m_lkhd = -1; + m_leaves = 0; + m_opath = 0; +} + +// +btDbvt::~btDbvt() +{ + clear(); +} + +// +void btDbvt::clear() +{ + if (m_root) + recursedeletenode(this, m_root); + btAlignedFree(m_free); + m_free = 0; + m_lkhd = -1; + m_stkStack.clear(); + m_opath = 0; +} + +// +void btDbvt::optimizeBottomUp() +{ + if (m_root) + { + tNodeArray leaves; + leaves.reserve(m_leaves); + fetchleaves(this, m_root, leaves); + bottomup(this, &leaves[0], leaves.size()); + m_root = leaves[0]; + } +} + +// +void btDbvt::optimizeTopDown(int bu_treshold) +{ + if (m_root) + { + tNodeArray leaves; + leaves.reserve(m_leaves); + fetchleaves(this, m_root, leaves); + m_root = topdown(this, &leaves[0], leaves.size(), bu_treshold); + } +} + +// +void btDbvt::optimizeIncremental(int passes) +{ + if (passes < 0) passes = m_leaves; + if (m_root && (passes > 0)) + { + do + { + btDbvtNode* node = m_root; + unsigned bit = 0; + while (node->isinternal()) + { + node = sort(node, m_root)->childs[(m_opath >> bit) & 1]; + bit = (bit + 1) & (sizeof(unsigned) * 8 - 1); + } + update(node); + ++m_opath; + } while (--passes); + } +} + +// +btDbvtNode* btDbvt::insert(const btDbvtVolume& volume, void* data) +{ + btDbvtNode* leaf = createnode(this, 0, volume, data); + insertleaf(this, m_root, leaf); + ++m_leaves; + return (leaf); +} + +// +void btDbvt::update(btDbvtNode* leaf, int lookahead) +{ + btDbvtNode* root = removeleaf(this, leaf); + if (root) + { + if (lookahead >= 0) + { + for (int i = 0; (i < lookahead) && root->parent; ++i) + { + root = root->parent; + } + } + else + root = m_root; + } + insertleaf(this, root, leaf); +} + +// +void btDbvt::update(btDbvtNode* leaf, btDbvtVolume& volume) +{ + btDbvtNode* root = removeleaf(this, leaf); + if (root) + { + if (m_lkhd >= 0) + { + for (int i = 0; (i < m_lkhd) && root->parent; ++i) + { + root = root->parent; + } + } + else + root = m_root; + } + leaf->volume = volume; + insertleaf(this, root, leaf); +} + +// +bool btDbvt::update(btDbvtNode* leaf, btDbvtVolume& volume, const btVector3& velocity, btScalar margin) +{ + if (leaf->volume.Contain(volume)) return (false); + volume.Expand(btVector3(margin, margin, margin)); + volume.SignedExpand(velocity); + update(leaf, volume); + return (true); +} + +// +bool btDbvt::update(btDbvtNode* leaf, btDbvtVolume& volume, const btVector3& velocity) +{ + if (leaf->volume.Contain(volume)) return (false); + volume.SignedExpand(velocity); + update(leaf, volume); + return (true); +} + +// +bool btDbvt::update(btDbvtNode* leaf, btDbvtVolume& volume, btScalar margin) +{ + if (leaf->volume.Contain(volume)) return (false); + volume.Expand(btVector3(margin, margin, margin)); + update(leaf, volume); + return (true); +} + +// +void btDbvt::remove(btDbvtNode* leaf) +{ + removeleaf(this, leaf); + deletenode(this, leaf); + --m_leaves; +} + +// +void btDbvt::write(IWriter* iwriter) const +{ + btDbvtNodeEnumerator nodes; + nodes.nodes.reserve(m_leaves * 2); + enumNodes(m_root, nodes); + iwriter->Prepare(m_root, nodes.nodes.size()); + for (int i = 0; i < nodes.nodes.size(); ++i) + { + const btDbvtNode* n = nodes.nodes[i]; + int p = -1; + if (n->parent) p = nodes.nodes.findLinearSearch(n->parent); + if (n->isinternal()) + { + const int c0 = nodes.nodes.findLinearSearch(n->childs[0]); + const int c1 = nodes.nodes.findLinearSearch(n->childs[1]); + iwriter->WriteNode(n, i, p, c0, c1); + } + else + { + iwriter->WriteLeaf(n, i, p); + } + } +} + +// +void btDbvt::clone(btDbvt& dest, IClone* iclone) const +{ + dest.clear(); + if (m_root != 0) + { + btAlignedObjectArray stack; + stack.reserve(m_leaves); + stack.push_back(sStkCLN(m_root, 0)); + do + { + const int i = stack.size() - 1; + const sStkCLN e = stack[i]; + btDbvtNode* n = createnode(&dest, e.parent, e.node->volume, e.node->data); + stack.pop_back(); + if (e.parent != 0) + e.parent->childs[i & 1] = n; + else + dest.m_root = n; + if (e.node->isinternal()) + { + stack.push_back(sStkCLN(e.node->childs[0], n)); + stack.push_back(sStkCLN(e.node->childs[1], n)); + } + else + { + iclone->CloneLeaf(n); + } + } while (stack.size() > 0); + } +} + +// +int btDbvt::maxdepth(const btDbvtNode* node) +{ + int depth = 0; + if (node) getmaxdepth(node, 1, depth); + return (depth); +} + +// +int btDbvt::countLeaves(const btDbvtNode* node) +{ + if (node->isinternal()) + return (countLeaves(node->childs[0]) + countLeaves(node->childs[1])); + else + return (1); +} + +// +void btDbvt::extractLeaves(const btDbvtNode* node, btAlignedObjectArray& leaves) +{ + if (node->isinternal()) + { + extractLeaves(node->childs[0], leaves); + extractLeaves(node->childs[1], leaves); + } + else + { + leaves.push_back(node); + } +} + +// +#if DBVT_ENABLE_BENCHMARK + +#include +#include +#include "LinearMath/btQuickProf.h" + +/* +q6600,2.4ghz + +/Ox /Ob2 /Oi /Ot /I "." /I "..\.." /I "..\..\src" /D "NDEBUG" /D "_LIB" /D "_WINDOWS" /D "_CRT_SECURE_NO_DEPRECATE" /D "_CRT_NONSTDC_NO_DEPRECATE" /D "WIN32" +/GF /FD /MT /GS- /Gy /arch:SSE2 /Zc:wchar_t- /Fp"..\..\out\release8\build\libbulletcollision\libbulletcollision.pch" +/Fo"..\..\out\release8\build\libbulletcollision\\" +/Fd"..\..\out\release8\build\libbulletcollision\bulletcollision.pdb" +/W3 /nologo /c /Wp64 /Zi /errorReport:prompt + +Benchmarking dbvt... +World scale: 100.000000 +Extents base: 1.000000 +Extents range: 4.000000 +Leaves: 8192 +sizeof(btDbvtVolume): 32 bytes +sizeof(btDbvtNode): 44 bytes +[1] btDbvtVolume intersections: 3499 ms (-1%) +[2] btDbvtVolume merges: 1934 ms (0%) +[3] btDbvt::collideTT: 5485 ms (-21%) +[4] btDbvt::collideTT self: 2814 ms (-20%) +[5] btDbvt::collideTT xform: 7379 ms (-1%) +[6] btDbvt::collideTT xform,self: 7270 ms (-2%) +[7] btDbvt::rayTest: 6314 ms (0%),(332143 r/s) +[8] insert/remove: 2093 ms (0%),(1001983 ir/s) +[9] updates (teleport): 1879 ms (-3%),(1116100 u/s) +[10] updates (jitter): 1244 ms (-4%),(1685813 u/s) +[11] optimize (incremental): 2514 ms (0%),(1668000 o/s) +[12] btDbvtVolume notequal: 3659 ms (0%) +[13] culling(OCL+fullsort): 2218 ms (0%),(461 t/s) +[14] culling(OCL+qsort): 3688 ms (5%),(2221 t/s) +[15] culling(KDOP+qsort): 1139 ms (-1%),(7192 t/s) +[16] insert/remove batch(256): 5092 ms (0%),(823704 bir/s) +[17] btDbvtVolume select: 3419 ms (0%) +*/ + +struct btDbvtBenchmark +{ + struct NilPolicy : btDbvt::ICollide + { + NilPolicy() : m_pcount(0), m_depth(-SIMD_INFINITY), m_checksort(true) {} + void Process(const btDbvtNode*, const btDbvtNode*) { ++m_pcount; } + void Process(const btDbvtNode*) { ++m_pcount; } + void Process(const btDbvtNode*, btScalar depth) + { + ++m_pcount; + if (m_checksort) + { + if (depth >= m_depth) + m_depth = depth; + else + printf("wrong depth: %f (should be >= %f)\r\n", depth, m_depth); + } + } + int m_pcount; + btScalar m_depth; + bool m_checksort; + }; + struct P14 : btDbvt::ICollide + { + struct Node + { + const btDbvtNode* leaf; + btScalar depth; + }; + void Process(const btDbvtNode* leaf, btScalar depth) + { + Node n; + n.leaf = leaf; + n.depth = depth; + } + static int sortfnc(const Node& a, const Node& b) + { + if (a.depth < b.depth) return (+1); + if (a.depth > b.depth) return (-1); + return (0); + } + btAlignedObjectArray m_nodes; + }; + struct P15 : btDbvt::ICollide + { + struct Node + { + const btDbvtNode* leaf; + btScalar depth; + }; + void Process(const btDbvtNode* leaf) + { + Node n; + n.leaf = leaf; + n.depth = dot(leaf->volume.Center(), m_axis); + } + static int sortfnc(const Node& a, const Node& b) + { + if (a.depth < b.depth) return (+1); + if (a.depth > b.depth) return (-1); + return (0); + } + btAlignedObjectArray m_nodes; + btVector3 m_axis; + }; + static btScalar RandUnit() + { + return (rand() / (btScalar)RAND_MAX); + } + static btVector3 RandVector3() + { + return (btVector3(RandUnit(), RandUnit(), RandUnit())); + } + static btVector3 RandVector3(btScalar cs) + { + return (RandVector3() * cs - btVector3(cs, cs, cs) / 2); + } + static btDbvtVolume RandVolume(btScalar cs, btScalar eb, btScalar es) + { + return (btDbvtVolume::FromCE(RandVector3(cs), btVector3(eb, eb, eb) + RandVector3() * es)); + } + static btTransform RandTransform(btScalar cs) + { + btTransform t; + t.setOrigin(RandVector3(cs)); + t.setRotation(btQuaternion(RandUnit() * SIMD_PI * 2, RandUnit() * SIMD_PI * 2, RandUnit() * SIMD_PI * 2).normalized()); + return (t); + } + static void RandTree(btScalar cs, btScalar eb, btScalar es, int leaves, btDbvt& dbvt) + { + dbvt.clear(); + for (int i = 0; i < leaves; ++i) + { + dbvt.insert(RandVolume(cs, eb, es), 0); + } + } +}; + +void btDbvt::benchmark() +{ + static const btScalar cfgVolumeCenterScale = 100; + static const btScalar cfgVolumeExentsBase = 1; + static const btScalar cfgVolumeExentsScale = 4; + static const int cfgLeaves = 8192; + static const bool cfgEnable = true; + + //[1] btDbvtVolume intersections + bool cfgBenchmark1_Enable = cfgEnable; + static const int cfgBenchmark1_Iterations = 8; + static const int cfgBenchmark1_Reference = 3499; + //[2] btDbvtVolume merges + bool cfgBenchmark2_Enable = cfgEnable; + static const int cfgBenchmark2_Iterations = 4; + static const int cfgBenchmark2_Reference = 1945; + //[3] btDbvt::collideTT + bool cfgBenchmark3_Enable = cfgEnable; + static const int cfgBenchmark3_Iterations = 512; + static const int cfgBenchmark3_Reference = 5485; + //[4] btDbvt::collideTT self + bool cfgBenchmark4_Enable = cfgEnable; + static const int cfgBenchmark4_Iterations = 512; + static const int cfgBenchmark4_Reference = 2814; + //[5] btDbvt::collideTT xform + bool cfgBenchmark5_Enable = cfgEnable; + static const int cfgBenchmark5_Iterations = 512; + static const btScalar cfgBenchmark5_OffsetScale = 2; + static const int cfgBenchmark5_Reference = 7379; + //[6] btDbvt::collideTT xform,self + bool cfgBenchmark6_Enable = cfgEnable; + static const int cfgBenchmark6_Iterations = 512; + static const btScalar cfgBenchmark6_OffsetScale = 2; + static const int cfgBenchmark6_Reference = 7270; + //[7] btDbvt::rayTest + bool cfgBenchmark7_Enable = cfgEnable; + static const int cfgBenchmark7_Passes = 32; + static const int cfgBenchmark7_Iterations = 65536; + static const int cfgBenchmark7_Reference = 6307; + //[8] insert/remove + bool cfgBenchmark8_Enable = cfgEnable; + static const int cfgBenchmark8_Passes = 32; + static const int cfgBenchmark8_Iterations = 65536; + static const int cfgBenchmark8_Reference = 2105; + //[9] updates (teleport) + bool cfgBenchmark9_Enable = cfgEnable; + static const int cfgBenchmark9_Passes = 32; + static const int cfgBenchmark9_Iterations = 65536; + static const int cfgBenchmark9_Reference = 1879; + //[10] updates (jitter) + bool cfgBenchmark10_Enable = cfgEnable; + static const btScalar cfgBenchmark10_Scale = cfgVolumeCenterScale / 10000; + static const int cfgBenchmark10_Passes = 32; + static const int cfgBenchmark10_Iterations = 65536; + static const int cfgBenchmark10_Reference = 1244; + //[11] optimize (incremental) + bool cfgBenchmark11_Enable = cfgEnable; + static const int cfgBenchmark11_Passes = 64; + static const int cfgBenchmark11_Iterations = 65536; + static const int cfgBenchmark11_Reference = 2510; + //[12] btDbvtVolume notequal + bool cfgBenchmark12_Enable = cfgEnable; + static const int cfgBenchmark12_Iterations = 32; + static const int cfgBenchmark12_Reference = 3677; + //[13] culling(OCL+fullsort) + bool cfgBenchmark13_Enable = cfgEnable; + static const int cfgBenchmark13_Iterations = 1024; + static const int cfgBenchmark13_Reference = 2231; + //[14] culling(OCL+qsort) + bool cfgBenchmark14_Enable = cfgEnable; + static const int cfgBenchmark14_Iterations = 8192; + static const int cfgBenchmark14_Reference = 3500; + //[15] culling(KDOP+qsort) + bool cfgBenchmark15_Enable = cfgEnable; + static const int cfgBenchmark15_Iterations = 8192; + static const int cfgBenchmark15_Reference = 1151; + //[16] insert/remove batch + bool cfgBenchmark16_Enable = cfgEnable; + static const int cfgBenchmark16_BatchCount = 256; + static const int cfgBenchmark16_Passes = 16384; + static const int cfgBenchmark16_Reference = 5138; + //[17] select + bool cfgBenchmark17_Enable = cfgEnable; + static const int cfgBenchmark17_Iterations = 4; + static const int cfgBenchmark17_Reference = 3390; + + btClock wallclock; + printf("Benchmarking dbvt...\r\n"); + printf("\tWorld scale: %f\r\n", cfgVolumeCenterScale); + printf("\tExtents base: %f\r\n", cfgVolumeExentsBase); + printf("\tExtents range: %f\r\n", cfgVolumeExentsScale); + printf("\tLeaves: %u\r\n", cfgLeaves); + printf("\tsizeof(btDbvtVolume): %u bytes\r\n", sizeof(btDbvtVolume)); + printf("\tsizeof(btDbvtNode): %u bytes\r\n", sizeof(btDbvtNode)); + if (cfgBenchmark1_Enable) + { // Benchmark 1 + srand(380843); + btAlignedObjectArray volumes; + btAlignedObjectArray results; + volumes.resize(cfgLeaves); + results.resize(cfgLeaves); + for (int i = 0; i < cfgLeaves; ++i) + { + volumes[i] = btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale); + } + printf("[1] btDbvtVolume intersections: "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark1_Iterations; ++i) + { + for (int j = 0; j < cfgLeaves; ++j) + { + for (int k = 0; k < cfgLeaves; ++k) + { + results[k] = Intersect(volumes[j], volumes[k]); + } + } + } + const int time = (int)wallclock.getTimeMilliseconds(); + printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark1_Reference) * 100 / time); + } + if (cfgBenchmark2_Enable) + { // Benchmark 2 + srand(380843); + btAlignedObjectArray volumes; + btAlignedObjectArray results; + volumes.resize(cfgLeaves); + results.resize(cfgLeaves); + for (int i = 0; i < cfgLeaves; ++i) + { + volumes[i] = btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale); + } + printf("[2] btDbvtVolume merges: "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark2_Iterations; ++i) + { + for (int j = 0; j < cfgLeaves; ++j) + { + for (int k = 0; k < cfgLeaves; ++k) + { + Merge(volumes[j], volumes[k], results[k]); + } + } + } + const int time = (int)wallclock.getTimeMilliseconds(); + printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark2_Reference) * 100 / time); + } + if (cfgBenchmark3_Enable) + { // Benchmark 3 + srand(380843); + btDbvt dbvt[2]; + btDbvtBenchmark::NilPolicy policy; + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[0]); + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[1]); + dbvt[0].optimizeTopDown(); + dbvt[1].optimizeTopDown(); + printf("[3] btDbvt::collideTT: "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark3_Iterations; ++i) + { + btDbvt::collideTT(dbvt[0].m_root, dbvt[1].m_root, policy); + } + const int time = (int)wallclock.getTimeMilliseconds(); + printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark3_Reference) * 100 / time); + } + if (cfgBenchmark4_Enable) + { // Benchmark 4 + srand(380843); + btDbvt dbvt; + btDbvtBenchmark::NilPolicy policy; + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + printf("[4] btDbvt::collideTT self: "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark4_Iterations; ++i) + { + btDbvt::collideTT(dbvt.m_root, dbvt.m_root, policy); + } + const int time = (int)wallclock.getTimeMilliseconds(); + printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark4_Reference) * 100 / time); + } + if (cfgBenchmark5_Enable) + { // Benchmark 5 + srand(380843); + btDbvt dbvt[2]; + btAlignedObjectArray transforms; + btDbvtBenchmark::NilPolicy policy; + transforms.resize(cfgBenchmark5_Iterations); + for (int i = 0; i < transforms.size(); ++i) + { + transforms[i] = btDbvtBenchmark::RandTransform(cfgVolumeCenterScale * cfgBenchmark5_OffsetScale); + } + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[0]); + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt[1]); + dbvt[0].optimizeTopDown(); + dbvt[1].optimizeTopDown(); + printf("[5] btDbvt::collideTT xform: "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark5_Iterations; ++i) + { + btDbvt::collideTT(dbvt[0].m_root, dbvt[1].m_root, transforms[i], policy); + } + const int time = (int)wallclock.getTimeMilliseconds(); + printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark5_Reference) * 100 / time); + } + if (cfgBenchmark6_Enable) + { // Benchmark 6 + srand(380843); + btDbvt dbvt; + btAlignedObjectArray transforms; + btDbvtBenchmark::NilPolicy policy; + transforms.resize(cfgBenchmark6_Iterations); + for (int i = 0; i < transforms.size(); ++i) + { + transforms[i] = btDbvtBenchmark::RandTransform(cfgVolumeCenterScale * cfgBenchmark6_OffsetScale); + } + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + printf("[6] btDbvt::collideTT xform,self: "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark6_Iterations; ++i) + { + btDbvt::collideTT(dbvt.m_root, dbvt.m_root, transforms[i], policy); + } + const int time = (int)wallclock.getTimeMilliseconds(); + printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark6_Reference) * 100 / time); + } + if (cfgBenchmark7_Enable) + { // Benchmark 7 + srand(380843); + btDbvt dbvt; + btAlignedObjectArray rayorg; + btAlignedObjectArray raydir; + btDbvtBenchmark::NilPolicy policy; + rayorg.resize(cfgBenchmark7_Iterations); + raydir.resize(cfgBenchmark7_Iterations); + for (int i = 0; i < rayorg.size(); ++i) + { + rayorg[i] = btDbvtBenchmark::RandVector3(cfgVolumeCenterScale * 2); + raydir[i] = btDbvtBenchmark::RandVector3(cfgVolumeCenterScale * 2); + } + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + printf("[7] btDbvt::rayTest: "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark7_Passes; ++i) + { + for (int j = 0; j < cfgBenchmark7_Iterations; ++j) + { + btDbvt::rayTest(dbvt.m_root, rayorg[j], rayorg[j] + raydir[j], policy); + } + } + const int time = (int)wallclock.getTimeMilliseconds(); + unsigned rays = cfgBenchmark7_Passes * cfgBenchmark7_Iterations; + printf("%u ms (%i%%),(%u r/s)\r\n", time, (time - cfgBenchmark7_Reference) * 100 / time, (rays * 1000) / time); + } + if (cfgBenchmark8_Enable) + { // Benchmark 8 + srand(380843); + btDbvt dbvt; + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + printf("[8] insert/remove: "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark8_Passes; ++i) + { + for (int j = 0; j < cfgBenchmark8_Iterations; ++j) + { + dbvt.remove(dbvt.insert(btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale), 0)); + } + } + const int time = (int)wallclock.getTimeMilliseconds(); + const int ir = cfgBenchmark8_Passes * cfgBenchmark8_Iterations; + printf("%u ms (%i%%),(%u ir/s)\r\n", time, (time - cfgBenchmark8_Reference) * 100 / time, ir * 1000 / time); + } + if (cfgBenchmark9_Enable) + { // Benchmark 9 + srand(380843); + btDbvt dbvt; + btAlignedObjectArray leaves; + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + dbvt.extractLeaves(dbvt.m_root, leaves); + printf("[9] updates (teleport): "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark9_Passes; ++i) + { + for (int j = 0; j < cfgBenchmark9_Iterations; ++j) + { + dbvt.update(const_cast(leaves[rand() % cfgLeaves]), + btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale)); + } + } + const int time = (int)wallclock.getTimeMilliseconds(); + const int up = cfgBenchmark9_Passes * cfgBenchmark9_Iterations; + printf("%u ms (%i%%),(%u u/s)\r\n", time, (time - cfgBenchmark9_Reference) * 100 / time, up * 1000 / time); + } + if (cfgBenchmark10_Enable) + { // Benchmark 10 + srand(380843); + btDbvt dbvt; + btAlignedObjectArray leaves; + btAlignedObjectArray vectors; + vectors.resize(cfgBenchmark10_Iterations); + for (int i = 0; i < vectors.size(); ++i) + { + vectors[i] = (btDbvtBenchmark::RandVector3() * 2 - btVector3(1, 1, 1)) * cfgBenchmark10_Scale; + } + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + dbvt.extractLeaves(dbvt.m_root, leaves); + printf("[10] updates (jitter): "); + wallclock.reset(); + + for (int i = 0; i < cfgBenchmark10_Passes; ++i) + { + for (int j = 0; j < cfgBenchmark10_Iterations; ++j) + { + const btVector3& d = vectors[j]; + btDbvtNode* l = const_cast(leaves[rand() % cfgLeaves]); + btDbvtVolume v = btDbvtVolume::FromMM(l->volume.Mins() + d, l->volume.Maxs() + d); + dbvt.update(l, v); + } + } + const int time = (int)wallclock.getTimeMilliseconds(); + const int up = cfgBenchmark10_Passes * cfgBenchmark10_Iterations; + printf("%u ms (%i%%),(%u u/s)\r\n", time, (time - cfgBenchmark10_Reference) * 100 / time, up * 1000 / time); + } + if (cfgBenchmark11_Enable) + { // Benchmark 11 + srand(380843); + btDbvt dbvt; + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + printf("[11] optimize (incremental): "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark11_Passes; ++i) + { + dbvt.optimizeIncremental(cfgBenchmark11_Iterations); + } + const int time = (int)wallclock.getTimeMilliseconds(); + const int op = cfgBenchmark11_Passes * cfgBenchmark11_Iterations; + printf("%u ms (%i%%),(%u o/s)\r\n", time, (time - cfgBenchmark11_Reference) * 100 / time, op / time * 1000); + } + if (cfgBenchmark12_Enable) + { // Benchmark 12 + srand(380843); + btAlignedObjectArray volumes; + btAlignedObjectArray results; + volumes.resize(cfgLeaves); + results.resize(cfgLeaves); + for (int i = 0; i < cfgLeaves; ++i) + { + volumes[i] = btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale); + } + printf("[12] btDbvtVolume notequal: "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark12_Iterations; ++i) + { + for (int j = 0; j < cfgLeaves; ++j) + { + for (int k = 0; k < cfgLeaves; ++k) + { + results[k] = NotEqual(volumes[j], volumes[k]); + } + } + } + const int time = (int)wallclock.getTimeMilliseconds(); + printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark12_Reference) * 100 / time); + } + if (cfgBenchmark13_Enable) + { // Benchmark 13 + srand(380843); + btDbvt dbvt; + btAlignedObjectArray vectors; + btDbvtBenchmark::NilPolicy policy; + vectors.resize(cfgBenchmark13_Iterations); + for (int i = 0; i < vectors.size(); ++i) + { + vectors[i] = (btDbvtBenchmark::RandVector3() * 2 - btVector3(1, 1, 1)).normalized(); + } + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + printf("[13] culling(OCL+fullsort): "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark13_Iterations; ++i) + { + static const btScalar offset = 0; + policy.m_depth = -SIMD_INFINITY; + dbvt.collideOCL(dbvt.m_root, &vectors[i], &offset, vectors[i], 1, policy); + } + const int time = (int)wallclock.getTimeMilliseconds(); + const int t = cfgBenchmark13_Iterations; + printf("%u ms (%i%%),(%u t/s)\r\n", time, (time - cfgBenchmark13_Reference) * 100 / time, (t * 1000) / time); + } + if (cfgBenchmark14_Enable) + { // Benchmark 14 + srand(380843); + btDbvt dbvt; + btAlignedObjectArray vectors; + btDbvtBenchmark::P14 policy; + vectors.resize(cfgBenchmark14_Iterations); + for (int i = 0; i < vectors.size(); ++i) + { + vectors[i] = (btDbvtBenchmark::RandVector3() * 2 - btVector3(1, 1, 1)).normalized(); + } + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + policy.m_nodes.reserve(cfgLeaves); + printf("[14] culling(OCL+qsort): "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark14_Iterations; ++i) + { + static const btScalar offset = 0; + policy.m_nodes.resize(0); + dbvt.collideOCL(dbvt.m_root, &vectors[i], &offset, vectors[i], 1, policy, false); + policy.m_nodes.quickSort(btDbvtBenchmark::P14::sortfnc); + } + const int time = (int)wallclock.getTimeMilliseconds(); + const int t = cfgBenchmark14_Iterations; + printf("%u ms (%i%%),(%u t/s)\r\n", time, (time - cfgBenchmark14_Reference) * 100 / time, (t * 1000) / time); + } + if (cfgBenchmark15_Enable) + { // Benchmark 15 + srand(380843); + btDbvt dbvt; + btAlignedObjectArray vectors; + btDbvtBenchmark::P15 policy; + vectors.resize(cfgBenchmark15_Iterations); + for (int i = 0; i < vectors.size(); ++i) + { + vectors[i] = (btDbvtBenchmark::RandVector3() * 2 - btVector3(1, 1, 1)).normalized(); + } + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + policy.m_nodes.reserve(cfgLeaves); + printf("[15] culling(KDOP+qsort): "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark15_Iterations; ++i) + { + static const btScalar offset = 0; + policy.m_nodes.resize(0); + policy.m_axis = vectors[i]; + dbvt.collideKDOP(dbvt.m_root, &vectors[i], &offset, 1, policy); + policy.m_nodes.quickSort(btDbvtBenchmark::P15::sortfnc); + } + const int time = (int)wallclock.getTimeMilliseconds(); + const int t = cfgBenchmark15_Iterations; + printf("%u ms (%i%%),(%u t/s)\r\n", time, (time - cfgBenchmark15_Reference) * 100 / time, (t * 1000) / time); + } + if (cfgBenchmark16_Enable) + { // Benchmark 16 + srand(380843); + btDbvt dbvt; + btAlignedObjectArray batch; + btDbvtBenchmark::RandTree(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale, cfgLeaves, dbvt); + dbvt.optimizeTopDown(); + batch.reserve(cfgBenchmark16_BatchCount); + printf("[16] insert/remove batch(%u): ", cfgBenchmark16_BatchCount); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark16_Passes; ++i) + { + for (int j = 0; j < cfgBenchmark16_BatchCount; ++j) + { + batch.push_back(dbvt.insert(btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale), 0)); + } + for (int j = 0; j < cfgBenchmark16_BatchCount; ++j) + { + dbvt.remove(batch[j]); + } + batch.resize(0); + } + const int time = (int)wallclock.getTimeMilliseconds(); + const int ir = cfgBenchmark16_Passes * cfgBenchmark16_BatchCount; + printf("%u ms (%i%%),(%u bir/s)\r\n", time, (time - cfgBenchmark16_Reference) * 100 / time, int(ir * 1000.0 / time)); + } + if (cfgBenchmark17_Enable) + { // Benchmark 17 + srand(380843); + btAlignedObjectArray volumes; + btAlignedObjectArray results; + btAlignedObjectArray indices; + volumes.resize(cfgLeaves); + results.resize(cfgLeaves); + indices.resize(cfgLeaves); + for (int i = 0; i < cfgLeaves; ++i) + { + indices[i] = i; + volumes[i] = btDbvtBenchmark::RandVolume(cfgVolumeCenterScale, cfgVolumeExentsBase, cfgVolumeExentsScale); + } + for (int i = 0; i < cfgLeaves; ++i) + { + btSwap(indices[i], indices[rand() % cfgLeaves]); + } + printf("[17] btDbvtVolume select: "); + wallclock.reset(); + for (int i = 0; i < cfgBenchmark17_Iterations; ++i) + { + for (int j = 0; j < cfgLeaves; ++j) + { + for (int k = 0; k < cfgLeaves; ++k) + { + const int idx = indices[k]; + results[idx] = Select(volumes[idx], volumes[j], volumes[k]); + } + } + } + const int time = (int)wallclock.getTimeMilliseconds(); + printf("%u ms (%i%%)\r\n", time, (time - cfgBenchmark17_Reference) * 100 / time); + } + printf("\r\n\r\n"); +} +#endif diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.cpp.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.cpp.i new file mode 100644 index 00000000..b220980f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btDbvt.cpp ---------------- + +%include "BulletCollision/BroadphaseCollision/btDbvt.cpp" + +%{ +#include "BulletCollision/BroadphaseCollision/btDbvt.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.h new file mode 100644 index 00000000..430f5771 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.h @@ -0,0 +1,1578 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2007 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +///btDbvt implementation by Nathanael Presson + +#ifndef BT_DYNAMIC_BOUNDING_VOLUME_TREE_H +#define BT_DYNAMIC_BOUNDING_VOLUME_TREE_H + +#include "LinearMath/btAlignedObjectArray.h" +#include "LinearMath/btVector3.h" +#include "LinearMath/btTransform.h" +#include "LinearMath/btAabbUtil2.h" +// +// Compile time configuration +// + +// Implementation profiles +#define DBVT_IMPL_GENERIC 0 // Generic implementation +#define DBVT_IMPL_SSE 1 // SSE + +// Template implementation of ICollide +#ifdef _WIN32 +#if (defined(_MSC_VER) && _MSC_VER >= 1400) +#define DBVT_USE_TEMPLATE 1 +#else +#define DBVT_USE_TEMPLATE 0 +#endif +#else +#define DBVT_USE_TEMPLATE 0 +#endif + +// Use only intrinsics instead of inline asm +#define DBVT_USE_INTRINSIC_SSE 1 + +// Using memmov for collideOCL +#define DBVT_USE_MEMMOVE 1 + +// Enable benchmarking code +#define DBVT_ENABLE_BENCHMARK 0 + +// Inlining +#define DBVT_INLINE SIMD_FORCE_INLINE + +// Specific methods implementation + +//SSE gives errors on a MSVC 7.1 +#if defined(BT_USE_SSE) //&& defined (_WIN32) +#define DBVT_SELECT_IMPL DBVT_IMPL_SSE +#define DBVT_MERGE_IMPL DBVT_IMPL_SSE +#define DBVT_INT0_IMPL DBVT_IMPL_SSE +#else +#define DBVT_SELECT_IMPL DBVT_IMPL_GENERIC +#define DBVT_MERGE_IMPL DBVT_IMPL_GENERIC +#define DBVT_INT0_IMPL DBVT_IMPL_GENERIC +#endif + +#if (DBVT_SELECT_IMPL == DBVT_IMPL_SSE) || \ + (DBVT_MERGE_IMPL == DBVT_IMPL_SSE) || \ + (DBVT_INT0_IMPL == DBVT_IMPL_SSE) +#include +#endif + +// +// Auto config and checks +// + +#if DBVT_USE_TEMPLATE +#define DBVT_VIRTUAL +#define DBVT_VIRTUAL_DTOR(a) +#define DBVT_PREFIX template +#define DBVT_IPOLICY T& policy +#define DBVT_CHECKTYPE \ + static const ICollide& typechecker = *(T*)1; \ + (void)typechecker; +#else +#define DBVT_VIRTUAL_DTOR(a) \ + virtual ~a() {} +#define DBVT_VIRTUAL virtual +#define DBVT_PREFIX +#define DBVT_IPOLICY ICollide& policy +#define DBVT_CHECKTYPE +#endif + +#if DBVT_USE_MEMMOVE +#if !defined(__CELLOS_LV2__) && !defined(__MWERKS__) +#include +#endif +#include +#endif + +#ifndef DBVT_USE_TEMPLATE +#error "DBVT_USE_TEMPLATE undefined" +#endif + +#ifndef DBVT_USE_MEMMOVE +#error "DBVT_USE_MEMMOVE undefined" +#endif + +#ifndef DBVT_ENABLE_BENCHMARK +#error "DBVT_ENABLE_BENCHMARK undefined" +#endif + +#ifndef DBVT_SELECT_IMPL +#error "DBVT_SELECT_IMPL undefined" +#endif + +#ifndef DBVT_MERGE_IMPL +#error "DBVT_MERGE_IMPL undefined" +#endif + +#ifndef DBVT_INT0_IMPL +#error "DBVT_INT0_IMPL undefined" +#endif + +// +// Defaults volumes +// + +/* btDbvtAabbMm */ +struct btDbvtAabbMm +{ + DBVT_INLINE btDbvtAabbMm(){} + DBVT_INLINE btVector3 Center() const { return ((mi + mx) / 2); } + DBVT_INLINE btVector3 Lengths() const { return (mx - mi); } + DBVT_INLINE btVector3 Extents() const { return ((mx - mi) / 2); } + DBVT_INLINE const btVector3& Mins() const { return (mi); } + DBVT_INLINE const btVector3& Maxs() const { return (mx); } + static inline btDbvtAabbMm FromCE(const btVector3& c, const btVector3& e); + static inline btDbvtAabbMm FromCR(const btVector3& c, btScalar r); + static inline btDbvtAabbMm FromMM(const btVector3& mi, const btVector3& mx); + static inline btDbvtAabbMm FromPoints(const btVector3* pts, int n); + static inline btDbvtAabbMm FromPoints(const btVector3** ppts, int n); + DBVT_INLINE void Expand(const btVector3& e); + DBVT_INLINE void SignedExpand(const btVector3& e); + DBVT_INLINE bool Contain(const btDbvtAabbMm& a) const; + DBVT_INLINE int Classify(const btVector3& n, btScalar o, int s) const; + DBVT_INLINE btScalar ProjectMinimum(const btVector3& v, unsigned signs) const; + DBVT_INLINE friend bool Intersect(const btDbvtAabbMm& a, + const btDbvtAabbMm& b); + + DBVT_INLINE friend bool Intersect(const btDbvtAabbMm& a, + const btVector3& b); + + DBVT_INLINE friend btScalar Proximity(const btDbvtAabbMm& a, + const btDbvtAabbMm& b); + DBVT_INLINE friend int Select(const btDbvtAabbMm& o, + const btDbvtAabbMm& a, + const btDbvtAabbMm& b); + DBVT_INLINE friend void Merge(const btDbvtAabbMm& a, + const btDbvtAabbMm& b, + btDbvtAabbMm& r); + DBVT_INLINE friend bool NotEqual(const btDbvtAabbMm& a, + const btDbvtAabbMm& b); + + DBVT_INLINE btVector3& tMins() { return (mi); } + DBVT_INLINE btVector3& tMaxs() { return (mx); } + +private: + DBVT_INLINE void AddSpan(const btVector3& d, btScalar& smi, btScalar& smx) const; + +private: + btVector3 mi, mx; +}; + +// Types +typedef btDbvtAabbMm btDbvtVolume; + +/* btDbvtNode */ +struct btDbvtNode +{ + btDbvtVolume volume; + btDbvtNode* parent; + DBVT_INLINE bool isleaf() const { return (childs[1] == 0); } + DBVT_INLINE bool isinternal() const { return (!isleaf()); } + union { + btDbvtNode* childs[2]; + void* data; + int dataAsInt; + }; +}; + +/* btDbv(normal)tNode */ +struct btDbvntNode +{ + btDbvtVolume volume; + btVector3 normal; + btScalar angle; + DBVT_INLINE bool isleaf() const { return (childs[1] == 0); } + DBVT_INLINE bool isinternal() const { return (!isleaf()); } + btDbvntNode* childs[2]; + void* data; + + btDbvntNode(const btDbvtNode* n) + : volume(n->volume) + , normal(0,0,0) + , angle(0) + , data(n->data) + { + childs[0] = 0; + childs[1] = 0; + } + + ~btDbvntNode() + { + if (childs[0]) + delete childs[0]; + if (childs[1]) + delete childs[1]; + } +}; + +typedef btAlignedObjectArray btNodeStack; + +///The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes (aabb tree). +///This btDbvt is used for soft body collision detection and for the btDbvtBroadphase. It has a fast insert, remove and update of nodes. +///Unlike the btQuantizedBvh, nodes can be dynamically moved around, which allows for change in topology of the underlying data structure. +struct btDbvt +{ + /* Stack element */ + struct sStkNN + { + const btDbvtNode* a; + const btDbvtNode* b; + sStkNN() {} + sStkNN(const btDbvtNode* na, const btDbvtNode* nb) : a(na), b(nb) {} + }; + struct sStkNP + { + const btDbvtNode* node; + int mask; + sStkNP(const btDbvtNode* n, unsigned m) : node(n), mask(m) {} + }; + struct sStkNPS + { + const btDbvtNode* node; + int mask; + btScalar value; + sStkNPS() {} + sStkNPS(const btDbvtNode* n, unsigned m, btScalar v) : node(n), mask(m), value(v) {} + }; + struct sStkCLN + { + const btDbvtNode* node; + btDbvtNode* parent; + sStkCLN(const btDbvtNode* n, btDbvtNode* p) : node(n), parent(p) {} + }; + + struct sStknNN + { + const btDbvntNode* a; + const btDbvntNode* b; + sStknNN() {} + sStknNN(const btDbvntNode* na, const btDbvntNode* nb) : a(na), b(nb) {} + }; + // Policies/Interfaces + + /* ICollide */ + struct ICollide + { + DBVT_VIRTUAL_DTOR(ICollide) + DBVT_VIRTUAL void Process(const btDbvtNode*, const btDbvtNode*) {} + DBVT_VIRTUAL void Process(const btDbvtNode*) {} + DBVT_VIRTUAL void Process(const btDbvtNode* n, btScalar) { Process(n); } + DBVT_VIRTUAL void Process(const btDbvntNode*, const btDbvntNode*) {} + DBVT_VIRTUAL bool Descent(const btDbvtNode*) { return (true); } + DBVT_VIRTUAL bool AllLeaves(const btDbvtNode*) { return (true); } + }; + /* IWriter */ + struct IWriter + { + virtual ~IWriter() {} + virtual void Prepare(const btDbvtNode* root, int numnodes) = 0; + virtual void WriteNode(const btDbvtNode*, int index, int parent, int child0, int child1) = 0; + virtual void WriteLeaf(const btDbvtNode*, int index, int parent) = 0; + }; + /* IClone */ + struct IClone + { + virtual ~IClone() {} + virtual void CloneLeaf(btDbvtNode*) {} + }; + + // Constants + enum + { + SIMPLE_STACKSIZE = 64, + DOUBLE_STACKSIZE = SIMPLE_STACKSIZE * 2 + }; + + // Fields + btDbvtNode* m_root; + btDbvtNode* m_free; + int m_lkhd; + int m_leaves; + unsigned m_opath; + + btAlignedObjectArray m_stkStack; + + // Methods + btDbvt(); + ~btDbvt(); + void clear(); + bool empty() const { return (0 == m_root); } + void optimizeBottomUp(); + void optimizeTopDown(int bu_treshold = 128); + void optimizeIncremental(int passes); + btDbvtNode* insert(const btDbvtVolume& box, void* data); + void update(btDbvtNode* leaf, int lookahead = -1); + void update(btDbvtNode* leaf, btDbvtVolume& volume); + bool update(btDbvtNode* leaf, btDbvtVolume& volume, const btVector3& velocity, btScalar margin); + bool update(btDbvtNode* leaf, btDbvtVolume& volume, const btVector3& velocity); + bool update(btDbvtNode* leaf, btDbvtVolume& volume, btScalar margin); + void remove(btDbvtNode* leaf); + void write(IWriter* iwriter) const; + void clone(btDbvt& dest, IClone* iclone = 0) const; + static int maxdepth(const btDbvtNode* node); + static int countLeaves(const btDbvtNode* node); + static void extractLeaves(const btDbvtNode* node, btAlignedObjectArray& leaves); +#if DBVT_ENABLE_BENCHMARK + static void benchmark(); +#else + static void benchmark() + { + } +#endif + // DBVT_IPOLICY must support ICollide policy/interface + DBVT_PREFIX + static void enumNodes(const btDbvtNode* root, + DBVT_IPOLICY); + DBVT_PREFIX + static void enumLeaves(const btDbvtNode* root, + DBVT_IPOLICY); + DBVT_PREFIX + void collideTT(const btDbvtNode* root0, + const btDbvtNode* root1, + DBVT_IPOLICY); + DBVT_PREFIX + void selfCollideT(const btDbvntNode* root, + DBVT_IPOLICY); + DBVT_PREFIX + void selfCollideTT(const btDbvtNode* root, + DBVT_IPOLICY); + + DBVT_PREFIX + void collideTTpersistentStack(const btDbvtNode* root0, + const btDbvtNode* root1, + DBVT_IPOLICY); +#if 0 + DBVT_PREFIX + void collideTT( const btDbvtNode* root0, + const btDbvtNode* root1, + const btTransform& xform, + DBVT_IPOLICY); + DBVT_PREFIX + void collideTT( const btDbvtNode* root0, + const btTransform& xform0, + const btDbvtNode* root1, + const btTransform& xform1, + DBVT_IPOLICY); +#endif + + DBVT_PREFIX + void collideTV(const btDbvtNode* root, + const btDbvtVolume& volume, + DBVT_IPOLICY) const; + + DBVT_PREFIX + void collideTVNoStackAlloc(const btDbvtNode* root, + const btDbvtVolume& volume, + btNodeStack& stack, + DBVT_IPOLICY) const; + + ///rayTest is a re-entrant ray test, and can be called in parallel as long as the btAlignedAlloc is thread-safe (uses locking etc) + ///rayTest is slower than rayTestInternal, because it builds a local stack, using memory allocations, and it recomputes signs/rayDirectionInverses each time + DBVT_PREFIX + static void rayTest(const btDbvtNode* root, + const btVector3& rayFrom, + const btVector3& rayTo, + DBVT_IPOLICY); + ///rayTestInternal is faster than rayTest, because it uses a persistent stack (to reduce dynamic memory allocations to a minimum) and it uses precomputed signs/rayInverseDirections + ///rayTestInternal is used by btDbvtBroadphase to accelerate world ray casts + DBVT_PREFIX + void rayTestInternal(const btDbvtNode* root, + const btVector3& rayFrom, + const btVector3& rayTo, + const btVector3& rayDirectionInverse, + unsigned int signs[3], + btScalar lambda_max, + const btVector3& aabbMin, + const btVector3& aabbMax, + btAlignedObjectArray& stack, + DBVT_IPOLICY) const; + + DBVT_PREFIX + static void collideKDOP(const btDbvtNode* root, + const btVector3* normals, + const btScalar* offsets, + int count, + DBVT_IPOLICY); + DBVT_PREFIX + static void collideOCL(const btDbvtNode* root, + const btVector3* normals, + const btScalar* offsets, + const btVector3& sortaxis, + int count, + DBVT_IPOLICY, + bool fullsort = true); + DBVT_PREFIX + static void collideTU(const btDbvtNode* root, + DBVT_IPOLICY); + // Helpers + static DBVT_INLINE int nearest(const int* i, const btDbvt::sStkNPS* a, btScalar v, int l, int h) + { + int m = 0; + while (l < h) + { + m = (l + h) >> 1; + if (a[i[m]].value >= v) + l = m + 1; + else + h = m; + } + return (h); + } + static DBVT_INLINE int allocate(btAlignedObjectArray& ifree, + btAlignedObjectArray& stock, + const sStkNPS& value) + { + int i; + if (ifree.size() > 0) + { + i = ifree[ifree.size() - 1]; + ifree.pop_back(); + stock[i] = value; + } + else + { + i = stock.size(); + stock.push_back(value); + } + return (i); + } + // +private: + btDbvt(const btDbvt&) {} +}; + +// +// Inline's +// + +// +inline btDbvtAabbMm btDbvtAabbMm::FromCE(const btVector3& c, const btVector3& e) +{ + btDbvtAabbMm box; + box.mi = c - e; + box.mx = c + e; + return (box); +} + +// +inline btDbvtAabbMm btDbvtAabbMm::FromCR(const btVector3& c, btScalar r) +{ + return (FromCE(c, btVector3(r, r, r))); +} + +// +inline btDbvtAabbMm btDbvtAabbMm::FromMM(const btVector3& mi, const btVector3& mx) +{ + btDbvtAabbMm box; + box.mi = mi; + box.mx = mx; + return (box); +} + +// +inline btDbvtAabbMm btDbvtAabbMm::FromPoints(const btVector3* pts, int n) +{ + btDbvtAabbMm box; + box.mi = box.mx = pts[0]; + for (int i = 1; i < n; ++i) + { + box.mi.setMin(pts[i]); + box.mx.setMax(pts[i]); + } + return (box); +} + +// +inline btDbvtAabbMm btDbvtAabbMm::FromPoints(const btVector3** ppts, int n) +{ + btDbvtAabbMm box; + box.mi = box.mx = *ppts[0]; + for (int i = 1; i < n; ++i) + { + box.mi.setMin(*ppts[i]); + box.mx.setMax(*ppts[i]); + } + return (box); +} + +// +DBVT_INLINE void btDbvtAabbMm::Expand(const btVector3& e) +{ + mi -= e; + mx += e; +} + +// +DBVT_INLINE void btDbvtAabbMm::SignedExpand(const btVector3& e) +{ + if (e.x() > 0) + mx.setX(mx.x() + e[0]); + else + mi.setX(mi.x() + e[0]); + if (e.y() > 0) + mx.setY(mx.y() + e[1]); + else + mi.setY(mi.y() + e[1]); + if (e.z() > 0) + mx.setZ(mx.z() + e[2]); + else + mi.setZ(mi.z() + e[2]); +} + +// +DBVT_INLINE bool btDbvtAabbMm::Contain(const btDbvtAabbMm& a) const +{ + return ((mi.x() <= a.mi.x()) && + (mi.y() <= a.mi.y()) && + (mi.z() <= a.mi.z()) && + (mx.x() >= a.mx.x()) && + (mx.y() >= a.mx.y()) && + (mx.z() >= a.mx.z())); +} + +// +DBVT_INLINE int btDbvtAabbMm::Classify(const btVector3& n, btScalar o, int s) const +{ + btVector3 pi, px; + switch (s) + { + case (0 + 0 + 0): + px = btVector3(mi.x(), mi.y(), mi.z()); + pi = btVector3(mx.x(), mx.y(), mx.z()); + break; + case (1 + 0 + 0): + px = btVector3(mx.x(), mi.y(), mi.z()); + pi = btVector3(mi.x(), mx.y(), mx.z()); + break; + case (0 + 2 + 0): + px = btVector3(mi.x(), mx.y(), mi.z()); + pi = btVector3(mx.x(), mi.y(), mx.z()); + break; + case (1 + 2 + 0): + px = btVector3(mx.x(), mx.y(), mi.z()); + pi = btVector3(mi.x(), mi.y(), mx.z()); + break; + case (0 + 0 + 4): + px = btVector3(mi.x(), mi.y(), mx.z()); + pi = btVector3(mx.x(), mx.y(), mi.z()); + break; + case (1 + 0 + 4): + px = btVector3(mx.x(), mi.y(), mx.z()); + pi = btVector3(mi.x(), mx.y(), mi.z()); + break; + case (0 + 2 + 4): + px = btVector3(mi.x(), mx.y(), mx.z()); + pi = btVector3(mx.x(), mi.y(), mi.z()); + break; + case (1 + 2 + 4): + px = btVector3(mx.x(), mx.y(), mx.z()); + pi = btVector3(mi.x(), mi.y(), mi.z()); + break; + } + if ((btDot(n, px) + o) < 0) return (-1); + if ((btDot(n, pi) + o) >= 0) return (+1); + return (0); +} + +// +DBVT_INLINE btScalar btDbvtAabbMm::ProjectMinimum(const btVector3& v, unsigned signs) const +{ + const btVector3* b[] = {&mx, &mi}; + const btVector3 p(b[(signs >> 0) & 1]->x(), + b[(signs >> 1) & 1]->y(), + b[(signs >> 2) & 1]->z()); + return (btDot(p, v)); +} + +// +DBVT_INLINE void btDbvtAabbMm::AddSpan(const btVector3& d, btScalar& smi, btScalar& smx) const +{ + for (int i = 0; i < 3; ++i) + { + if (d[i] < 0) + { + smi += mx[i] * d[i]; + smx += mi[i] * d[i]; + } + else + { + smi += mi[i] * d[i]; + smx += mx[i] * d[i]; + } + } +} + +// +DBVT_INLINE bool Intersect(const btDbvtAabbMm& a, + const btDbvtAabbMm& b) +{ +#if DBVT_INT0_IMPL == DBVT_IMPL_SSE + const __m128 rt(_mm_or_ps(_mm_cmplt_ps(_mm_load_ps(b.mx), _mm_load_ps(a.mi)), + _mm_cmplt_ps(_mm_load_ps(a.mx), _mm_load_ps(b.mi)))); +#if defined(_WIN32) + const __int32* pu((const __int32*)&rt); +#else + const int* pu((const int*)&rt); +#endif + return ((pu[0] | pu[1] | pu[2]) == 0); +#else + return ((a.mi.x() <= b.mx.x()) && + (a.mx.x() >= b.mi.x()) && + (a.mi.y() <= b.mx.y()) && + (a.mx.y() >= b.mi.y()) && + (a.mi.z() <= b.mx.z()) && + (a.mx.z() >= b.mi.z())); +#endif +} + +// +DBVT_INLINE bool Intersect(const btDbvtAabbMm& a, + const btVector3& b) +{ + return ((b.x() >= a.mi.x()) && + (b.y() >= a.mi.y()) && + (b.z() >= a.mi.z()) && + (b.x() <= a.mx.x()) && + (b.y() <= a.mx.y()) && + (b.z() <= a.mx.z())); +} + +////////////////////////////////////// + +// +DBVT_INLINE btScalar Proximity(const btDbvtAabbMm& a, + const btDbvtAabbMm& b) +{ + const btVector3 d = (a.mi + a.mx) - (b.mi + b.mx); + return (btFabs(d.x()) + btFabs(d.y()) + btFabs(d.z())); +} + +// +DBVT_INLINE int Select(const btDbvtAabbMm& o, + const btDbvtAabbMm& a, + const btDbvtAabbMm& b) +{ +#if DBVT_SELECT_IMPL == DBVT_IMPL_SSE + +#if defined(_WIN32) + static ATTRIBUTE_ALIGNED16(const unsigned __int32) mask[] = {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff}; +#else + static ATTRIBUTE_ALIGNED16(const unsigned int) mask[] = {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x00000000 /*0x7fffffff*/}; +#endif + ///@todo: the intrinsic version is 11% slower +#if DBVT_USE_INTRINSIC_SSE + + union btSSEUnion ///NOTE: if we use more intrinsics, move btSSEUnion into the LinearMath directory + { + __m128 ssereg; + float floats[4]; + int ints[4]; + }; + + __m128 omi(_mm_load_ps(o.mi)); + omi = _mm_add_ps(omi, _mm_load_ps(o.mx)); + __m128 ami(_mm_load_ps(a.mi)); + ami = _mm_add_ps(ami, _mm_load_ps(a.mx)); + ami = _mm_sub_ps(ami, omi); + ami = _mm_and_ps(ami, _mm_load_ps((const float*)mask)); + __m128 bmi(_mm_load_ps(b.mi)); + bmi = _mm_add_ps(bmi, _mm_load_ps(b.mx)); + bmi = _mm_sub_ps(bmi, omi); + bmi = _mm_and_ps(bmi, _mm_load_ps((const float*)mask)); + __m128 t0(_mm_movehl_ps(ami, ami)); + ami = _mm_add_ps(ami, t0); + ami = _mm_add_ss(ami, _mm_shuffle_ps(ami, ami, 1)); + __m128 t1(_mm_movehl_ps(bmi, bmi)); + bmi = _mm_add_ps(bmi, t1); + bmi = _mm_add_ss(bmi, _mm_shuffle_ps(bmi, bmi, 1)); + + btSSEUnion tmp; + tmp.ssereg = _mm_cmple_ss(bmi, ami); + return tmp.ints[0] & 1; + +#else + ATTRIBUTE_ALIGNED16(__int32 r[1]); + __asm + { + mov eax,o + mov ecx,a + mov edx,b + movaps xmm0,[eax] + movaps xmm5,mask + addps xmm0,[eax+16] + movaps xmm1,[ecx] + movaps xmm2,[edx] + addps xmm1,[ecx+16] + addps xmm2,[edx+16] + subps xmm1,xmm0 + subps xmm2,xmm0 + andps xmm1,xmm5 + andps xmm2,xmm5 + movhlps xmm3,xmm1 + movhlps xmm4,xmm2 + addps xmm1,xmm3 + addps xmm2,xmm4 + pshufd xmm3,xmm1,1 + pshufd xmm4,xmm2,1 + addss xmm1,xmm3 + addss xmm2,xmm4 + cmpless xmm2,xmm1 + movss r,xmm2 + } + return (r[0] & 1); +#endif +#else + return (Proximity(o, a) < Proximity(o, b) ? 0 : 1); +#endif +} + +// +DBVT_INLINE void Merge(const btDbvtAabbMm& a, + const btDbvtAabbMm& b, + btDbvtAabbMm& r) +{ +#if DBVT_MERGE_IMPL == DBVT_IMPL_SSE + __m128 ami(_mm_load_ps(a.mi)); + __m128 amx(_mm_load_ps(a.mx)); + __m128 bmi(_mm_load_ps(b.mi)); + __m128 bmx(_mm_load_ps(b.mx)); + ami = _mm_min_ps(ami, bmi); + amx = _mm_max_ps(amx, bmx); + _mm_store_ps(r.mi, ami); + _mm_store_ps(r.mx, amx); +#else + for (int i = 0; i < 3; ++i) + { + if (a.mi[i] < b.mi[i]) + r.mi[i] = a.mi[i]; + else + r.mi[i] = b.mi[i]; + if (a.mx[i] > b.mx[i]) + r.mx[i] = a.mx[i]; + else + r.mx[i] = b.mx[i]; + } +#endif +} + +// +DBVT_INLINE bool NotEqual(const btDbvtAabbMm& a, + const btDbvtAabbMm& b) +{ + return ((a.mi.x() != b.mi.x()) || + (a.mi.y() != b.mi.y()) || + (a.mi.z() != b.mi.z()) || + (a.mx.x() != b.mx.x()) || + (a.mx.y() != b.mx.y()) || + (a.mx.z() != b.mx.z())); +} + +// +// Inline's +// + +// +DBVT_PREFIX +inline void btDbvt::enumNodes(const btDbvtNode* root, + DBVT_IPOLICY) +{ + DBVT_CHECKTYPE + policy.Process(root); + if (root->isinternal()) + { + enumNodes(root->childs[0], policy); + enumNodes(root->childs[1], policy); + } +} + +// +DBVT_PREFIX +inline void btDbvt::enumLeaves(const btDbvtNode* root, + DBVT_IPOLICY) +{ + DBVT_CHECKTYPE + if (root->isinternal()) + { + enumLeaves(root->childs[0], policy); + enumLeaves(root->childs[1], policy); + } + else + { + policy.Process(root); + } +} + +// +DBVT_PREFIX +inline void btDbvt::collideTT(const btDbvtNode* root0, + const btDbvtNode* root1, + DBVT_IPOLICY) +{ + DBVT_CHECKTYPE + if (root0 && root1) + { + int depth = 1; + int treshold = DOUBLE_STACKSIZE - 4; + btAlignedObjectArray stkStack; + stkStack.resize(DOUBLE_STACKSIZE); + stkStack[0] = sStkNN(root0, root1); + do + { + sStkNN p = stkStack[--depth]; + if (depth > treshold) + { + stkStack.resize(stkStack.size() * 2); + treshold = stkStack.size() - 4; + } + if (p.a == p.b) + { + if (p.a->isinternal()) + { + stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[0]); + stkStack[depth++] = sStkNN(p.a->childs[1], p.a->childs[1]); + stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[1]); + } + } + else if (Intersect(p.a->volume, p.b->volume)) + { + if (p.a->isinternal()) + { + if (p.b->isinternal()) + { + stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[0]); + stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[0]); + stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[1]); + stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[1]); + } + else + { + stkStack[depth++] = sStkNN(p.a->childs[0], p.b); + stkStack[depth++] = sStkNN(p.a->childs[1], p.b); + } + } + else + { + if (p.b->isinternal()) + { + stkStack[depth++] = sStkNN(p.a, p.b->childs[0]); + stkStack[depth++] = sStkNN(p.a, p.b->childs[1]); + } + else + { + policy.Process(p.a, p.b); + } + } + } + } while (depth); + } +} + +// +DBVT_PREFIX +inline void btDbvt::selfCollideT(const btDbvntNode* root, + DBVT_IPOLICY) +{ + DBVT_CHECKTYPE + if (root) + { + int depth = 1; + int treshold = DOUBLE_STACKSIZE - 4; + btAlignedObjectArray stkStack; + stkStack.resize(DOUBLE_STACKSIZE); + stkStack[0] = sStknNN(root, root); + do + { + sStknNN p = stkStack[--depth]; + if (depth > treshold) + { + stkStack.resize(stkStack.size() * 2); + treshold = stkStack.size() - 4; + } + if (p.a == p.b) + { + if (p.a->isinternal() && p.a->angle > SIMD_PI) + { + stkStack[depth++] = sStknNN(p.a->childs[0], p.a->childs[0]); + stkStack[depth++] = sStknNN(p.a->childs[1], p.a->childs[1]); + stkStack[depth++] = sStknNN(p.a->childs[0], p.a->childs[1]); + } + } + else if (Intersect(p.a->volume, p.b->volume)) + { + if (p.a->isinternal()) + { + if (p.b->isinternal()) + { + stkStack[depth++] = sStknNN(p.a->childs[0], p.b->childs[0]); + stkStack[depth++] = sStknNN(p.a->childs[1], p.b->childs[0]); + stkStack[depth++] = sStknNN(p.a->childs[0], p.b->childs[1]); + stkStack[depth++] = sStknNN(p.a->childs[1], p.b->childs[1]); + } + else + { + stkStack[depth++] = sStknNN(p.a->childs[0], p.b); + stkStack[depth++] = sStknNN(p.a->childs[1], p.b); + } + } + else + { + if (p.b->isinternal()) + { + stkStack[depth++] = sStknNN(p.a, p.b->childs[0]); + stkStack[depth++] = sStknNN(p.a, p.b->childs[1]); + } + else + { + policy.Process(p.a, p.b); + } + } + } + } while (depth); + } +} + +// +DBVT_PREFIX +inline void btDbvt::selfCollideTT(const btDbvtNode* root, + DBVT_IPOLICY) +{ + DBVT_CHECKTYPE + if (root) + { + int depth = 1; + int treshold = DOUBLE_STACKSIZE - 4; + btAlignedObjectArray stkStack; + stkStack.resize(DOUBLE_STACKSIZE); + stkStack[0] = sStkNN(root, root); + do + { + sStkNN p = stkStack[--depth]; + if (depth > treshold) + { + stkStack.resize(stkStack.size() * 2); + treshold = stkStack.size() - 4; + } + if (p.a == p.b) + { + if (p.a->isinternal()) + { + stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[0]); + stkStack[depth++] = sStkNN(p.a->childs[1], p.a->childs[1]); + stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[1]); + } + } + else if (Intersect(p.a->volume, p.b->volume)) + { + if (p.a->isinternal()) + { + if (p.b->isinternal()) + { + stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[0]); + stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[0]); + stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[1]); + stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[1]); + } + else + { + stkStack[depth++] = sStkNN(p.a->childs[0], p.b); + stkStack[depth++] = sStkNN(p.a->childs[1], p.b); + } + } + else + { + if (p.b->isinternal()) + { + stkStack[depth++] = sStkNN(p.a, p.b->childs[0]); + stkStack[depth++] = sStkNN(p.a, p.b->childs[1]); + } + else + { + policy.Process(p.a, p.b); + } + } + } + } while (depth); + } +} + + +DBVT_PREFIX +inline void btDbvt::collideTTpersistentStack(const btDbvtNode* root0, + const btDbvtNode* root1, + DBVT_IPOLICY) +{ + DBVT_CHECKTYPE + if (root0 && root1) + { + int depth = 1; + int treshold = DOUBLE_STACKSIZE - 4; + + m_stkStack.resize(DOUBLE_STACKSIZE); + m_stkStack[0] = sStkNN(root0, root1); + do + { + sStkNN p = m_stkStack[--depth]; + if (depth > treshold) + { + m_stkStack.resize(m_stkStack.size() * 2); + treshold = m_stkStack.size() - 4; + } + if (p.a == p.b) + { + if (p.a->isinternal()) + { + m_stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[0]); + m_stkStack[depth++] = sStkNN(p.a->childs[1], p.a->childs[1]); + m_stkStack[depth++] = sStkNN(p.a->childs[0], p.a->childs[1]); + } + } + else if (Intersect(p.a->volume, p.b->volume)) + { + if (p.a->isinternal()) + { + if (p.b->isinternal()) + { + m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[0]); + m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[0]); + m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b->childs[1]); + m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b->childs[1]); + } + else + { + m_stkStack[depth++] = sStkNN(p.a->childs[0], p.b); + m_stkStack[depth++] = sStkNN(p.a->childs[1], p.b); + } + } + else + { + if (p.b->isinternal()) + { + m_stkStack[depth++] = sStkNN(p.a, p.b->childs[0]); + m_stkStack[depth++] = sStkNN(p.a, p.b->childs[1]); + } + else + { + policy.Process(p.a, p.b); + } + } + } + } while (depth); + } +} + +#if 0 +// +DBVT_PREFIX +inline void btDbvt::collideTT( const btDbvtNode* root0, + const btDbvtNode* root1, + const btTransform& xform, + DBVT_IPOLICY) +{ + DBVT_CHECKTYPE + if(root0&&root1) + { + int depth=1; + int treshold=DOUBLE_STACKSIZE-4; + btAlignedObjectArray stkStack; + stkStack.resize(DOUBLE_STACKSIZE); + stkStack[0]=sStkNN(root0,root1); + do { + sStkNN p=stkStack[--depth]; + if(Intersect(p.a->volume,p.b->volume,xform)) + { + if(depth>treshold) + { + stkStack.resize(stkStack.size()*2); + treshold=stkStack.size()-4; + } + if(p.a->isinternal()) + { + if(p.b->isinternal()) + { + stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[0]); + stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[0]); + stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[1]); + stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[1]); + } + else + { + stkStack[depth++]=sStkNN(p.a->childs[0],p.b); + stkStack[depth++]=sStkNN(p.a->childs[1],p.b); + } + } + else + { + if(p.b->isinternal()) + { + stkStack[depth++]=sStkNN(p.a,p.b->childs[0]); + stkStack[depth++]=sStkNN(p.a,p.b->childs[1]); + } + else + { + policy.Process(p.a,p.b); + } + } + } + } while(depth); + } +} +// +DBVT_PREFIX +inline void btDbvt::collideTT( const btDbvtNode* root0, + const btTransform& xform0, + const btDbvtNode* root1, + const btTransform& xform1, + DBVT_IPOLICY) +{ + const btTransform xform=xform0.inverse()*xform1; + collideTT(root0,root1,xform,policy); +} +#endif + +DBVT_PREFIX +inline void btDbvt::collideTV(const btDbvtNode* root, + const btDbvtVolume& vol, + DBVT_IPOLICY) const +{ + DBVT_CHECKTYPE + if (root) + { + ATTRIBUTE_ALIGNED16(btDbvtVolume) + volume(vol); + btAlignedObjectArray stack; + stack.resize(0); +#ifndef BT_DISABLE_STACK_TEMP_MEMORY + char tempmemory[SIMPLE_STACKSIZE * sizeof(const btDbvtNode*)]; + stack.initializeFromBuffer(tempmemory, 0, SIMPLE_STACKSIZE); +#else + stack.reserve(SIMPLE_STACKSIZE); +#endif //BT_DISABLE_STACK_TEMP_MEMORY + + stack.push_back(root); + do + { + const btDbvtNode* n = stack[stack.size() - 1]; + stack.pop_back(); + if (Intersect(n->volume, volume)) + { + if (n->isinternal()) + { + stack.push_back(n->childs[0]); + stack.push_back(n->childs[1]); + } + else + { + policy.Process(n); + } + } + } while (stack.size() > 0); + } +} + +// +DBVT_PREFIX +inline void btDbvt::collideTVNoStackAlloc(const btDbvtNode* root, + const btDbvtVolume& vol, + btNodeStack& stack, + DBVT_IPOLICY) const +{ + DBVT_CHECKTYPE + if (root) + { + ATTRIBUTE_ALIGNED16(btDbvtVolume) + volume(vol); + stack.resize(0); + stack.reserve(SIMPLE_STACKSIZE); + stack.push_back(root); + do + { + const btDbvtNode* n = stack[stack.size() - 1]; + stack.pop_back(); + if (Intersect(n->volume, volume)) + { + if (n->isinternal()) + { + stack.push_back(n->childs[0]); + stack.push_back(n->childs[1]); + } + else + { + policy.Process(n); + } + } + } while (stack.size() > 0); + } +} + +DBVT_PREFIX +inline void btDbvt::rayTestInternal(const btDbvtNode* root, + const btVector3& rayFrom, + const btVector3& rayTo, + const btVector3& rayDirectionInverse, + unsigned int signs[3], + btScalar lambda_max, + const btVector3& aabbMin, + const btVector3& aabbMax, + btAlignedObjectArray& stack, + DBVT_IPOLICY) const +{ + (void)rayTo; + DBVT_CHECKTYPE + if (root) + { + btVector3 resultNormal; + + int depth = 1; + int treshold = DOUBLE_STACKSIZE - 2; + stack.resize(DOUBLE_STACKSIZE); + stack[0] = root; + btVector3 bounds[2]; + do + { + const btDbvtNode* node = stack[--depth]; + bounds[0] = node->volume.Mins() - aabbMax; + bounds[1] = node->volume.Maxs() - aabbMin; + btScalar tmin = 1.f, lambda_min = 0.f; + unsigned int result1 = false; + result1 = btRayAabb2(rayFrom, rayDirectionInverse, signs, bounds, tmin, lambda_min, lambda_max); + if (result1) + { + if (node->isinternal()) + { + if (depth > treshold) + { + stack.resize(stack.size() * 2); + treshold = stack.size() - 2; + } + stack[depth++] = node->childs[0]; + stack[depth++] = node->childs[1]; + } + else + { + policy.Process(node); + } + } + } while (depth); + } +} + +// +DBVT_PREFIX +inline void btDbvt::rayTest(const btDbvtNode* root, + const btVector3& rayFrom, + const btVector3& rayTo, + DBVT_IPOLICY) +{ + DBVT_CHECKTYPE + if (root) + { + btVector3 rayDir = (rayTo - rayFrom); + rayDir.normalize(); + + ///what about division by zero? --> just set rayDirection[i] to INF/BT_LARGE_FLOAT + btVector3 rayDirectionInverse; + rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[0]; + rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[1]; + rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[2]; + unsigned int signs[3] = {rayDirectionInverse[0] < 0.0, rayDirectionInverse[1] < 0.0, rayDirectionInverse[2] < 0.0}; + + btScalar lambda_max = rayDir.dot(rayTo - rayFrom); + + btVector3 resultNormal; + + btAlignedObjectArray stack; + + int depth = 1; + int treshold = DOUBLE_STACKSIZE - 2; + + char tempmemory[DOUBLE_STACKSIZE * sizeof(const btDbvtNode*)]; +#ifndef BT_DISABLE_STACK_TEMP_MEMORY + stack.initializeFromBuffer(tempmemory, DOUBLE_STACKSIZE, DOUBLE_STACKSIZE); +#else //BT_DISABLE_STACK_TEMP_MEMORY + stack.resize(DOUBLE_STACKSIZE); +#endif //BT_DISABLE_STACK_TEMP_MEMORY + stack[0] = root; + btVector3 bounds[2]; + do + { + const btDbvtNode* node = stack[--depth]; + + bounds[0] = node->volume.Mins(); + bounds[1] = node->volume.Maxs(); + + btScalar tmin = 1.f, lambda_min = 0.f; + unsigned int result1 = btRayAabb2(rayFrom, rayDirectionInverse, signs, bounds, tmin, lambda_min, lambda_max); + +#ifdef COMPARE_BTRAY_AABB2 + btScalar param = 1.f; + bool result2 = btRayAabb(rayFrom, rayTo, node->volume.Mins(), node->volume.Maxs(), param, resultNormal); + btAssert(result1 == result2); +#endif //TEST_BTRAY_AABB2 + + if (result1) + { + if (node->isinternal()) + { + if (depth > treshold) + { + stack.resize(stack.size() * 2); + treshold = stack.size() - 2; + } + stack[depth++] = node->childs[0]; + stack[depth++] = node->childs[1]; + } + else + { + policy.Process(node); + } + } + } while (depth); + } +} + +// +DBVT_PREFIX +inline void btDbvt::collideKDOP(const btDbvtNode* root, + const btVector3* normals, + const btScalar* offsets, + int count, + DBVT_IPOLICY) +{ + DBVT_CHECKTYPE + if (root) + { + const int inside = (1 << count) - 1; + btAlignedObjectArray stack; + int signs[sizeof(unsigned) * 8]; + btAssert(count < int(sizeof(signs) / sizeof(signs[0]))); + for (int i = 0; i < count; ++i) + { + signs[i] = ((normals[i].x() >= 0) ? 1 : 0) + + ((normals[i].y() >= 0) ? 2 : 0) + + ((normals[i].z() >= 0) ? 4 : 0); + } + stack.reserve(SIMPLE_STACKSIZE); + stack.push_back(sStkNP(root, 0)); + do + { + sStkNP se = stack[stack.size() - 1]; + bool out = false; + stack.pop_back(); + for (int i = 0, j = 1; (!out) && (i < count); ++i, j <<= 1) + { + if (0 == (se.mask & j)) + { + const int side = se.node->volume.Classify(normals[i], offsets[i], signs[i]); + switch (side) + { + case -1: + out = true; + break; + case +1: + se.mask |= j; + break; + } + } + } + if (!out) + { + if ((se.mask != inside) && (se.node->isinternal())) + { + stack.push_back(sStkNP(se.node->childs[0], se.mask)); + stack.push_back(sStkNP(se.node->childs[1], se.mask)); + } + else + { + if (policy.AllLeaves(se.node)) enumLeaves(se.node, policy); + } + } + } while (stack.size()); + } +} + +// +DBVT_PREFIX +inline void btDbvt::collideOCL(const btDbvtNode* root, + const btVector3* normals, + const btScalar* offsets, + const btVector3& sortaxis, + int count, + DBVT_IPOLICY, + bool fsort) +{ + DBVT_CHECKTYPE + if (root) + { + const unsigned srtsgns = (sortaxis[0] >= 0 ? 1 : 0) + + (sortaxis[1] >= 0 ? 2 : 0) + + (sortaxis[2] >= 0 ? 4 : 0); + const int inside = (1 << count) - 1; + btAlignedObjectArray stock; + btAlignedObjectArray ifree; + btAlignedObjectArray stack; + int signs[sizeof(unsigned) * 8]; + btAssert(count < int(sizeof(signs) / sizeof(signs[0]))); + for (int i = 0; i < count; ++i) + { + signs[i] = ((normals[i].x() >= 0) ? 1 : 0) + + ((normals[i].y() >= 0) ? 2 : 0) + + ((normals[i].z() >= 0) ? 4 : 0); + } + stock.reserve(SIMPLE_STACKSIZE); + stack.reserve(SIMPLE_STACKSIZE); + ifree.reserve(SIMPLE_STACKSIZE); + stack.push_back(allocate(ifree, stock, sStkNPS(root, 0, root->volume.ProjectMinimum(sortaxis, srtsgns)))); + do + { + const int id = stack[stack.size() - 1]; + sStkNPS se = stock[id]; + stack.pop_back(); + ifree.push_back(id); + if (se.mask != inside) + { + bool out = false; + for (int i = 0, j = 1; (!out) && (i < count); ++i, j <<= 1) + { + if (0 == (se.mask & j)) + { + const int side = se.node->volume.Classify(normals[i], offsets[i], signs[i]); + switch (side) + { + case -1: + out = true; + break; + case +1: + se.mask |= j; + break; + } + } + } + if (out) continue; + } + if (policy.Descent(se.node)) + { + if (se.node->isinternal()) + { + const btDbvtNode* pns[] = {se.node->childs[0], se.node->childs[1]}; + sStkNPS nes[] = {sStkNPS(pns[0], se.mask, pns[0]->volume.ProjectMinimum(sortaxis, srtsgns)), + sStkNPS(pns[1], se.mask, pns[1]->volume.ProjectMinimum(sortaxis, srtsgns))}; + const int q = nes[0].value < nes[1].value ? 1 : 0; + int j = stack.size(); + if (fsort && (j > 0)) + { + /* Insert 0 */ + j = nearest(&stack[0], &stock[0], nes[q].value, 0, stack.size()); + stack.push_back(0); + + //void * memmove ( void * destination, const void * source, size_t num ); + +#if DBVT_USE_MEMMOVE + { + int num_items_to_move = stack.size() - 1 - j; + if (num_items_to_move > 0) + memmove(&stack[j + 1], &stack[j], sizeof(int) * num_items_to_move); + } +#else + for (int k = stack.size() - 1; k > j; --k) + { + stack[k] = stack[k - 1]; + } +#endif + stack[j] = allocate(ifree, stock, nes[q]); + /* Insert 1 */ + j = nearest(&stack[0], &stock[0], nes[1 - q].value, j, stack.size()); + stack.push_back(0); +#if DBVT_USE_MEMMOVE + { + int num_items_to_move = stack.size() - 1 - j; + if (num_items_to_move > 0) + memmove(&stack[j + 1], &stack[j], sizeof(int) * num_items_to_move); + } +#else + for (int k = stack.size() - 1; k > j; --k) + { + stack[k] = stack[k - 1]; + } +#endif + stack[j] = allocate(ifree, stock, nes[1 - q]); + } + else + { + stack.push_back(allocate(ifree, stock, nes[q])); + stack.push_back(allocate(ifree, stock, nes[1 - q])); + } + } + else + { + policy.Process(se.node, se.value); + } + } + } while (stack.size()); + } +} + +// +DBVT_PREFIX +inline void btDbvt::collideTU(const btDbvtNode* root, + DBVT_IPOLICY) +{ + DBVT_CHECKTYPE + if (root) + { + btAlignedObjectArray stack; + stack.reserve(SIMPLE_STACKSIZE); + stack.push_back(root); + do + { + const btDbvtNode* n = stack[stack.size() - 1]; + stack.pop_back(); + if (policy.Descent(n)) + { + if (n->isinternal()) + { + stack.push_back(n->childs[0]); + stack.push_back(n->childs[1]); + } + else + { + policy.Process(n); + } + } + } while (stack.size() > 0); + } +} + +// +// PP Cleanup +// + +#undef DBVT_USE_MEMMOVE +#undef DBVT_USE_TEMPLATE +#undef DBVT_VIRTUAL_DTOR +#undef DBVT_VIRTUAL +#undef DBVT_PREFIX +#undef DBVT_IPOLICY +#undef DBVT_CHECKTYPE +#undef DBVT_IMPL_GENERIC +#undef DBVT_IMPL_SSE +#undef DBVT_USE_INTRINSIC_SSE +#undef DBVT_SELECT_IMPL +#undef DBVT_MERGE_IMPL +#undef DBVT_INT0_IMPL + +#endif diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.h.i new file mode 100644 index 00000000..b068949e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvt.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btDbvt.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btDbvt.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btDbvt.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp new file mode 100644 index 00000000..7b39dbdc --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp @@ -0,0 +1,828 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///btDbvtBroadphase implementation by Nathanael Presson + +#include "btDbvtBroadphase.h" +#include "LinearMath/btThreads.h" +btScalar gDbvtMargin = btScalar(0.05); +// +// Profiling +// + +#if DBVT_BP_PROFILE || DBVT_BP_ENABLE_BENCHMARK +#include +#endif + +#if DBVT_BP_PROFILE +struct ProfileScope +{ + __forceinline ProfileScope(btClock& clock, unsigned long& value) : m_clock(&clock), m_value(&value), m_base(clock.getTimeMicroseconds()) + { + } + __forceinline ~ProfileScope() + { + (*m_value) += m_clock->getTimeMicroseconds() - m_base; + } + btClock* m_clock; + unsigned long* m_value; + unsigned long m_base; +}; +#define SPC(_value_) ProfileScope spc_scope(m_clock, _value_) +#else +#define SPC(_value_) +#endif + +// +// Helpers +// + +// +template +static inline void listappend(T* item, T*& list) +{ + item->links[0] = 0; + item->links[1] = list; + if (list) list->links[0] = item; + list = item; +} + +// +template +static inline void listremove(T* item, T*& list) +{ + if (item->links[0]) + item->links[0]->links[1] = item->links[1]; + else + list = item->links[1]; + if (item->links[1]) item->links[1]->links[0] = item->links[0]; +} + +// +template +static inline int listcount(T* root) +{ + int n = 0; + while (root) + { + ++n; + root = root->links[1]; + } + return (n); +} + +// +template +static inline void clear(T& value) +{ + static const struct ZeroDummy : T + { + } zerodummy; + value = zerodummy; +} + +// +// Colliders +// + +/* Tree collider */ +struct btDbvtTreeCollider : btDbvt::ICollide +{ + btDbvtBroadphase* pbp; + btDbvtProxy* proxy; + btDbvtTreeCollider(btDbvtBroadphase* p) : pbp(p) {} + void Process(const btDbvtNode* na, const btDbvtNode* nb) + { + if (na != nb) + { + btDbvtProxy* pa = (btDbvtProxy*)na->data; + btDbvtProxy* pb = (btDbvtProxy*)nb->data; +#if DBVT_BP_SORTPAIRS + if (pa->m_uniqueId > pb->m_uniqueId) + btSwap(pa, pb); +#endif + pbp->m_paircache->addOverlappingPair(pa, pb); + ++pbp->m_newpairs; + } + } + void Process(const btDbvtNode* n) + { + Process(n, proxy->leaf); + } +}; + +// +// btDbvtBroadphase +// + +// +btDbvtBroadphase::btDbvtBroadphase(btOverlappingPairCache* paircache) +{ + m_deferedcollide = false; + m_needcleanup = true; + m_releasepaircache = (paircache != 0) ? false : true; + m_prediction = 0; + m_stageCurrent = 0; + m_fixedleft = 0; + m_fupdates = 1; + m_dupdates = 0; + m_cupdates = 10; + m_newpairs = 1; + m_updates_call = 0; + m_updates_done = 0; + m_updates_ratio = 0; + m_paircache = paircache ? paircache : new (btAlignedAlloc(sizeof(btHashedOverlappingPairCache), 16)) btHashedOverlappingPairCache(); + m_gid = 0; + m_pid = 0; + m_cid = 0; + for (int i = 0; i <= STAGECOUNT; ++i) + { + m_stageRoots[i] = 0; + } +#if BT_THREADSAFE + m_rayTestStacks.resize(BT_MAX_THREAD_COUNT); +#else + m_rayTestStacks.resize(1); +#endif +#if DBVT_BP_PROFILE + clear(m_profiling); +#endif +} + +// +btDbvtBroadphase::~btDbvtBroadphase() +{ + if (m_releasepaircache) + { + m_paircache->~btOverlappingPairCache(); + btAlignedFree(m_paircache); + } +} + +// +btBroadphaseProxy* btDbvtBroadphase::createProxy(const btVector3& aabbMin, + const btVector3& aabbMax, + int /*shapeType*/, + void* userPtr, + int collisionFilterGroup, + int collisionFilterMask, + btDispatcher* /*dispatcher*/) +{ + btDbvtProxy* proxy = new (btAlignedAlloc(sizeof(btDbvtProxy), 16)) btDbvtProxy(aabbMin, aabbMax, userPtr, + collisionFilterGroup, + collisionFilterMask); + + btDbvtAabbMm aabb = btDbvtVolume::FromMM(aabbMin, aabbMax); + + //bproxy->aabb = btDbvtVolume::FromMM(aabbMin,aabbMax); + proxy->stage = m_stageCurrent; + proxy->m_uniqueId = ++m_gid; + proxy->leaf = m_sets[0].insert(aabb, proxy); + listappend(proxy, m_stageRoots[m_stageCurrent]); + if (!m_deferedcollide) + { + btDbvtTreeCollider collider(this); + collider.proxy = proxy; + m_sets[0].collideTV(m_sets[0].m_root, aabb, collider); + m_sets[1].collideTV(m_sets[1].m_root, aabb, collider); + } + return (proxy); +} + +// +void btDbvtBroadphase::destroyProxy(btBroadphaseProxy* absproxy, + btDispatcher* dispatcher) +{ + btDbvtProxy* proxy = (btDbvtProxy*)absproxy; + if (proxy->stage == STAGECOUNT) + m_sets[1].remove(proxy->leaf); + else + m_sets[0].remove(proxy->leaf); + listremove(proxy, m_stageRoots[proxy->stage]); + m_paircache->removeOverlappingPairsContainingProxy(proxy, dispatcher); + btAlignedFree(proxy); + m_needcleanup = true; +} + +void btDbvtBroadphase::getAabb(btBroadphaseProxy* absproxy, btVector3& aabbMin, btVector3& aabbMax) const +{ + btDbvtProxy* proxy = (btDbvtProxy*)absproxy; + aabbMin = proxy->m_aabbMin; + aabbMax = proxy->m_aabbMax; +} + +struct BroadphaseRayTester : btDbvt::ICollide +{ + btBroadphaseRayCallback& m_rayCallback; + BroadphaseRayTester(btBroadphaseRayCallback& orgCallback) + : m_rayCallback(orgCallback) + { + } + void Process(const btDbvtNode* leaf) + { + btDbvtProxy* proxy = (btDbvtProxy*)leaf->data; + m_rayCallback.process(proxy); + } +}; + +void btDbvtBroadphase::rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin, const btVector3& aabbMax) +{ + BroadphaseRayTester callback(rayCallback); + btAlignedObjectArray* stack = &m_rayTestStacks[0]; +#if BT_THREADSAFE + // for this function to be threadsafe, each thread must have a separate copy + // of this stack. This could be thread-local static to avoid dynamic allocations, + // instead of just a local. + int threadIndex = btGetCurrentThreadIndex(); + btAlignedObjectArray localStack; + //todo(erwincoumans, "why do we get tsan issue here?") + if (0)//threadIndex < m_rayTestStacks.size()) + //if (threadIndex < m_rayTestStacks.size()) + { + // use per-thread preallocated stack if possible to avoid dynamic allocations + stack = &m_rayTestStacks[threadIndex]; + } + else + { + stack = &localStack; + } +#endif + + m_sets[0].rayTestInternal(m_sets[0].m_root, + rayFrom, + rayTo, + rayCallback.m_rayDirectionInverse, + rayCallback.m_signs, + rayCallback.m_lambda_max, + aabbMin, + aabbMax, + *stack, + callback); + + m_sets[1].rayTestInternal(m_sets[1].m_root, + rayFrom, + rayTo, + rayCallback.m_rayDirectionInverse, + rayCallback.m_signs, + rayCallback.m_lambda_max, + aabbMin, + aabbMax, + *stack, + callback); +} + +struct BroadphaseAabbTester : btDbvt::ICollide +{ + btBroadphaseAabbCallback& m_aabbCallback; + BroadphaseAabbTester(btBroadphaseAabbCallback& orgCallback) + : m_aabbCallback(orgCallback) + { + } + void Process(const btDbvtNode* leaf) + { + btDbvtProxy* proxy = (btDbvtProxy*)leaf->data; + m_aabbCallback.process(proxy); + } +}; + +void btDbvtBroadphase::aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& aabbCallback) +{ + BroadphaseAabbTester callback(aabbCallback); + + const ATTRIBUTE_ALIGNED16(btDbvtVolume) bounds = btDbvtVolume::FromMM(aabbMin, aabbMax); + //process all children, that overlap with the given AABB bounds + m_sets[0].collideTV(m_sets[0].m_root, bounds, callback); + m_sets[1].collideTV(m_sets[1].m_root, bounds, callback); +} + +// +void btDbvtBroadphase::setAabb(btBroadphaseProxy* absproxy, + const btVector3& aabbMin, + const btVector3& aabbMax, + btDispatcher* /*dispatcher*/) +{ + btDbvtProxy* proxy = (btDbvtProxy*)absproxy; + ATTRIBUTE_ALIGNED16(btDbvtVolume) + aabb = btDbvtVolume::FromMM(aabbMin, aabbMax); +#if DBVT_BP_PREVENTFALSEUPDATE + if (NotEqual(aabb, proxy->leaf->volume)) +#endif + { + bool docollide = false; + if (proxy->stage == STAGECOUNT) + { /* fixed -> dynamic set */ + m_sets[1].remove(proxy->leaf); + proxy->leaf = m_sets[0].insert(aabb, proxy); + docollide = true; + } + else + { /* dynamic set */ + ++m_updates_call; + if (Intersect(proxy->leaf->volume, aabb)) + { /* Moving */ + + const btVector3 delta = aabbMin - proxy->m_aabbMin; + btVector3 velocity(((proxy->m_aabbMax - proxy->m_aabbMin) / 2) * m_prediction); + if (delta[0] < 0) velocity[0] = -velocity[0]; + if (delta[1] < 0) velocity[1] = -velocity[1]; + if (delta[2] < 0) velocity[2] = -velocity[2]; + if ( + m_sets[0].update(proxy->leaf, aabb, velocity, gDbvtMargin) + + ) + { + ++m_updates_done; + docollide = true; + } + } + else + { /* Teleporting */ + m_sets[0].update(proxy->leaf, aabb); + ++m_updates_done; + docollide = true; + } + } + listremove(proxy, m_stageRoots[proxy->stage]); + proxy->m_aabbMin = aabbMin; + proxy->m_aabbMax = aabbMax; + proxy->stage = m_stageCurrent; + listappend(proxy, m_stageRoots[m_stageCurrent]); + if (docollide) + { + m_needcleanup = true; + if (!m_deferedcollide) + { + btDbvtTreeCollider collider(this); + m_sets[1].collideTTpersistentStack(m_sets[1].m_root, proxy->leaf, collider); + m_sets[0].collideTTpersistentStack(m_sets[0].m_root, proxy->leaf, collider); + } + } + } +} + +// +void btDbvtBroadphase::setAabbForceUpdate(btBroadphaseProxy* absproxy, + const btVector3& aabbMin, + const btVector3& aabbMax, + btDispatcher* /*dispatcher*/) +{ + btDbvtProxy* proxy = (btDbvtProxy*)absproxy; + ATTRIBUTE_ALIGNED16(btDbvtVolume) + aabb = btDbvtVolume::FromMM(aabbMin, aabbMax); + bool docollide = false; + if (proxy->stage == STAGECOUNT) + { /* fixed -> dynamic set */ + m_sets[1].remove(proxy->leaf); + proxy->leaf = m_sets[0].insert(aabb, proxy); + docollide = true; + } + else + { /* dynamic set */ + ++m_updates_call; + /* Teleporting */ + m_sets[0].update(proxy->leaf, aabb); + ++m_updates_done; + docollide = true; + } + listremove(proxy, m_stageRoots[proxy->stage]); + proxy->m_aabbMin = aabbMin; + proxy->m_aabbMax = aabbMax; + proxy->stage = m_stageCurrent; + listappend(proxy, m_stageRoots[m_stageCurrent]); + if (docollide) + { + m_needcleanup = true; + if (!m_deferedcollide) + { + btDbvtTreeCollider collider(this); + m_sets[1].collideTTpersistentStack(m_sets[1].m_root, proxy->leaf, collider); + m_sets[0].collideTTpersistentStack(m_sets[0].m_root, proxy->leaf, collider); + } + } +} + +// +void btDbvtBroadphase::calculateOverlappingPairs(btDispatcher* dispatcher) +{ + collide(dispatcher); +#if DBVT_BP_PROFILE + if (0 == (m_pid % DBVT_BP_PROFILING_RATE)) + { + printf("fixed(%u) dynamics(%u) pairs(%u)\r\n", m_sets[1].m_leaves, m_sets[0].m_leaves, m_paircache->getNumOverlappingPairs()); + unsigned int total = m_profiling.m_total; + if (total <= 0) total = 1; + printf("ddcollide: %u%% (%uus)\r\n", (50 + m_profiling.m_ddcollide * 100) / total, m_profiling.m_ddcollide / DBVT_BP_PROFILING_RATE); + printf("fdcollide: %u%% (%uus)\r\n", (50 + m_profiling.m_fdcollide * 100) / total, m_profiling.m_fdcollide / DBVT_BP_PROFILING_RATE); + printf("cleanup: %u%% (%uus)\r\n", (50 + m_profiling.m_cleanup * 100) / total, m_profiling.m_cleanup / DBVT_BP_PROFILING_RATE); + printf("total: %uus\r\n", total / DBVT_BP_PROFILING_RATE); + const unsigned long sum = m_profiling.m_ddcollide + + m_profiling.m_fdcollide + + m_profiling.m_cleanup; + printf("leaked: %u%% (%uus)\r\n", 100 - ((50 + sum * 100) / total), (total - sum) / DBVT_BP_PROFILING_RATE); + printf("job counts: %u%%\r\n", (m_profiling.m_jobcount * 100) / ((m_sets[0].m_leaves + m_sets[1].m_leaves) * DBVT_BP_PROFILING_RATE)); + clear(m_profiling); + m_clock.reset(); + } +#endif + + performDeferredRemoval(dispatcher); +} + +void btDbvtBroadphase::performDeferredRemoval(btDispatcher* dispatcher) +{ + if (m_paircache->hasDeferredRemoval()) + { + btBroadphasePairArray& overlappingPairArray = m_paircache->getOverlappingPairArray(); + + //perform a sort, to find duplicates and to sort 'invalid' pairs to the end + overlappingPairArray.quickSort(btBroadphasePairSortPredicate()); + + int invalidPair = 0; + + int i; + + btBroadphasePair previousPair; + previousPair.m_pProxy0 = 0; + previousPair.m_pProxy1 = 0; + previousPair.m_algorithm = 0; + + for (i = 0; i < overlappingPairArray.size(); i++) + { + btBroadphasePair& pair = overlappingPairArray[i]; + + bool isDuplicate = (pair == previousPair); + + previousPair = pair; + + bool needsRemoval = false; + + if (!isDuplicate) + { + //important to perform AABB check that is consistent with the broadphase + btDbvtProxy* pa = (btDbvtProxy*)pair.m_pProxy0; + btDbvtProxy* pb = (btDbvtProxy*)pair.m_pProxy1; + bool hasOverlap = Intersect(pa->leaf->volume, pb->leaf->volume); + + if (hasOverlap) + { + needsRemoval = false; + } + else + { + needsRemoval = true; + } + } + else + { + //remove duplicate + needsRemoval = true; + //should have no algorithm + btAssert(!pair.m_algorithm); + } + + if (needsRemoval) + { + m_paircache->cleanOverlappingPair(pair, dispatcher); + + pair.m_pProxy0 = 0; + pair.m_pProxy1 = 0; + invalidPair++; + } + } + + //perform a sort, to sort 'invalid' pairs to the end + overlappingPairArray.quickSort(btBroadphasePairSortPredicate()); + overlappingPairArray.resize(overlappingPairArray.size() - invalidPair); + } +} + +// +void btDbvtBroadphase::collide(btDispatcher* dispatcher) +{ + /*printf("---------------------------------------------------------\n"); + printf("m_sets[0].m_leaves=%d\n",m_sets[0].m_leaves); + printf("m_sets[1].m_leaves=%d\n",m_sets[1].m_leaves); + printf("numPairs = %d\n",getOverlappingPairCache()->getNumOverlappingPairs()); + { + int i; + for (i=0;igetNumOverlappingPairs();i++) + { + printf("pair[%d]=(%d,%d),",i,getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy0->getUid(), + getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy1->getUid()); + } + printf("\n"); + } +*/ + + SPC(m_profiling.m_total); + /* optimize */ + m_sets[0].optimizeIncremental(1 + (m_sets[0].m_leaves * m_dupdates) / 100); + if (m_fixedleft) + { + const int count = 1 + (m_sets[1].m_leaves * m_fupdates) / 100; + m_sets[1].optimizeIncremental(1 + (m_sets[1].m_leaves * m_fupdates) / 100); + m_fixedleft = btMax(0, m_fixedleft - count); + } + /* dynamic -> fixed set */ + m_stageCurrent = (m_stageCurrent + 1) % STAGECOUNT; + btDbvtProxy* current = m_stageRoots[m_stageCurrent]; + if (current) + { +#if DBVT_BP_ACCURATESLEEPING + btDbvtTreeCollider collider(this); +#endif + do + { + btDbvtProxy* next = current->links[1]; + listremove(current, m_stageRoots[current->stage]); + listappend(current, m_stageRoots[STAGECOUNT]); +#if DBVT_BP_ACCURATESLEEPING + m_paircache->removeOverlappingPairsContainingProxy(current, dispatcher); + collider.proxy = current; + btDbvt::collideTV(m_sets[0].m_root, current->aabb, collider); + btDbvt::collideTV(m_sets[1].m_root, current->aabb, collider); +#endif + m_sets[0].remove(current->leaf); + ATTRIBUTE_ALIGNED16(btDbvtVolume) + curAabb = btDbvtVolume::FromMM(current->m_aabbMin, current->m_aabbMax); + current->leaf = m_sets[1].insert(curAabb, current); + current->stage = STAGECOUNT; + current = next; + } while (current); + m_fixedleft = m_sets[1].m_leaves; + m_needcleanup = true; + } + /* collide dynamics */ + { + btDbvtTreeCollider collider(this); + if (m_deferedcollide) + { + SPC(m_profiling.m_fdcollide); + m_sets[0].collideTTpersistentStack(m_sets[0].m_root, m_sets[1].m_root, collider); + } + if (m_deferedcollide) + { + SPC(m_profiling.m_ddcollide); + m_sets[0].collideTTpersistentStack(m_sets[0].m_root, m_sets[0].m_root, collider); + } + } + /* clean up */ + if (m_needcleanup) + { + SPC(m_profiling.m_cleanup); + btBroadphasePairArray& pairs = m_paircache->getOverlappingPairArray(); + if (pairs.size() > 0) + { + int ni = btMin(pairs.size(), btMax(m_newpairs, (pairs.size() * m_cupdates) / 100)); + for (int i = 0; i < ni; ++i) + { + btBroadphasePair& p = pairs[(m_cid + i) % pairs.size()]; + btDbvtProxy* pa = (btDbvtProxy*)p.m_pProxy0; + btDbvtProxy* pb = (btDbvtProxy*)p.m_pProxy1; + if (!Intersect(pa->leaf->volume, pb->leaf->volume)) + { +#if DBVT_BP_SORTPAIRS + if (pa->m_uniqueId > pb->m_uniqueId) + btSwap(pa, pb); +#endif + m_paircache->removeOverlappingPair(pa, pb, dispatcher); + --ni; + --i; + } + } + if (pairs.size() > 0) + m_cid = (m_cid + ni) % pairs.size(); + else + m_cid = 0; + } + } + ++m_pid; + m_newpairs = 1; + m_needcleanup = false; + if (m_updates_call > 0) + { + m_updates_ratio = m_updates_done / (btScalar)m_updates_call; + } + else + { + m_updates_ratio = 0; + } + m_updates_done /= 2; + m_updates_call /= 2; +} + +// +void btDbvtBroadphase::optimize() +{ + m_sets[0].optimizeTopDown(); + m_sets[1].optimizeTopDown(); +} + +// +btOverlappingPairCache* btDbvtBroadphase::getOverlappingPairCache() +{ + return (m_paircache); +} + +// +const btOverlappingPairCache* btDbvtBroadphase::getOverlappingPairCache() const +{ + return (m_paircache); +} + +// +void btDbvtBroadphase::getBroadphaseAabb(btVector3& aabbMin, btVector3& aabbMax) const +{ + ATTRIBUTE_ALIGNED16(btDbvtVolume) + bounds; + + if (!m_sets[0].empty()) + if (!m_sets[1].empty()) + Merge(m_sets[0].m_root->volume, + m_sets[1].m_root->volume, bounds); + else + bounds = m_sets[0].m_root->volume; + else if (!m_sets[1].empty()) + bounds = m_sets[1].m_root->volume; + else + bounds = btDbvtVolume::FromCR(btVector3(0, 0, 0), 0); + aabbMin = bounds.Mins(); + aabbMax = bounds.Maxs(); +} + +void btDbvtBroadphase::resetPool(btDispatcher* dispatcher) +{ + int totalObjects = m_sets[0].m_leaves + m_sets[1].m_leaves; + if (!totalObjects) + { + //reset internal dynamic tree data structures + m_sets[0].clear(); + m_sets[1].clear(); + + m_deferedcollide = false; + m_needcleanup = true; + m_stageCurrent = 0; + m_fixedleft = 0; + m_fupdates = 1; + m_dupdates = 0; + m_cupdates = 10; + m_newpairs = 1; + m_updates_call = 0; + m_updates_done = 0; + m_updates_ratio = 0; + + m_gid = 0; + m_pid = 0; + m_cid = 0; + for (int i = 0; i <= STAGECOUNT; ++i) + { + m_stageRoots[i] = 0; + } + } +} + +// +void btDbvtBroadphase::printStats() +{ +} + +// +#if DBVT_BP_ENABLE_BENCHMARK + +struct btBroadphaseBenchmark +{ + struct Experiment + { + const char* name; + int object_count; + int update_count; + int spawn_count; + int iterations; + btScalar speed; + btScalar amplitude; + }; + struct Object + { + btVector3 center; + btVector3 extents; + btBroadphaseProxy* proxy; + btScalar time; + void update(btScalar speed, btScalar amplitude, btBroadphaseInterface* pbi) + { + time += speed; + center[0] = btCos(time * (btScalar)2.17) * amplitude + + btSin(time) * amplitude / 2; + center[1] = btCos(time * (btScalar)1.38) * amplitude + + btSin(time) * amplitude; + center[2] = btSin(time * (btScalar)0.777) * amplitude; + pbi->setAabb(proxy, center - extents, center + extents, 0); + } + }; + static int UnsignedRand(int range = RAND_MAX - 1) { return (rand() % (range + 1)); } + static btScalar UnitRand() { return (UnsignedRand(16384) / (btScalar)16384); } + static void OutputTime(const char* name, btClock& c, unsigned count = 0) + { + const unsigned long us = c.getTimeMicroseconds(); + const unsigned long ms = (us + 500) / 1000; + const btScalar sec = us / (btScalar)(1000 * 1000); + if (count > 0) + printf("%s : %u us (%u ms), %.2f/s\r\n", name, us, ms, count / sec); + else + printf("%s : %u us (%u ms)\r\n", name, us, ms); + } +}; + +void btDbvtBroadphase::benchmark(btBroadphaseInterface* pbi) +{ + static const btBroadphaseBenchmark::Experiment experiments[] = + { + {"1024o.10%", 1024, 10, 0, 8192, (btScalar)0.005, (btScalar)100}, + /*{"4096o.10%",4096,10,0,8192,(btScalar)0.005,(btScalar)100}, + {"8192o.10%",8192,10,0,8192,(btScalar)0.005,(btScalar)100},*/ + }; + static const int nexperiments = sizeof(experiments) / sizeof(experiments[0]); + btAlignedObjectArray objects; + btClock wallclock; + /* Begin */ + for (int iexp = 0; iexp < nexperiments; ++iexp) + { + const btBroadphaseBenchmark::Experiment& experiment = experiments[iexp]; + const int object_count = experiment.object_count; + const int update_count = (object_count * experiment.update_count) / 100; + const int spawn_count = (object_count * experiment.spawn_count) / 100; + const btScalar speed = experiment.speed; + const btScalar amplitude = experiment.amplitude; + printf("Experiment #%u '%s':\r\n", iexp, experiment.name); + printf("\tObjects: %u\r\n", object_count); + printf("\tUpdate: %u\r\n", update_count); + printf("\tSpawn: %u\r\n", spawn_count); + printf("\tSpeed: %f\r\n", speed); + printf("\tAmplitude: %f\r\n", amplitude); + srand(180673); + /* Create objects */ + wallclock.reset(); + objects.reserve(object_count); + for (int i = 0; i < object_count; ++i) + { + btBroadphaseBenchmark::Object* po = new btBroadphaseBenchmark::Object(); + po->center[0] = btBroadphaseBenchmark::UnitRand() * 50; + po->center[1] = btBroadphaseBenchmark::UnitRand() * 50; + po->center[2] = btBroadphaseBenchmark::UnitRand() * 50; + po->extents[0] = btBroadphaseBenchmark::UnitRand() * 2 + 2; + po->extents[1] = btBroadphaseBenchmark::UnitRand() * 2 + 2; + po->extents[2] = btBroadphaseBenchmark::UnitRand() * 2 + 2; + po->time = btBroadphaseBenchmark::UnitRand() * 2000; + po->proxy = pbi->createProxy(po->center - po->extents, po->center + po->extents, 0, po, 1, 1, 0, 0); + objects.push_back(po); + } + btBroadphaseBenchmark::OutputTime("\tInitialization", wallclock); + /* First update */ + wallclock.reset(); + for (int i = 0; i < objects.size(); ++i) + { + objects[i]->update(speed, amplitude, pbi); + } + btBroadphaseBenchmark::OutputTime("\tFirst update", wallclock); + /* Updates */ + wallclock.reset(); + for (int i = 0; i < experiment.iterations; ++i) + { + for (int j = 0; j < update_count; ++j) + { + objects[j]->update(speed, amplitude, pbi); + } + pbi->calculateOverlappingPairs(0); + } + btBroadphaseBenchmark::OutputTime("\tUpdate", wallclock, experiment.iterations); + /* Clean up */ + wallclock.reset(); + for (int i = 0; i < objects.size(); ++i) + { + pbi->destroyProxy(objects[i]->proxy, 0); + delete objects[i]; + } + objects.resize(0); + btBroadphaseBenchmark::OutputTime("\tRelease", wallclock); + } +} +#else +void btDbvtBroadphase::benchmark(btBroadphaseInterface*) +{ +} +#endif + +#if DBVT_BP_PROFILE +#undef SPC +#endif diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp.i new file mode 100644 index 00000000..0b2dac67 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp ---------------- + +%include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp" + +%{ +#include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h new file mode 100644 index 00000000..a71feef5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h @@ -0,0 +1,146 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///btDbvtBroadphase implementation by Nathanael Presson +#ifndef BT_DBVT_BROADPHASE_H +#define BT_DBVT_BROADPHASE_H + +#include "BulletCollision/BroadphaseCollision/btDbvt.h" +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" + +// +// Compile time config +// + +#define DBVT_BP_PROFILE 0 +//#define DBVT_BP_SORTPAIRS 1 +#define DBVT_BP_PREVENTFALSEUPDATE 0 +#define DBVT_BP_ACCURATESLEEPING 0 +#define DBVT_BP_ENABLE_BENCHMARK 0 +//#define DBVT_BP_MARGIN (btScalar)0.05 +extern btScalar gDbvtMargin; + +#if DBVT_BP_PROFILE +#define DBVT_BP_PROFILING_RATE 256 +#include "LinearMath/btQuickprof.h" +#endif + +// +// btDbvtProxy +// +struct btDbvtProxy : btBroadphaseProxy +{ + /* Fields */ + //btDbvtAabbMm aabb; + btDbvtNode* leaf; + btDbvtProxy* links[2]; + int stage; + /* ctor */ + btDbvtProxy(const btVector3& aabbMin, const btVector3& aabbMax, void* userPtr, int collisionFilterGroup, int collisionFilterMask) : btBroadphaseProxy(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask) + { + links[0] = links[1] = 0; + } +}; + +typedef btAlignedObjectArray btDbvtProxyArray; + +///The btDbvtBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see btDbvt). +///One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other. +///This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases btAxisSweep3 and bt32BitAxisSweep3. +struct btDbvtBroadphase : btBroadphaseInterface +{ + /* Config */ + enum + { + DYNAMIC_SET = 0, /* Dynamic set index */ + FIXED_SET = 1, /* Fixed set index */ + STAGECOUNT = 2 /* Number of stages */ + }; + /* Fields */ + btDbvt m_sets[2]; // Dbvt sets + btDbvtProxy* m_stageRoots[STAGECOUNT + 1]; // Stages list + btOverlappingPairCache* m_paircache; // Pair cache + btScalar m_prediction; // Velocity prediction + int m_stageCurrent; // Current stage + int m_fupdates; // % of fixed updates per frame + int m_dupdates; // % of dynamic updates per frame + int m_cupdates; // % of cleanup updates per frame + int m_newpairs; // Number of pairs created + int m_fixedleft; // Fixed optimization left + unsigned m_updates_call; // Number of updates call + unsigned m_updates_done; // Number of updates done + btScalar m_updates_ratio; // m_updates_done/m_updates_call + int m_pid; // Parse id + int m_cid; // Cleanup index + int m_gid; // Gen id + bool m_releasepaircache; // Release pair cache on delete + bool m_deferedcollide; // Defere dynamic/static collision to collide call + bool m_needcleanup; // Need to run cleanup? + btAlignedObjectArray > m_rayTestStacks; +#if DBVT_BP_PROFILE + btClock m_clock; + struct + { + unsigned long m_total; + unsigned long m_ddcollide; + unsigned long m_fdcollide; + unsigned long m_cleanup; + unsigned long m_jobcount; + } m_profiling; +#endif + /* Methods */ + btDbvtBroadphase(btOverlappingPairCache* paircache = 0); + ~btDbvtBroadphase(); + void collide(btDispatcher* dispatcher); + void optimize(); + + /* btBroadphaseInterface Implementation */ + btBroadphaseProxy* createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher); + virtual void destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher); + virtual void setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher); + virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin = btVector3(0, 0, 0), const btVector3& aabbMax = btVector3(0, 0, 0)); + virtual void aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback); + + virtual void getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const; + virtual void calculateOverlappingPairs(btDispatcher* dispatcher); + virtual btOverlappingPairCache* getOverlappingPairCache(); + virtual const btOverlappingPairCache* getOverlappingPairCache() const; + virtual void getBroadphaseAabb(btVector3& aabbMin, btVector3& aabbMax) const; + virtual void printStats(); + + ///reset broadphase internal structures, to ensure determinism/reproducability + virtual void resetPool(btDispatcher* dispatcher); + + void performDeferredRemoval(btDispatcher* dispatcher); + + void setVelocityPrediction(btScalar prediction) + { + m_prediction = prediction; + } + btScalar getVelocityPrediction() const + { + return m_prediction; + } + + ///this setAabbForceUpdate is similar to setAabb but always forces the aabb update. + ///it is not part of the btBroadphaseInterface but specific to btDbvtBroadphase. + ///it bypasses certain optimizations that prevent aabb updates (when the aabb shrinks), see + ///http://code.google.com/p/bullet/issues/detail?id=223 + void setAabbForceUpdate(btBroadphaseProxy* absproxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* /*dispatcher*/); + + static void benchmark(btBroadphaseInterface*); +}; + +#endif diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h.i new file mode 100644 index 00000000..510d90cf --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btDbvtBroadphase.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.cpp b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.cpp new file mode 100644 index 00000000..e71cb7da --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.cpp @@ -0,0 +1,20 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btDispatcher.h" + +btDispatcher::~btDispatcher() +{ +} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.cpp.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.cpp.i new file mode 100644 index 00000000..eaa9c4a2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btDispatcher.cpp ---------------- + +%include "BulletCollision/BroadphaseCollision/btDispatcher.cpp" + +%{ +#include "BulletCollision/BroadphaseCollision/btDispatcher.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.h new file mode 100644 index 00000000..d59441cf --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.h @@ -0,0 +1,110 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_DISPATCHER_H +#define BT_DISPATCHER_H +#include "LinearMath/btScalar.h" + +class btCollisionAlgorithm; +struct btBroadphaseProxy; +class btRigidBody; +class btCollisionObject; +class btOverlappingPairCache; +struct btCollisionObjectWrapper; + +class btPersistentManifold; +class btPoolAllocator; + +struct btDispatcherInfo +{ + enum DispatchFunc + { + DISPATCH_DISCRETE = 1, + DISPATCH_CONTINUOUS + }; + btDispatcherInfo() + : m_timeStep(btScalar(0.)), + m_stepCount(0), + m_dispatchFunc(DISPATCH_DISCRETE), + m_timeOfImpact(btScalar(1.)), + m_useContinuous(true), + m_debugDraw(0), + m_enableSatConvex(false), + m_enableSPU(true), + m_useEpa(true), + m_allowedCcdPenetration(btScalar(0.04)), + m_useConvexConservativeDistanceUtil(false), + m_convexConservativeDistanceThreshold(0.0f), + m_deterministicOverlappingPairs(false) + { + } + btScalar m_timeStep; + int m_stepCount; + int m_dispatchFunc; + mutable btScalar m_timeOfImpact; + bool m_useContinuous; + class btIDebugDraw* m_debugDraw; + bool m_enableSatConvex; + bool m_enableSPU; + bool m_useEpa; + btScalar m_allowedCcdPenetration; + bool m_useConvexConservativeDistanceUtil; + btScalar m_convexConservativeDistanceThreshold; + bool m_deterministicOverlappingPairs; +}; + +enum ebtDispatcherQueryType +{ + BT_CONTACT_POINT_ALGORITHMS = 1, + BT_CLOSEST_POINT_ALGORITHMS = 2 +}; + +///The btDispatcher interface class can be used in combination with broadphase to dispatch calculations for overlapping pairs. +///For example for pairwise collision detection, calculating contact points stored in btPersistentManifold or user callbacks (game logic). +class btDispatcher +{ +public: + virtual ~btDispatcher(); + + virtual btCollisionAlgorithm* findAlgorithm(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btPersistentManifold* sharedManifold, ebtDispatcherQueryType queryType) = 0; + + virtual btPersistentManifold* getNewManifold(const btCollisionObject* b0, const btCollisionObject* b1) = 0; + + virtual void releaseManifold(btPersistentManifold* manifold) = 0; + + virtual void clearManifold(btPersistentManifold* manifold) = 0; + + virtual bool needsCollision(const btCollisionObject* body0, const btCollisionObject* body1) = 0; + + virtual bool needsResponse(const btCollisionObject* body0, const btCollisionObject* body1) = 0; + + virtual void dispatchAllCollisionPairs(btOverlappingPairCache* pairCache, const btDispatcherInfo& dispatchInfo, btDispatcher* dispatcher) = 0; + + virtual int getNumManifolds() const = 0; + + virtual btPersistentManifold* getManifoldByIndexInternal(int index) = 0; + + virtual btPersistentManifold** getInternalManifoldPointer() = 0; + + virtual btPoolAllocator* getInternalManifoldPool() = 0; + + virtual const btPoolAllocator* getInternalManifoldPool() const = 0; + + virtual void* allocateCollisionAlgorithm(int size) = 0; + + virtual void freeCollisionAlgorithm(void* ptr) = 0; +}; + +#endif //BT_DISPATCHER_H diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.h.i new file mode 100644 index 00000000..008163c6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btDispatcher.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btDispatcher.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btDispatcher.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btDispatcher.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp new file mode 100644 index 00000000..802848e1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp @@ -0,0 +1,611 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btOverlappingPairCache.h" + +#include "btDispatcher.h" +#include "btCollisionAlgorithm.h" +#include "LinearMath/btAabbUtil2.h" + +#include + +btHashedOverlappingPairCache::btHashedOverlappingPairCache() : m_overlapFilterCallback(0), + m_ghostPairCallback(0) +{ + int initialAllocatedSize = 2; + m_overlappingPairArray.reserve(initialAllocatedSize); + growTables(); +} + +btHashedOverlappingPairCache::~btHashedOverlappingPairCache() +{ +} + +void btHashedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair, btDispatcher* dispatcher) +{ + if (pair.m_algorithm && dispatcher) + { + { + pair.m_algorithm->~btCollisionAlgorithm(); + dispatcher->freeCollisionAlgorithm(pair.m_algorithm); + pair.m_algorithm = 0; + } + } +} + +void btHashedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy, btDispatcher* dispatcher) +{ + class CleanPairCallback : public btOverlapCallback + { + btBroadphaseProxy* m_cleanProxy; + btOverlappingPairCache* m_pairCache; + btDispatcher* m_dispatcher; + + public: + CleanPairCallback(btBroadphaseProxy* cleanProxy, btOverlappingPairCache* pairCache, btDispatcher* dispatcher) + : m_cleanProxy(cleanProxy), + m_pairCache(pairCache), + m_dispatcher(dispatcher) + { + } + virtual bool processOverlap(btBroadphasePair& pair) + { + if ((pair.m_pProxy0 == m_cleanProxy) || + (pair.m_pProxy1 == m_cleanProxy)) + { + m_pairCache->cleanOverlappingPair(pair, m_dispatcher); + } + return false; + } + }; + + CleanPairCallback cleanPairs(proxy, this, dispatcher); + + processAllOverlappingPairs(&cleanPairs, dispatcher); +} + +void btHashedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher) +{ + class RemovePairCallback : public btOverlapCallback + { + btBroadphaseProxy* m_obsoleteProxy; + + public: + RemovePairCallback(btBroadphaseProxy* obsoleteProxy) + : m_obsoleteProxy(obsoleteProxy) + { + } + virtual bool processOverlap(btBroadphasePair& pair) + { + return ((pair.m_pProxy0 == m_obsoleteProxy) || + (pair.m_pProxy1 == m_obsoleteProxy)); + } + }; + + RemovePairCallback removeCallback(proxy); + + processAllOverlappingPairs(&removeCallback, dispatcher); +} + +btBroadphasePair* btHashedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) +{ + if (proxy0->m_uniqueId > proxy1->m_uniqueId) + btSwap(proxy0, proxy1); + int proxyId1 = proxy0->getUid(); + int proxyId2 = proxy1->getUid(); + + /*if (proxyId1 > proxyId2) + btSwap(proxyId1, proxyId2);*/ + + int hash = static_cast(getHash(static_cast(proxyId1), static_cast(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); + + if (hash >= m_hashTable.size()) + { + return NULL; + } + + int index = m_hashTable[hash]; + while (index != BT_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false) + { + index = m_next[index]; + } + + if (index == BT_NULL_PAIR) + { + return NULL; + } + + btAssert(index < m_overlappingPairArray.size()); + + return &m_overlappingPairArray[index]; +} + +//#include + +void btHashedOverlappingPairCache::growTables() +{ + int newCapacity = m_overlappingPairArray.capacity(); + + if (m_hashTable.size() < newCapacity) + { + //grow hashtable and next table + int curHashtableSize = m_hashTable.size(); + + m_hashTable.resize(newCapacity); + m_next.resize(newCapacity); + + int i; + + for (i = 0; i < newCapacity; ++i) + { + m_hashTable[i] = BT_NULL_PAIR; + } + for (i = 0; i < newCapacity; ++i) + { + m_next[i] = BT_NULL_PAIR; + } + + for (i = 0; i < curHashtableSize; i++) + { + const btBroadphasePair& pair = m_overlappingPairArray[i]; + int proxyId1 = pair.m_pProxy0->getUid(); + int proxyId2 = pair.m_pProxy1->getUid(); + /*if (proxyId1 > proxyId2) + btSwap(proxyId1, proxyId2);*/ + int hashValue = static_cast(getHash(static_cast(proxyId1), static_cast(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); // New hash value with new mask + m_next[i] = m_hashTable[hashValue]; + m_hashTable[hashValue] = i; + } + } +} + +btBroadphasePair* btHashedOverlappingPairCache::internalAddPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) +{ + if (proxy0->m_uniqueId > proxy1->m_uniqueId) + btSwap(proxy0, proxy1); + int proxyId1 = proxy0->getUid(); + int proxyId2 = proxy1->getUid(); + + /*if (proxyId1 > proxyId2) + btSwap(proxyId1, proxyId2);*/ + + int hash = static_cast(getHash(static_cast(proxyId1), static_cast(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); // New hash value with new mask + + btBroadphasePair* pair = internalFindPair(proxy0, proxy1, hash); + if (pair != NULL) + { + return pair; + } + /*for(int i=0;i%u\r\n",proxyId1,proxyId2); + internalFindPair(proxy0, proxy1, hash); + } + }*/ + int count = m_overlappingPairArray.size(); + int oldCapacity = m_overlappingPairArray.capacity(); + void* mem = &m_overlappingPairArray.expandNonInitializing(); + + //this is where we add an actual pair, so also call the 'ghost' + if (m_ghostPairCallback) + m_ghostPairCallback->addOverlappingPair(proxy0, proxy1); + + int newCapacity = m_overlappingPairArray.capacity(); + + if (oldCapacity < newCapacity) + { + growTables(); + //hash with new capacity + hash = static_cast(getHash(static_cast(proxyId1), static_cast(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); + } + + pair = new (mem) btBroadphasePair(*proxy0, *proxy1); + // pair->m_pProxy0 = proxy0; + // pair->m_pProxy1 = proxy1; + pair->m_algorithm = 0; + pair->m_internalTmpValue = 0; + + m_next[count] = m_hashTable[hash]; + m_hashTable[hash] = count; + + return pair; +} + +void* btHashedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher) +{ + if (proxy0->m_uniqueId > proxy1->m_uniqueId) + btSwap(proxy0, proxy1); + int proxyId1 = proxy0->getUid(); + int proxyId2 = proxy1->getUid(); + + /*if (proxyId1 > proxyId2) + btSwap(proxyId1, proxyId2);*/ + + int hash = static_cast(getHash(static_cast(proxyId1), static_cast(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); + + btBroadphasePair* pair = internalFindPair(proxy0, proxy1, hash); + if (pair == NULL) + { + return 0; + } + + cleanOverlappingPair(*pair, dispatcher); + + void* userData = pair->m_internalInfo1; + + btAssert(pair->m_pProxy0->getUid() == proxyId1); + btAssert(pair->m_pProxy1->getUid() == proxyId2); + + int pairIndex = int(pair - &m_overlappingPairArray[0]); + btAssert(pairIndex < m_overlappingPairArray.size()); + + // Remove the pair from the hash table. + int index = m_hashTable[hash]; + btAssert(index != BT_NULL_PAIR); + + int previous = BT_NULL_PAIR; + while (index != pairIndex) + { + previous = index; + index = m_next[index]; + } + + if (previous != BT_NULL_PAIR) + { + btAssert(m_next[previous] == pairIndex); + m_next[previous] = m_next[pairIndex]; + } + else + { + m_hashTable[hash] = m_next[pairIndex]; + } + + // We now move the last pair into spot of the + // pair being removed. We need to fix the hash + // table indices to support the move. + + int lastPairIndex = m_overlappingPairArray.size() - 1; + + if (m_ghostPairCallback) + m_ghostPairCallback->removeOverlappingPair(proxy0, proxy1, dispatcher); + + // If the removed pair is the last pair, we are done. + if (lastPairIndex == pairIndex) + { + m_overlappingPairArray.pop_back(); + return userData; + } + + // Remove the last pair from the hash table. + const btBroadphasePair* last = &m_overlappingPairArray[lastPairIndex]; + /* missing swap here too, Nat. */ + int lastHash = static_cast(getHash(static_cast(last->m_pProxy0->getUid()), static_cast(last->m_pProxy1->getUid())) & (m_overlappingPairArray.capacity() - 1)); + + index = m_hashTable[lastHash]; + btAssert(index != BT_NULL_PAIR); + + previous = BT_NULL_PAIR; + while (index != lastPairIndex) + { + previous = index; + index = m_next[index]; + } + + if (previous != BT_NULL_PAIR) + { + btAssert(m_next[previous] == lastPairIndex); + m_next[previous] = m_next[lastPairIndex]; + } + else + { + m_hashTable[lastHash] = m_next[lastPairIndex]; + } + + // Copy the last pair into the remove pair's spot. + m_overlappingPairArray[pairIndex] = m_overlappingPairArray[lastPairIndex]; + + // Insert the last pair into the hash table + m_next[pairIndex] = m_hashTable[lastHash]; + m_hashTable[lastHash] = pairIndex; + + m_overlappingPairArray.pop_back(); + + return userData; +} +//#include +#include "LinearMath/btQuickprof.h" +void btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback, btDispatcher* dispatcher) +{ +//\1("btHashedOverlappingPairCache::processAllOverlappingPairs"); + int i; + + // printf("m_overlappingPairArray.size()=%d\n",m_overlappingPairArray.size()); + for (i = 0; i < m_overlappingPairArray.size();) + { + btBroadphasePair* pair = &m_overlappingPairArray[i]; + if (callback->processOverlap(*pair)) + { + removeOverlappingPair(pair->m_pProxy0, pair->m_pProxy1, dispatcher); + } + else + { + i++; + } + } +} + +struct MyPairIndex +{ + int m_orgIndex; + int m_uidA0; + int m_uidA1; +}; + +class MyPairIndeSortPredicate +{ +public: + bool operator()(const MyPairIndex& a, const MyPairIndex& b) const + { + const int uidA0 = a.m_uidA0; + const int uidB0 = b.m_uidA0; + const int uidA1 = a.m_uidA1; + const int uidB1 = b.m_uidA1; + return uidA0 > uidB0 || (uidA0 == uidB0 && uidA1 > uidB1); + } +}; + +void btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback, btDispatcher* dispatcher, const struct btDispatcherInfo& dispatchInfo) +{ + if (dispatchInfo.m_deterministicOverlappingPairs) + { + btBroadphasePairArray& pa = getOverlappingPairArray(); + btAlignedObjectArray indices; + { +//\1("sortOverlappingPairs"); + indices.resize(pa.size()); + for (int i = 0; i < indices.size(); i++) + { + const btBroadphasePair& p = pa[i]; + const int uidA0 = p.m_pProxy0 ? p.m_pProxy0->m_uniqueId : -1; + const int uidA1 = p.m_pProxy1 ? p.m_pProxy1->m_uniqueId : -1; + + indices[i].m_uidA0 = uidA0; + indices[i].m_uidA1 = uidA1; + indices[i].m_orgIndex = i; + } + indices.quickSort(MyPairIndeSortPredicate()); + } + { +//\1("btHashedOverlappingPairCache::processAllOverlappingPairs"); + int i; + for (i = 0; i < indices.size();) + { + btBroadphasePair* pair = &pa[indices[i].m_orgIndex]; + if (callback->processOverlap(*pair)) + { + removeOverlappingPair(pair->m_pProxy0, pair->m_pProxy1, dispatcher); + } + else + { + i++; + } + } + } + } + else + { + processAllOverlappingPairs(callback, dispatcher); + } +} + +void btHashedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher) +{ + ///need to keep hashmap in sync with pair address, so rebuild all + btBroadphasePairArray tmpPairs; + int i; + for (i = 0; i < m_overlappingPairArray.size(); i++) + { + tmpPairs.push_back(m_overlappingPairArray[i]); + } + + for (i = 0; i < tmpPairs.size(); i++) + { + removeOverlappingPair(tmpPairs[i].m_pProxy0, tmpPairs[i].m_pProxy1, dispatcher); + } + + for (i = 0; i < m_next.size(); i++) + { + m_next[i] = BT_NULL_PAIR; + } + + tmpPairs.quickSort(btBroadphasePairSortPredicate()); + + for (i = 0; i < tmpPairs.size(); i++) + { + addOverlappingPair(tmpPairs[i].m_pProxy0, tmpPairs[i].m_pProxy1); + } +} + +void* btSortedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher) +{ + if (!hasDeferredRemoval()) + { + btBroadphasePair findPair(*proxy0, *proxy1); + + int findIndex = m_overlappingPairArray.findLinearSearch(findPair); + if (findIndex < m_overlappingPairArray.size()) + { + btBroadphasePair& pair = m_overlappingPairArray[findIndex]; + void* userData = pair.m_internalInfo1; + cleanOverlappingPair(pair, dispatcher); + if (m_ghostPairCallback) + m_ghostPairCallback->removeOverlappingPair(proxy0, proxy1, dispatcher); + + m_overlappingPairArray.swap(findIndex, m_overlappingPairArray.capacity() - 1); + m_overlappingPairArray.pop_back(); + return userData; + } + } + + return 0; +} + +btBroadphasePair* btSortedOverlappingPairCache::addOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) +{ + //don't add overlap with own + btAssert(proxy0 != proxy1); + + if (!needsBroadphaseCollision(proxy0, proxy1)) + return 0; + + void* mem = &m_overlappingPairArray.expandNonInitializing(); + btBroadphasePair* pair = new (mem) btBroadphasePair(*proxy0, *proxy1); + + if (m_ghostPairCallback) + m_ghostPairCallback->addOverlappingPair(proxy0, proxy1); + return pair; +} + +///this findPair becomes really slow. Either sort the list to speedup the query, or +///use a different solution. It is mainly used for Removing overlapping pairs. Removal could be delayed. +///we could keep a linked list in each proxy, and store pair in one of the proxies (with lowest memory address) +///Also we can use a 2D bitmap, which can be useful for a future GPU implementation +btBroadphasePair* btSortedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) +{ + if (!needsBroadphaseCollision(proxy0, proxy1)) + return 0; + + btBroadphasePair tmpPair(*proxy0, *proxy1); + int findIndex = m_overlappingPairArray.findLinearSearch(tmpPair); + + if (findIndex < m_overlappingPairArray.size()) + { + //btAssert(it != m_overlappingPairSet.end()); + btBroadphasePair* pair = &m_overlappingPairArray[findIndex]; + return pair; + } + return 0; +} + +//#include + +void btSortedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback, btDispatcher* dispatcher) +{ + int i; + + for (i = 0; i < m_overlappingPairArray.size();) + { + btBroadphasePair* pair = &m_overlappingPairArray[i]; + if (callback->processOverlap(*pair)) + { + cleanOverlappingPair(*pair, dispatcher); + pair->m_pProxy0 = 0; + pair->m_pProxy1 = 0; + m_overlappingPairArray.swap(i, m_overlappingPairArray.size() - 1); + m_overlappingPairArray.pop_back(); + } + else + { + i++; + } + } +} + +btSortedOverlappingPairCache::btSortedOverlappingPairCache() : m_blockedForChanges(false), + m_hasDeferredRemoval(true), + m_overlapFilterCallback(0), + m_ghostPairCallback(0) +{ + int initialAllocatedSize = 2; + m_overlappingPairArray.reserve(initialAllocatedSize); +} + +btSortedOverlappingPairCache::~btSortedOverlappingPairCache() +{ +} + +void btSortedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair, btDispatcher* dispatcher) +{ + if (pair.m_algorithm) + { + { + pair.m_algorithm->~btCollisionAlgorithm(); + dispatcher->freeCollisionAlgorithm(pair.m_algorithm); + pair.m_algorithm = 0; + } + } +} + +void btSortedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy, btDispatcher* dispatcher) +{ + class CleanPairCallback : public btOverlapCallback + { + btBroadphaseProxy* m_cleanProxy; + btOverlappingPairCache* m_pairCache; + btDispatcher* m_dispatcher; + + public: + CleanPairCallback(btBroadphaseProxy* cleanProxy, btOverlappingPairCache* pairCache, btDispatcher* dispatcher) + : m_cleanProxy(cleanProxy), + m_pairCache(pairCache), + m_dispatcher(dispatcher) + { + } + virtual bool processOverlap(btBroadphasePair& pair) + { + if ((pair.m_pProxy0 == m_cleanProxy) || + (pair.m_pProxy1 == m_cleanProxy)) + { + m_pairCache->cleanOverlappingPair(pair, m_dispatcher); + } + return false; + } + }; + + CleanPairCallback cleanPairs(proxy, this, dispatcher); + + processAllOverlappingPairs(&cleanPairs, dispatcher); +} + +void btSortedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher) +{ + class RemovePairCallback : public btOverlapCallback + { + btBroadphaseProxy* m_obsoleteProxy; + + public: + RemovePairCallback(btBroadphaseProxy* obsoleteProxy) + : m_obsoleteProxy(obsoleteProxy) + { + } + virtual bool processOverlap(btBroadphasePair& pair) + { + return ((pair.m_pProxy0 == m_obsoleteProxy) || + (pair.m_pProxy1 == m_obsoleteProxy)); + } + }; + + RemovePairCallback removeCallback(proxy); + + processAllOverlappingPairs(&removeCallback, dispatcher); +} + +void btSortedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher) +{ + //should already be sorted +} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp.i new file mode 100644 index 00000000..17a3e5a0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp ---------------- + +%include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp" + +%{ +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h new file mode 100644 index 00000000..1d827264 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h @@ -0,0 +1,434 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_OVERLAPPING_PAIR_CACHE_H +#define BT_OVERLAPPING_PAIR_CACHE_H + +#include "btBroadphaseInterface.h" +#include "btBroadphaseProxy.h" +#include "btOverlappingPairCallback.h" + +#include "LinearMath/btAlignedObjectArray.h" +class btDispatcher; + +typedef btAlignedObjectArray btBroadphasePairArray; + +struct btOverlapCallback +{ + virtual ~btOverlapCallback() + { + } + //return true for deletion of the pair + virtual bool processOverlap(btBroadphasePair& pair) = 0; +}; + +struct btOverlapFilterCallback +{ + virtual ~btOverlapFilterCallback() + { + } + // return true when pairs need collision + virtual bool needBroadphaseCollision(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) const = 0; +}; + +const int BT_NULL_PAIR = 0xffffffff; + +///The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases. +///The btHashedOverlappingPairCache and btSortedOverlappingPairCache classes are two implementations. +class btOverlappingPairCache : public btOverlappingPairCallback +{ +public: + virtual ~btOverlappingPairCache() {} // this is needed so we can get to the derived class destructor + + virtual btBroadphasePair* getOverlappingPairArrayPtr() = 0; + + virtual const btBroadphasePair* getOverlappingPairArrayPtr() const = 0; + + virtual btBroadphasePairArray& getOverlappingPairArray() = 0; + + virtual void cleanOverlappingPair(btBroadphasePair& pair, btDispatcher* dispatcher) = 0; + + virtual int getNumOverlappingPairs() const = 0; + virtual bool needsBroadphaseCollision(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1) const = 0; + virtual btOverlapFilterCallback* getOverlapFilterCallback() = 0; + virtual void cleanProxyFromPairs(btBroadphaseProxy* proxy, btDispatcher* dispatcher) = 0; + + virtual void setOverlapFilterCallback(btOverlapFilterCallback* callback) = 0; + + virtual void processAllOverlappingPairs(btOverlapCallback*, btDispatcher* dispatcher) = 0; + + virtual void processAllOverlappingPairs(btOverlapCallback* callback, btDispatcher* dispatcher, const struct btDispatcherInfo& /*dispatchInfo*/) + { + processAllOverlappingPairs(callback, dispatcher); + } + virtual btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) = 0; + + virtual bool hasDeferredRemoval() = 0; + + virtual void setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback) = 0; + + virtual void sortOverlappingPairs(btDispatcher* dispatcher) = 0; +}; + +/// Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com + +ATTRIBUTE_ALIGNED16(class) +btHashedOverlappingPairCache : public btOverlappingPairCache +{ + btBroadphasePairArray m_overlappingPairArray; + btOverlapFilterCallback* m_overlapFilterCallback; + +protected: + btAlignedObjectArray m_hashTable; + btAlignedObjectArray m_next; + btOverlappingPairCallback* m_ghostPairCallback; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btHashedOverlappingPairCache(); + virtual ~btHashedOverlappingPairCache(); + + void removeOverlappingPairsContainingProxy(btBroadphaseProxy * proxy, btDispatcher * dispatcher); + + virtual void* removeOverlappingPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1, btDispatcher * dispatcher); + + SIMD_FORCE_INLINE bool needsBroadphaseCollision(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1) const + { + if (m_overlapFilterCallback) + return m_overlapFilterCallback->needBroadphaseCollision(proxy0, proxy1); + + bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0; + collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask); + + return collides; + } + + // Add a pair and return the new pair. If the pair already exists, + // no new pair is created and the old one is returned. + virtual btBroadphasePair* addOverlappingPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1) + { + if (!needsBroadphaseCollision(proxy0, proxy1)) + return 0; + + return internalAddPair(proxy0, proxy1); + } + + void cleanProxyFromPairs(btBroadphaseProxy * proxy, btDispatcher * dispatcher); + + virtual void processAllOverlappingPairs(btOverlapCallback*, btDispatcher * dispatcher); + + virtual void processAllOverlappingPairs(btOverlapCallback * callback, btDispatcher * dispatcher, const struct btDispatcherInfo& dispatchInfo); + + virtual btBroadphasePair* getOverlappingPairArrayPtr() + { + return &m_overlappingPairArray[0]; + } + + const btBroadphasePair* getOverlappingPairArrayPtr() const + { + return &m_overlappingPairArray[0]; + } + + btBroadphasePairArray& getOverlappingPairArray() + { + return m_overlappingPairArray; + } + + const btBroadphasePairArray& getOverlappingPairArray() const + { + return m_overlappingPairArray; + } + + void cleanOverlappingPair(btBroadphasePair & pair, btDispatcher * dispatcher); + + btBroadphasePair* findPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1); + + int GetCount() const { return m_overlappingPairArray.size(); } + // btBroadphasePair* GetPairs() { return m_pairs; } + + btOverlapFilterCallback* getOverlapFilterCallback() + { + return m_overlapFilterCallback; + } + + void setOverlapFilterCallback(btOverlapFilterCallback * callback) + { + m_overlapFilterCallback = callback; + } + + int getNumOverlappingPairs() const + { + return m_overlappingPairArray.size(); + } + +private: + btBroadphasePair* internalAddPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1); + + void growTables(); + + SIMD_FORCE_INLINE bool equalsPair(const btBroadphasePair& pair, int proxyId1, int proxyId2) + { + return pair.m_pProxy0->getUid() == proxyId1 && pair.m_pProxy1->getUid() == proxyId2; + } + + /* + // Thomas Wang's hash, see: http://www.concentric.net/~Ttwang/tech/inthash.htm + // This assumes proxyId1 and proxyId2 are 16-bit. + SIMD_FORCE_INLINE int getHash(int proxyId1, int proxyId2) + { + int key = (proxyId2 << 16) | proxyId1; + key = ~key + (key << 15); + key = key ^ (key >> 12); + key = key + (key << 2); + key = key ^ (key >> 4); + key = key * 2057; + key = key ^ (key >> 16); + return key; + } + */ + + SIMD_FORCE_INLINE unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2) + { + unsigned int key = proxyId1 | (proxyId2 << 16); + // Thomas Wang's hash + + key += ~(key << 15); + key ^= (key >> 10); + key += (key << 3); + key ^= (key >> 6); + key += ~(key << 11); + key ^= (key >> 16); + return key; + } + + SIMD_FORCE_INLINE btBroadphasePair* internalFindPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1, int hash) + { + int proxyId1 = proxy0->getUid(); + int proxyId2 = proxy1->getUid(); +#if 0 // wrong, 'equalsPair' use unsorted uids, copy-past devil striked again. Nat. + if (proxyId1 > proxyId2) + btSwap(proxyId1, proxyId2); +#endif + + int index = m_hashTable[hash]; + + while (index != BT_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false) + { + index = m_next[index]; + } + + if (index == BT_NULL_PAIR) + { + return NULL; + } + + btAssert(index < m_overlappingPairArray.size()); + + return &m_overlappingPairArray[index]; + } + + virtual bool hasDeferredRemoval() + { + return false; + } + + virtual void setInternalGhostPairCallback(btOverlappingPairCallback * ghostPairCallback) + { + m_ghostPairCallback = ghostPairCallback; + } + + virtual void sortOverlappingPairs(btDispatcher * dispatcher); +}; + +///btSortedOverlappingPairCache maintains the objects with overlapping AABB +///Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase +class btSortedOverlappingPairCache : public btOverlappingPairCache +{ +protected: + //avoid brute-force finding all the time + btBroadphasePairArray m_overlappingPairArray; + + //during the dispatch, check that user doesn't destroy/create proxy + bool m_blockedForChanges; + + ///by default, do the removal during the pair traversal + bool m_hasDeferredRemoval; + + //if set, use the callback instead of the built in filter in needBroadphaseCollision + btOverlapFilterCallback* m_overlapFilterCallback; + + btOverlappingPairCallback* m_ghostPairCallback; + +public: + btSortedOverlappingPairCache(); + virtual ~btSortedOverlappingPairCache(); + + virtual void processAllOverlappingPairs(btOverlapCallback*, btDispatcher* dispatcher); + + void* removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher); + + void cleanOverlappingPair(btBroadphasePair& pair, btDispatcher* dispatcher); + + btBroadphasePair* addOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1); + + btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1); + + void cleanProxyFromPairs(btBroadphaseProxy* proxy, btDispatcher* dispatcher); + + void removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher); + + inline bool needsBroadphaseCollision(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) const + { + if (m_overlapFilterCallback) + return m_overlapFilterCallback->needBroadphaseCollision(proxy0, proxy1); + + bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0; + collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask); + + return collides; + } + + btBroadphasePairArray& getOverlappingPairArray() + { + return m_overlappingPairArray; + } + + const btBroadphasePairArray& getOverlappingPairArray() const + { + return m_overlappingPairArray; + } + + btBroadphasePair* getOverlappingPairArrayPtr() + { + return &m_overlappingPairArray[0]; + } + + const btBroadphasePair* getOverlappingPairArrayPtr() const + { + return &m_overlappingPairArray[0]; + } + + int getNumOverlappingPairs() const + { + return m_overlappingPairArray.size(); + } + + btOverlapFilterCallback* getOverlapFilterCallback() + { + return m_overlapFilterCallback; + } + + void setOverlapFilterCallback(btOverlapFilterCallback* callback) + { + m_overlapFilterCallback = callback; + } + + virtual bool hasDeferredRemoval() + { + return m_hasDeferredRemoval; + } + + virtual void setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback) + { + m_ghostPairCallback = ghostPairCallback; + } + + virtual void sortOverlappingPairs(btDispatcher* dispatcher); +}; + +///btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing. +class btNullPairCache : public btOverlappingPairCache +{ + btBroadphasePairArray m_overlappingPairArray; + +public: + virtual btBroadphasePair* getOverlappingPairArrayPtr() + { + return &m_overlappingPairArray[0]; + } + const btBroadphasePair* getOverlappingPairArrayPtr() const + { + return &m_overlappingPairArray[0]; + } + btBroadphasePairArray& getOverlappingPairArray() + { + return m_overlappingPairArray; + } + + virtual void cleanOverlappingPair(btBroadphasePair& /*pair*/, btDispatcher* /*dispatcher*/) + { + } + + virtual int getNumOverlappingPairs() const + { + return 0; + } + + virtual void cleanProxyFromPairs(btBroadphaseProxy* /*proxy*/, btDispatcher* /*dispatcher*/) + { + } + + bool needsBroadphaseCollision(btBroadphaseProxy*, btBroadphaseProxy*) const + { + return true; + } + btOverlapFilterCallback* getOverlapFilterCallback() + { + return 0; + } + virtual void setOverlapFilterCallback(btOverlapFilterCallback* /*callback*/) + { + } + + virtual void processAllOverlappingPairs(btOverlapCallback*, btDispatcher* /*dispatcher*/) + { + } + + virtual btBroadphasePair* findPair(btBroadphaseProxy* /*proxy0*/, btBroadphaseProxy* /*proxy1*/) + { + return 0; + } + + virtual bool hasDeferredRemoval() + { + return true; + } + + virtual void setInternalGhostPairCallback(btOverlappingPairCallback* /* ghostPairCallback */) + { + } + + virtual btBroadphasePair* addOverlappingPair(btBroadphaseProxy* /*proxy0*/, btBroadphaseProxy* /*proxy1*/) + { + return 0; + } + + virtual void* removeOverlappingPair(btBroadphaseProxy* /*proxy0*/, btBroadphaseProxy* /*proxy1*/, btDispatcher* /*dispatcher*/) + { + return 0; + } + + virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy* /*proxy0*/, btDispatcher* /*dispatcher*/) + { + } + + virtual void sortOverlappingPairs(btDispatcher* dispatcher) + { + (void)dispatcher; + } +}; + +#endif //BT_OVERLAPPING_PAIR_CACHE_H diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h.i new file mode 100644 index 00000000..2884a437 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btOverlappingPairCache.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h new file mode 100644 index 00000000..36e5068e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h @@ -0,0 +1,41 @@ + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef OVERLAPPING_PAIR_CALLBACK_H +#define OVERLAPPING_PAIR_CALLBACK_H + +class btDispatcher; +struct btBroadphasePair; + +///The btOverlappingPairCallback class is an additional optional broadphase user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache. +class btOverlappingPairCallback +{ +protected: + btOverlappingPairCallback() {} + +public: + virtual ~btOverlappingPairCallback() + { + } + + virtual btBroadphasePair* addOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) = 0; + + virtual void* removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher) = 0; + + virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy0, btDispatcher* dispatcher) = 0; +}; + +#endif //OVERLAPPING_PAIR_CALLBACK_H diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h.i new file mode 100644 index 00000000..7d8052fe --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp new file mode 100644 index 00000000..e23610eb --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp @@ -0,0 +1,1341 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btQuantizedBvh.h" + +#include "LinearMath/btAabbUtil2.h" +#include "LinearMath/btIDebugDraw.h" +#include "LinearMath/btSerializer.h" + +#define RAYAABB2 + +btQuantizedBvh::btQuantizedBvh() : m_bulletVersion(BT_BULLET_VERSION), + m_useQuantization(false), + //m_traversalMode(TRAVERSAL_STACKLESS_CACHE_FRIENDLY) + m_traversalMode(TRAVERSAL_STACKLESS) + //m_traversalMode(TRAVERSAL_RECURSIVE) + , + m_subtreeHeaderCount(0) //PCK: add this line +{ + m_bvhAabbMin.setValue(-SIMD_INFINITY, -SIMD_INFINITY, -SIMD_INFINITY); + m_bvhAabbMax.setValue(SIMD_INFINITY, SIMD_INFINITY, SIMD_INFINITY); +} + +void btQuantizedBvh::buildInternal() +{ + ///assumes that caller filled in the m_quantizedLeafNodes + m_useQuantization = true; + int numLeafNodes = 0; + + if (m_useQuantization) + { + //now we have an array of leafnodes in m_leafNodes + numLeafNodes = m_quantizedLeafNodes.size(); + + m_quantizedContiguousNodes.resize(2 * numLeafNodes); + } + + m_curNodeIndex = 0; + + buildTree(0, numLeafNodes); + + ///if the entire tree is small then subtree size, we need to create a header info for the tree + if (m_useQuantization && !m_SubtreeHeaders.size()) + { + btBvhSubtreeInfo& subtree = m_SubtreeHeaders.expand(); + subtree.setAabbFromQuantizeNode(m_quantizedContiguousNodes[0]); + subtree.m_rootNodeIndex = 0; + subtree.m_subtreeSize = m_quantizedContiguousNodes[0].isLeafNode() ? 1 : m_quantizedContiguousNodes[0].getEscapeIndex(); + } + + //PCK: update the copy of the size + m_subtreeHeaderCount = m_SubtreeHeaders.size(); + + //PCK: clear m_quantizedLeafNodes and m_leafNodes, they are temporary + m_quantizedLeafNodes.clear(); + m_leafNodes.clear(); +} + +///just for debugging, to visualize the individual patches/subtrees +#ifdef DEBUG_PATCH_COLORS +btVector3 color[4] = + { + btVector3(1, 0, 0), + btVector3(0, 1, 0), + btVector3(0, 0, 1), + btVector3(0, 1, 1)}; +#endif //DEBUG_PATCH_COLORS + +void btQuantizedBvh::setQuantizationValues(const btVector3& bvhAabbMin, const btVector3& bvhAabbMax, btScalar quantizationMargin) +{ + //enlarge the AABB to avoid division by zero when initializing the quantization values + btVector3 clampValue(quantizationMargin, quantizationMargin, quantizationMargin); + m_bvhAabbMin = bvhAabbMin - clampValue; + m_bvhAabbMax = bvhAabbMax + clampValue; + btVector3 aabbSize = m_bvhAabbMax - m_bvhAabbMin; + m_bvhQuantization = btVector3(btScalar(65533.0), btScalar(65533.0), btScalar(65533.0)) / aabbSize; + + m_useQuantization = true; + + { + unsigned short vecIn[3]; + btVector3 v; + { + quantize(vecIn, m_bvhAabbMin, false); + v = unQuantize(vecIn); + m_bvhAabbMin.setMin(v - clampValue); + } + aabbSize = m_bvhAabbMax - m_bvhAabbMin; + m_bvhQuantization = btVector3(btScalar(65533.0), btScalar(65533.0), btScalar(65533.0)) / aabbSize; + { + quantize(vecIn, m_bvhAabbMax, true); + v = unQuantize(vecIn); + m_bvhAabbMax.setMax(v + clampValue); + } + aabbSize = m_bvhAabbMax - m_bvhAabbMin; + m_bvhQuantization = btVector3(btScalar(65533.0), btScalar(65533.0), btScalar(65533.0)) / aabbSize; + } +} + +btQuantizedBvh::~btQuantizedBvh() +{ +} + +#ifdef DEBUG_TREE_BUILDING +int gStackDepth = 0; +int gMaxStackDepth = 0; +#endif //DEBUG_TREE_BUILDING + +void btQuantizedBvh::buildTree(int startIndex, int endIndex) +{ +#ifdef DEBUG_TREE_BUILDING + gStackDepth++; + if (gStackDepth > gMaxStackDepth) + gMaxStackDepth = gStackDepth; +#endif //DEBUG_TREE_BUILDING + + int splitAxis, splitIndex, i; + int numIndices = endIndex - startIndex; + int curIndex = m_curNodeIndex; + + btAssert(numIndices > 0); + + if (numIndices == 1) + { +#ifdef DEBUG_TREE_BUILDING + gStackDepth--; +#endif //DEBUG_TREE_BUILDING + + assignInternalNodeFromLeafNode(m_curNodeIndex, startIndex); + + m_curNodeIndex++; + return; + } + //calculate Best Splitting Axis and where to split it. Sort the incoming 'leafNodes' array within range 'startIndex/endIndex'. + + splitAxis = calcSplittingAxis(startIndex, endIndex); + + splitIndex = sortAndCalcSplittingIndex(startIndex, endIndex, splitAxis); + + int internalNodeIndex = m_curNodeIndex; + + //set the min aabb to 'inf' or a max value, and set the max aabb to a -inf/minimum value. + //the aabb will be expanded during buildTree/mergeInternalNodeAabb with actual node values + setInternalNodeAabbMin(m_curNodeIndex, m_bvhAabbMax); //can't use btVector3(SIMD_INFINITY,SIMD_INFINITY,SIMD_INFINITY)) because of quantization + setInternalNodeAabbMax(m_curNodeIndex, m_bvhAabbMin); //can't use btVector3(-SIMD_INFINITY,-SIMD_INFINITY,-SIMD_INFINITY)) because of quantization + + for (i = startIndex; i < endIndex; i++) + { + mergeInternalNodeAabb(m_curNodeIndex, getAabbMin(i), getAabbMax(i)); + } + + m_curNodeIndex++; + + //internalNode->m_escapeIndex; + + int leftChildNodexIndex = m_curNodeIndex; + + //build left child tree + buildTree(startIndex, splitIndex); + + int rightChildNodexIndex = m_curNodeIndex; + //build right child tree + buildTree(splitIndex, endIndex); + +#ifdef DEBUG_TREE_BUILDING + gStackDepth--; +#endif //DEBUG_TREE_BUILDING + + int escapeIndex = m_curNodeIndex - curIndex; + + if (m_useQuantization) + { + //escapeIndex is the number of nodes of this subtree + const int sizeQuantizedNode = sizeof(btQuantizedBvhNode); + const int treeSizeInBytes = escapeIndex * sizeQuantizedNode; + if (treeSizeInBytes > MAX_SUBTREE_SIZE_IN_BYTES) + { + updateSubtreeHeaders(leftChildNodexIndex, rightChildNodexIndex); + } + } + else + { + } + + setInternalNodeEscapeIndex(internalNodeIndex, escapeIndex); +} + +void btQuantizedBvh::updateSubtreeHeaders(int leftChildNodexIndex, int rightChildNodexIndex) +{ + btAssert(m_useQuantization); + + btQuantizedBvhNode& leftChildNode = m_quantizedContiguousNodes[leftChildNodexIndex]; + int leftSubTreeSize = leftChildNode.isLeafNode() ? 1 : leftChildNode.getEscapeIndex(); + int leftSubTreeSizeInBytes = leftSubTreeSize * static_cast(sizeof(btQuantizedBvhNode)); + + btQuantizedBvhNode& rightChildNode = m_quantizedContiguousNodes[rightChildNodexIndex]; + int rightSubTreeSize = rightChildNode.isLeafNode() ? 1 : rightChildNode.getEscapeIndex(); + int rightSubTreeSizeInBytes = rightSubTreeSize * static_cast(sizeof(btQuantizedBvhNode)); + + if (leftSubTreeSizeInBytes <= MAX_SUBTREE_SIZE_IN_BYTES) + { + btBvhSubtreeInfo& subtree = m_SubtreeHeaders.expand(); + subtree.setAabbFromQuantizeNode(leftChildNode); + subtree.m_rootNodeIndex = leftChildNodexIndex; + subtree.m_subtreeSize = leftSubTreeSize; + } + + if (rightSubTreeSizeInBytes <= MAX_SUBTREE_SIZE_IN_BYTES) + { + btBvhSubtreeInfo& subtree = m_SubtreeHeaders.expand(); + subtree.setAabbFromQuantizeNode(rightChildNode); + subtree.m_rootNodeIndex = rightChildNodexIndex; + subtree.m_subtreeSize = rightSubTreeSize; + } + + //PCK: update the copy of the size + m_subtreeHeaderCount = m_SubtreeHeaders.size(); +} + +int btQuantizedBvh::sortAndCalcSplittingIndex(int startIndex, int endIndex, int splitAxis) +{ + int i; + int splitIndex = startIndex; + int numIndices = endIndex - startIndex; + btScalar splitValue; + + btVector3 means(btScalar(0.), btScalar(0.), btScalar(0.)); + for (i = startIndex; i < endIndex; i++) + { + btVector3 center = btScalar(0.5) * (getAabbMax(i) + getAabbMin(i)); + means += center; + } + means *= (btScalar(1.) / (btScalar)numIndices); + + splitValue = means[splitAxis]; + + //sort leafNodes so all values larger then splitValue comes first, and smaller values start from 'splitIndex'. + for (i = startIndex; i < endIndex; i++) + { + btVector3 center = btScalar(0.5) * (getAabbMax(i) + getAabbMin(i)); + if (center[splitAxis] > splitValue) + { + //swap + swapLeafNodes(i, splitIndex); + splitIndex++; + } + } + + //if the splitIndex causes unbalanced trees, fix this by using the center in between startIndex and endIndex + //otherwise the tree-building might fail due to stack-overflows in certain cases. + //unbalanced1 is unsafe: it can cause stack overflows + //bool unbalanced1 = ((splitIndex==startIndex) || (splitIndex == (endIndex-1))); + + //unbalanced2 should work too: always use center (perfect balanced trees) + //bool unbalanced2 = true; + + //this should be safe too: + int rangeBalancedIndices = numIndices / 3; + bool unbalanced = ((splitIndex <= (startIndex + rangeBalancedIndices)) || (splitIndex >= (endIndex - 1 - rangeBalancedIndices))); + + if (unbalanced) + { + splitIndex = startIndex + (numIndices >> 1); + } + + bool unbal = (splitIndex == startIndex) || (splitIndex == (endIndex)); + (void)unbal; + btAssert(!unbal); + + return splitIndex; +} + +int btQuantizedBvh::calcSplittingAxis(int startIndex, int endIndex) +{ + int i; + + btVector3 means(btScalar(0.), btScalar(0.), btScalar(0.)); + btVector3 variance(btScalar(0.), btScalar(0.), btScalar(0.)); + int numIndices = endIndex - startIndex; + + for (i = startIndex; i < endIndex; i++) + { + btVector3 center = btScalar(0.5) * (getAabbMax(i) + getAabbMin(i)); + means += center; + } + means *= (btScalar(1.) / (btScalar)numIndices); + + for (i = startIndex; i < endIndex; i++) + { + btVector3 center = btScalar(0.5) * (getAabbMax(i) + getAabbMin(i)); + btVector3 diff2 = center - means; + diff2 = diff2 * diff2; + variance += diff2; + } + variance *= (btScalar(1.) / ((btScalar)numIndices - 1)); + + return variance.maxAxis(); +} + +void btQuantizedBvh::reportAabbOverlappingNodex(btNodeOverlapCallback* nodeCallback, const btVector3& aabbMin, const btVector3& aabbMax) const +{ + //either choose recursive traversal (walkTree) or stackless (walkStacklessTree) + + if (m_useQuantization) + { + ///quantize query AABB + unsigned short int quantizedQueryAabbMin[3]; + unsigned short int quantizedQueryAabbMax[3]; + quantizeWithClamp(quantizedQueryAabbMin, aabbMin, 0); + quantizeWithClamp(quantizedQueryAabbMax, aabbMax, 1); + + switch (m_traversalMode) + { + case TRAVERSAL_STACKLESS: + walkStacklessQuantizedTree(nodeCallback, quantizedQueryAabbMin, quantizedQueryAabbMax, 0, m_curNodeIndex); + break; + case TRAVERSAL_STACKLESS_CACHE_FRIENDLY: + walkStacklessQuantizedTreeCacheFriendly(nodeCallback, quantizedQueryAabbMin, quantizedQueryAabbMax); + break; + case TRAVERSAL_RECURSIVE: + { + const btQuantizedBvhNode* rootNode = &m_quantizedContiguousNodes[0]; + walkRecursiveQuantizedTreeAgainstQueryAabb(rootNode, nodeCallback, quantizedQueryAabbMin, quantizedQueryAabbMax); + } + break; + default: + //unsupported + btAssert(0); + } + } + else + { + walkStacklessTree(nodeCallback, aabbMin, aabbMax); + } +} + +void btQuantizedBvh::walkStacklessTree(btNodeOverlapCallback* nodeCallback, const btVector3& aabbMin, const btVector3& aabbMax) const +{ + btAssert(!m_useQuantization); + + const btOptimizedBvhNode* rootNode = &m_contiguousNodes[0]; + int escapeIndex, curIndex = 0; + int walkIterations = 0; + bool isLeafNode; + //PCK: unsigned instead of bool + unsigned aabbOverlap; + + while (curIndex < m_curNodeIndex) + { + //catch bugs in tree data + btAssert(walkIterations < m_curNodeIndex); + + walkIterations++; + aabbOverlap = TestAabbAgainstAabb2(aabbMin, aabbMax, rootNode->m_aabbMinOrg, rootNode->m_aabbMaxOrg); + isLeafNode = rootNode->m_escapeIndex == -1; + + //PCK: unsigned instead of bool + if (isLeafNode && (aabbOverlap != 0)) + { + nodeCallback->processNode(rootNode->m_subPart, rootNode->m_triangleIndex); + } + + //PCK: unsigned instead of bool + if ((aabbOverlap != 0) || isLeafNode) + { + rootNode++; + curIndex++; + } + else + { + escapeIndex = rootNode->m_escapeIndex; + rootNode += escapeIndex; + curIndex += escapeIndex; + } + } +} + +/* +///this was the original recursive traversal, before we optimized towards stackless traversal +void btQuantizedBvh::walkTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const +{ + bool isLeafNode, aabbOverlap = TestAabbAgainstAabb2(aabbMin,aabbMax,rootNode->m_aabbMin,rootNode->m_aabbMax); + if (aabbOverlap) + { + isLeafNode = (!rootNode->m_leftChild && !rootNode->m_rightChild); + if (isLeafNode) + { + nodeCallback->processNode(rootNode); + } else + { + walkTree(rootNode->m_leftChild,nodeCallback,aabbMin,aabbMax); + walkTree(rootNode->m_rightChild,nodeCallback,aabbMin,aabbMax); + } + } + +} +*/ + +void btQuantizedBvh::walkRecursiveQuantizedTreeAgainstQueryAabb(const btQuantizedBvhNode* currentNode, btNodeOverlapCallback* nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax) const +{ + btAssert(m_useQuantization); + + bool isLeafNode; + //PCK: unsigned instead of bool + unsigned aabbOverlap; + + //PCK: unsigned instead of bool + aabbOverlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin, quantizedQueryAabbMax, currentNode->m_quantizedAabbMin, currentNode->m_quantizedAabbMax); + isLeafNode = currentNode->isLeafNode(); + + //PCK: unsigned instead of bool + if (aabbOverlap != 0) + { + if (isLeafNode) + { + nodeCallback->processNode(currentNode->getPartId(), currentNode->getTriangleIndex()); + } + else + { + //process left and right children + const btQuantizedBvhNode* leftChildNode = currentNode + 1; + walkRecursiveQuantizedTreeAgainstQueryAabb(leftChildNode, nodeCallback, quantizedQueryAabbMin, quantizedQueryAabbMax); + + const btQuantizedBvhNode* rightChildNode = leftChildNode->isLeafNode() ? leftChildNode + 1 : leftChildNode + leftChildNode->getEscapeIndex(); + walkRecursiveQuantizedTreeAgainstQueryAabb(rightChildNode, nodeCallback, quantizedQueryAabbMin, quantizedQueryAabbMax); + } + } +} + +void btQuantizedBvh::walkStacklessTreeAgainstRay(btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax, int startNodeIndex, int endNodeIndex) const +{ + btAssert(!m_useQuantization); + + const btOptimizedBvhNode* rootNode = &m_contiguousNodes[0]; + int escapeIndex, curIndex = 0; + int walkIterations = 0; + bool isLeafNode; + //PCK: unsigned instead of bool + unsigned aabbOverlap = 0; + unsigned rayBoxOverlap = 0; + btScalar lambda_max = 1.0; + + /* Quick pruning by quantized box */ + btVector3 rayAabbMin = raySource; + btVector3 rayAabbMax = raySource; + rayAabbMin.setMin(rayTarget); + rayAabbMax.setMax(rayTarget); + + /* Add box cast extents to bounding box */ + rayAabbMin += aabbMin; + rayAabbMax += aabbMax; + +#ifdef RAYAABB2 + btVector3 rayDir = (rayTarget - raySource); + rayDir.safeNormalize();// stephengold changed normalize to safeNormalize 2020-02-17 + lambda_max = rayDir.dot(rayTarget - raySource); + ///what about division by zero? --> just set rayDirection[i] to 1.0 + btVector3 rayDirectionInverse; + rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[0]; + rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[1]; + rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[2]; + unsigned int sign[3] = {rayDirectionInverse[0] < 0.0, rayDirectionInverse[1] < 0.0, rayDirectionInverse[2] < 0.0}; +#endif + + btVector3 bounds[2]; + + while (curIndex < m_curNodeIndex) + { + btScalar param = 1.0; + //catch bugs in tree data + btAssert(walkIterations < m_curNodeIndex); + + walkIterations++; + + bounds[0] = rootNode->m_aabbMinOrg; + bounds[1] = rootNode->m_aabbMaxOrg; + /* Add box cast extents */ + bounds[0] -= aabbMax; + bounds[1] -= aabbMin; + + aabbOverlap = TestAabbAgainstAabb2(rayAabbMin, rayAabbMax, rootNode->m_aabbMinOrg, rootNode->m_aabbMaxOrg); + //perhaps profile if it is worth doing the aabbOverlap test first + +#ifdef RAYAABB2 + ///careful with this check: need to check division by zero (above) and fix the unQuantize method + ///thanks Joerg/hiker for the reproduction case! + ///http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1858 + rayBoxOverlap = aabbOverlap ? btRayAabb2(raySource, rayDirectionInverse, sign, bounds, param, 0.0f, lambda_max) : false; + +#else + btVector3 normal; + rayBoxOverlap = btRayAabb(raySource, rayTarget, bounds[0], bounds[1], param, normal); +#endif + + isLeafNode = rootNode->m_escapeIndex == -1; + + //PCK: unsigned instead of bool + if (isLeafNode && (rayBoxOverlap != 0)) + { + nodeCallback->processNode(rootNode->m_subPart, rootNode->m_triangleIndex); + } + + //PCK: unsigned instead of bool + if ((rayBoxOverlap != 0) || isLeafNode) + { + rootNode++; + curIndex++; + } + else + { + escapeIndex = rootNode->m_escapeIndex; + rootNode += escapeIndex; + curIndex += escapeIndex; + } + } +} + +void btQuantizedBvh::walkStacklessQuantizedTreeAgainstRay(btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax, int startNodeIndex, int endNodeIndex) const +{ + btAssert(m_useQuantization); + + int curIndex = startNodeIndex; + int walkIterations = 0; + int subTreeSize = endNodeIndex - startNodeIndex; + (void)subTreeSize; + + const btQuantizedBvhNode* rootNode = &m_quantizedContiguousNodes[startNodeIndex]; + int escapeIndex; + + bool isLeafNode; + //PCK: unsigned instead of bool + unsigned boxBoxOverlap = 0; + unsigned rayBoxOverlap = 0; + + btScalar lambda_max = 1.0; + +#ifdef RAYAABB2 + btVector3 rayDirection = (rayTarget - raySource); + rayDirection.safeNormalize();// stephengold changed normalize to safeNormalize 2020-02-17 + lambda_max = rayDirection.dot(rayTarget - raySource); + ///what about division by zero? --> just set rayDirection[i] to 1.0 + rayDirection[0] = rayDirection[0] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDirection[0]; + rayDirection[1] = rayDirection[1] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDirection[1]; + rayDirection[2] = rayDirection[2] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDirection[2]; + unsigned int sign[3] = {rayDirection[0] < 0.0, rayDirection[1] < 0.0, rayDirection[2] < 0.0}; +#endif + + /* Quick pruning by quantized box */ + btVector3 rayAabbMin = raySource; + btVector3 rayAabbMax = raySource; + rayAabbMin.setMin(rayTarget); + rayAabbMax.setMax(rayTarget); + + /* Add box cast extents to bounding box */ + rayAabbMin += aabbMin; + rayAabbMax += aabbMax; + + unsigned short int quantizedQueryAabbMin[3]; + unsigned short int quantizedQueryAabbMax[3]; + quantizeWithClamp(quantizedQueryAabbMin, rayAabbMin, 0); + quantizeWithClamp(quantizedQueryAabbMax, rayAabbMax, 1); + + while (curIndex < endNodeIndex) + { +//#define VISUALLY_ANALYZE_BVH 1 +#ifdef VISUALLY_ANALYZE_BVH + //some code snippet to debugDraw aabb, to visually analyze bvh structure + static int drawPatch = 0; + //need some global access to a debugDrawer + extern btIDebugDraw* debugDrawerPtr; + if (curIndex == drawPatch) + { + btVector3 aabbMin, aabbMax; + aabbMin = unQuantize(rootNode->m_quantizedAabbMin); + aabbMax = unQuantize(rootNode->m_quantizedAabbMax); + btVector3 color(1, 0, 0); + debugDrawerPtr->drawAabb(aabbMin, aabbMax, color); + } +#endif //VISUALLY_ANALYZE_BVH + + //catch bugs in tree data + btAssert(walkIterations < subTreeSize); + + walkIterations++; + //PCK: unsigned instead of bool + // only interested if this is closer than any previous hit + btScalar param = 1.0; + rayBoxOverlap = 0; + boxBoxOverlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin, quantizedQueryAabbMax, rootNode->m_quantizedAabbMin, rootNode->m_quantizedAabbMax); + isLeafNode = rootNode->isLeafNode(); + if (boxBoxOverlap) + { + btVector3 bounds[2]; + bounds[0] = unQuantize(rootNode->m_quantizedAabbMin); + bounds[1] = unQuantize(rootNode->m_quantizedAabbMax); + /* Add box cast extents */ + bounds[0] -= aabbMax; + bounds[1] -= aabbMin; + btVector3 normal; +#if 0 + bool ra2 = btRayAabb2 (raySource, rayDirection, sign, bounds, param, 0.0, lambda_max); + bool ra = btRayAabb (raySource, rayTarget, bounds[0], bounds[1], param, normal); + if (ra2 != ra) + { + printf("functions don't match\n"); + } +#endif +#ifdef RAYAABB2 + ///careful with this check: need to check division by zero (above) and fix the unQuantize method + ///thanks Joerg/hiker for the reproduction case! + ///http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1858 + + //BT_PROFILE("btRayAabb2"); + rayBoxOverlap = btRayAabb2(raySource, rayDirection, sign, bounds, param, 0.0f, lambda_max); + +#else + rayBoxOverlap = true; //btRayAabb(raySource, rayTarget, bounds[0], bounds[1], param, normal); +#endif + } + + if (isLeafNode && rayBoxOverlap) + { + nodeCallback->processNode(rootNode->getPartId(), rootNode->getTriangleIndex()); + } + + //PCK: unsigned instead of bool + if ((rayBoxOverlap != 0) || isLeafNode) + { + rootNode++; + curIndex++; + } + else + { + escapeIndex = rootNode->getEscapeIndex(); + rootNode += escapeIndex; + curIndex += escapeIndex; + } + } +} + +void btQuantizedBvh::walkStacklessQuantizedTree(btNodeOverlapCallback* nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax, int startNodeIndex, int endNodeIndex) const +{ + btAssert(m_useQuantization); + + int curIndex = startNodeIndex; + int walkIterations = 0; + int subTreeSize = endNodeIndex - startNodeIndex; + (void)subTreeSize; + + const btQuantizedBvhNode* rootNode = &m_quantizedContiguousNodes[startNodeIndex]; + int escapeIndex; + + bool isLeafNode; + //PCK: unsigned instead of bool + unsigned aabbOverlap; + + while (curIndex < endNodeIndex) + { +//#define VISUALLY_ANALYZE_BVH 1 +#ifdef VISUALLY_ANALYZE_BVH + //some code snippet to debugDraw aabb, to visually analyze bvh structure + static int drawPatch = 0; + //need some global access to a debugDrawer + extern btIDebugDraw* debugDrawerPtr; + if (curIndex == drawPatch) + { + btVector3 aabbMin, aabbMax; + aabbMin = unQuantize(rootNode->m_quantizedAabbMin); + aabbMax = unQuantize(rootNode->m_quantizedAabbMax); + btVector3 color(1, 0, 0); + debugDrawerPtr->drawAabb(aabbMin, aabbMax, color); + } +#endif //VISUALLY_ANALYZE_BVH + + //catch bugs in tree data + btAssert(walkIterations < subTreeSize); + + walkIterations++; + //PCK: unsigned instead of bool + aabbOverlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin, quantizedQueryAabbMax, rootNode->m_quantizedAabbMin, rootNode->m_quantizedAabbMax); + isLeafNode = rootNode->isLeafNode(); + + if (isLeafNode && aabbOverlap) + { + nodeCallback->processNode(rootNode->getPartId(), rootNode->getTriangleIndex()); + } + + //PCK: unsigned instead of bool + if ((aabbOverlap != 0) || isLeafNode) + { + rootNode++; + curIndex++; + } + else + { + escapeIndex = rootNode->getEscapeIndex(); + rootNode += escapeIndex; + curIndex += escapeIndex; + } + } +} + +//This traversal can be called from Playstation 3 SPU +void btQuantizedBvh::walkStacklessQuantizedTreeCacheFriendly(btNodeOverlapCallback* nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax) const +{ + btAssert(m_useQuantization); + + int i; + + for (i = 0; i < this->m_SubtreeHeaders.size(); i++) + { + const btBvhSubtreeInfo& subtree = m_SubtreeHeaders[i]; + + //PCK: unsigned instead of bool + unsigned overlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin, quantizedQueryAabbMax, subtree.m_quantizedAabbMin, subtree.m_quantizedAabbMax); + if (overlap != 0) + { + walkStacklessQuantizedTree(nodeCallback, quantizedQueryAabbMin, quantizedQueryAabbMax, + subtree.m_rootNodeIndex, + subtree.m_rootNodeIndex + subtree.m_subtreeSize); + } + } +} + +void btQuantizedBvh::reportRayOverlappingNodex(btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget) const +{ + reportBoxCastOverlappingNodex(nodeCallback, raySource, rayTarget, btVector3(0, 0, 0), btVector3(0, 0, 0)); +} + +void btQuantizedBvh::reportBoxCastOverlappingNodex(btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax) const +{ + //always use stackless + + if (m_useQuantization) + { + walkStacklessQuantizedTreeAgainstRay(nodeCallback, raySource, rayTarget, aabbMin, aabbMax, 0, m_curNodeIndex); + } + else + { + walkStacklessTreeAgainstRay(nodeCallback, raySource, rayTarget, aabbMin, aabbMax, 0, m_curNodeIndex); + } + /* + { + //recursive traversal + btVector3 qaabbMin = raySource; + btVector3 qaabbMax = raySource; + qaabbMin.setMin(rayTarget); + qaabbMax.setMax(rayTarget); + qaabbMin += aabbMin; + qaabbMax += aabbMax; + reportAabbOverlappingNodex(nodeCallback,qaabbMin,qaabbMax); + } + */ +} + +void btQuantizedBvh::swapLeafNodes(int i, int splitIndex) +{ + if (m_useQuantization) + { + btQuantizedBvhNode tmp = m_quantizedLeafNodes[i]; + m_quantizedLeafNodes[i] = m_quantizedLeafNodes[splitIndex]; + m_quantizedLeafNodes[splitIndex] = tmp; + } + else + { + btOptimizedBvhNode tmp = m_leafNodes[i]; + m_leafNodes[i] = m_leafNodes[splitIndex]; + m_leafNodes[splitIndex] = tmp; + } +} + +void btQuantizedBvh::assignInternalNodeFromLeafNode(int internalNode, int leafNodeIndex) +{ + if (m_useQuantization) + { + m_quantizedContiguousNodes[internalNode] = m_quantizedLeafNodes[leafNodeIndex]; + } + else + { + m_contiguousNodes[internalNode] = m_leafNodes[leafNodeIndex]; + } +} + +//PCK: include +#include + +#if 0 +//PCK: consts +static const unsigned BVH_ALIGNMENT = 16; +static const unsigned BVH_ALIGNMENT_MASK = BVH_ALIGNMENT-1; + +static const unsigned BVH_ALIGNMENT_BLOCKS = 2; +#endif + +unsigned int btQuantizedBvh::getAlignmentSerializationPadding() +{ + // I changed this to 0 since the extra padding is not needed or used. + return 0; //BVH_ALIGNMENT_BLOCKS * BVH_ALIGNMENT; +} + +unsigned btQuantizedBvh::calculateSerializeBufferSize() const +{ + unsigned baseSize = sizeof(btQuantizedBvh) + getAlignmentSerializationPadding(); + baseSize += sizeof(btBvhSubtreeInfo) * m_subtreeHeaderCount; + if (m_useQuantization) + { + return baseSize + m_curNodeIndex * sizeof(btQuantizedBvhNode); + } + return baseSize + m_curNodeIndex * sizeof(btOptimizedBvhNode); +} + +bool btQuantizedBvh::serialize(void* o_alignedDataBuffer, unsigned /*i_dataBufferSize */, bool i_swapEndian) const +{ + btAssert(m_subtreeHeaderCount == m_SubtreeHeaders.size()); + m_subtreeHeaderCount = m_SubtreeHeaders.size(); + + /* if (i_dataBufferSize < calculateSerializeBufferSize() || o_alignedDataBuffer == NULL || (((unsigned)o_alignedDataBuffer & BVH_ALIGNMENT_MASK) != 0)) + { + ///check alignedment for buffer? + btAssert(0); + return false; + } +*/ + + btQuantizedBvh* targetBvh = (btQuantizedBvh*)o_alignedDataBuffer; + + // construct the class so the virtual function table, etc will be set up + // Also, m_leafNodes and m_quantizedLeafNodes will be initialized to default values by the constructor + new (targetBvh) btQuantizedBvh; + + if (i_swapEndian) + { + targetBvh->m_curNodeIndex = static_cast(btSwapEndian(m_curNodeIndex)); + + btSwapVector3Endian(m_bvhAabbMin, targetBvh->m_bvhAabbMin); + btSwapVector3Endian(m_bvhAabbMax, targetBvh->m_bvhAabbMax); + btSwapVector3Endian(m_bvhQuantization, targetBvh->m_bvhQuantization); + + targetBvh->m_traversalMode = (btTraversalMode)btSwapEndian(m_traversalMode); + targetBvh->m_subtreeHeaderCount = static_cast(btSwapEndian(m_subtreeHeaderCount)); + } + else + { + targetBvh->m_curNodeIndex = m_curNodeIndex; + targetBvh->m_bvhAabbMin = m_bvhAabbMin; + targetBvh->m_bvhAabbMax = m_bvhAabbMax; + targetBvh->m_bvhQuantization = m_bvhQuantization; + targetBvh->m_traversalMode = m_traversalMode; + targetBvh->m_subtreeHeaderCount = m_subtreeHeaderCount; + } + + targetBvh->m_useQuantization = m_useQuantization; + + unsigned char* nodeData = (unsigned char*)targetBvh; + nodeData += sizeof(btQuantizedBvh); + + unsigned sizeToAdd = 0; //(BVH_ALIGNMENT-((unsigned)nodeData & BVH_ALIGNMENT_MASK))&BVH_ALIGNMENT_MASK; + nodeData += sizeToAdd; + + int nodeCount = m_curNodeIndex; + + if (m_useQuantization) + { + targetBvh->m_quantizedContiguousNodes.initializeFromBuffer(nodeData, nodeCount, nodeCount); + + if (i_swapEndian) + { + for (int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++) + { + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0] = btSwapEndian(m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0]); + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[1] = btSwapEndian(m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[1]); + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[2] = btSwapEndian(m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[2]); + + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0] = btSwapEndian(m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0]); + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[1] = btSwapEndian(m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[1]); + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[2] = btSwapEndian(m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[2]); + + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex = static_cast(btSwapEndian(m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex)); + } + } + else + { + for (int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++) + { + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0] = m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0]; + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[1] = m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[1]; + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[2] = m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[2]; + + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0] = m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0]; + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[1] = m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[1]; + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[2] = m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[2]; + + targetBvh->m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex = m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex; + } + } + nodeData += sizeof(btQuantizedBvhNode) * nodeCount; + + // this clears the pointer in the member variable it doesn't really do anything to the data + // it does call the destructor on the contained objects, but they are all classes with no destructor defined + // so the memory (which is not freed) is left alone + targetBvh->m_quantizedContiguousNodes.initializeFromBuffer(NULL, 0, 0); + } + else + { + targetBvh->m_contiguousNodes.initializeFromBuffer(nodeData, nodeCount, nodeCount); + + if (i_swapEndian) + { + for (int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++) + { + btSwapVector3Endian(m_contiguousNodes[nodeIndex].m_aabbMinOrg, targetBvh->m_contiguousNodes[nodeIndex].m_aabbMinOrg); + btSwapVector3Endian(m_contiguousNodes[nodeIndex].m_aabbMaxOrg, targetBvh->m_contiguousNodes[nodeIndex].m_aabbMaxOrg); + + targetBvh->m_contiguousNodes[nodeIndex].m_escapeIndex = static_cast(btSwapEndian(m_contiguousNodes[nodeIndex].m_escapeIndex)); + targetBvh->m_contiguousNodes[nodeIndex].m_subPart = static_cast(btSwapEndian(m_contiguousNodes[nodeIndex].m_subPart)); + targetBvh->m_contiguousNodes[nodeIndex].m_triangleIndex = static_cast(btSwapEndian(m_contiguousNodes[nodeIndex].m_triangleIndex)); + } + } + else + { + for (int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++) + { + targetBvh->m_contiguousNodes[nodeIndex].m_aabbMinOrg = m_contiguousNodes[nodeIndex].m_aabbMinOrg; + targetBvh->m_contiguousNodes[nodeIndex].m_aabbMaxOrg = m_contiguousNodes[nodeIndex].m_aabbMaxOrg; + + targetBvh->m_contiguousNodes[nodeIndex].m_escapeIndex = m_contiguousNodes[nodeIndex].m_escapeIndex; + targetBvh->m_contiguousNodes[nodeIndex].m_subPart = m_contiguousNodes[nodeIndex].m_subPart; + targetBvh->m_contiguousNodes[nodeIndex].m_triangleIndex = m_contiguousNodes[nodeIndex].m_triangleIndex; + } + } + nodeData += sizeof(btOptimizedBvhNode) * nodeCount; + + // this clears the pointer in the member variable it doesn't really do anything to the data + // it does call the destructor on the contained objects, but they are all classes with no destructor defined + // so the memory (which is not freed) is left alone + targetBvh->m_contiguousNodes.initializeFromBuffer(NULL, 0, 0); + } + + sizeToAdd = 0; //(BVH_ALIGNMENT-((unsigned)nodeData & BVH_ALIGNMENT_MASK))&BVH_ALIGNMENT_MASK; + nodeData += sizeToAdd; + + // Now serialize the subtree headers + targetBvh->m_SubtreeHeaders.initializeFromBuffer(nodeData, m_subtreeHeaderCount, m_subtreeHeaderCount); + if (i_swapEndian) + { + for (int i = 0; i < m_subtreeHeaderCount; i++) + { + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMin[0] = btSwapEndian(m_SubtreeHeaders[i].m_quantizedAabbMin[0]); + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMin[1] = btSwapEndian(m_SubtreeHeaders[i].m_quantizedAabbMin[1]); + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMin[2] = btSwapEndian(m_SubtreeHeaders[i].m_quantizedAabbMin[2]); + + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMax[0] = btSwapEndian(m_SubtreeHeaders[i].m_quantizedAabbMax[0]); + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMax[1] = btSwapEndian(m_SubtreeHeaders[i].m_quantizedAabbMax[1]); + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMax[2] = btSwapEndian(m_SubtreeHeaders[i].m_quantizedAabbMax[2]); + + targetBvh->m_SubtreeHeaders[i].m_rootNodeIndex = static_cast(btSwapEndian(m_SubtreeHeaders[i].m_rootNodeIndex)); + targetBvh->m_SubtreeHeaders[i].m_subtreeSize = static_cast(btSwapEndian(m_SubtreeHeaders[i].m_subtreeSize)); + } + } + else + { + for (int i = 0; i < m_subtreeHeaderCount; i++) + { + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMin[0] = (m_SubtreeHeaders[i].m_quantizedAabbMin[0]); + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMin[1] = (m_SubtreeHeaders[i].m_quantizedAabbMin[1]); + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMin[2] = (m_SubtreeHeaders[i].m_quantizedAabbMin[2]); + + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMax[0] = (m_SubtreeHeaders[i].m_quantizedAabbMax[0]); + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMax[1] = (m_SubtreeHeaders[i].m_quantizedAabbMax[1]); + targetBvh->m_SubtreeHeaders[i].m_quantizedAabbMax[2] = (m_SubtreeHeaders[i].m_quantizedAabbMax[2]); + + targetBvh->m_SubtreeHeaders[i].m_rootNodeIndex = (m_SubtreeHeaders[i].m_rootNodeIndex); + targetBvh->m_SubtreeHeaders[i].m_subtreeSize = (m_SubtreeHeaders[i].m_subtreeSize); + + // need to clear padding in destination buffer + targetBvh->m_SubtreeHeaders[i].m_padding[0] = 0; + targetBvh->m_SubtreeHeaders[i].m_padding[1] = 0; + targetBvh->m_SubtreeHeaders[i].m_padding[2] = 0; + } + } + nodeData += sizeof(btBvhSubtreeInfo) * m_subtreeHeaderCount; + + // this clears the pointer in the member variable it doesn't really do anything to the data + // it does call the destructor on the contained objects, but they are all classes with no destructor defined + // so the memory (which is not freed) is left alone + targetBvh->m_SubtreeHeaders.initializeFromBuffer(NULL, 0, 0); + + // this wipes the virtual function table pointer at the start of the buffer for the class + *((void**)o_alignedDataBuffer) = NULL; + + return true; +} + +btQuantizedBvh* btQuantizedBvh::deSerializeInPlace(void* i_alignedDataBuffer, unsigned int i_dataBufferSize, bool i_swapEndian) +{ + if (i_alignedDataBuffer == NULL) // || (((unsigned)i_alignedDataBuffer & BVH_ALIGNMENT_MASK) != 0)) + { + return NULL; + } + btQuantizedBvh* bvh = (btQuantizedBvh*)i_alignedDataBuffer; + + if (i_swapEndian) + { + bvh->m_curNodeIndex = static_cast(btSwapEndian(bvh->m_curNodeIndex)); + + btUnSwapVector3Endian(bvh->m_bvhAabbMin); + btUnSwapVector3Endian(bvh->m_bvhAabbMax); + btUnSwapVector3Endian(bvh->m_bvhQuantization); + + bvh->m_traversalMode = (btTraversalMode)btSwapEndian(bvh->m_traversalMode); + bvh->m_subtreeHeaderCount = static_cast(btSwapEndian(bvh->m_subtreeHeaderCount)); + } + + unsigned int calculatedBufSize = bvh->calculateSerializeBufferSize(); + btAssert(calculatedBufSize <= i_dataBufferSize); + + if (calculatedBufSize > i_dataBufferSize) + { + return NULL; + } + + unsigned char* nodeData = (unsigned char*)bvh; + nodeData += sizeof(btQuantizedBvh); + + unsigned sizeToAdd = 0; //(BVH_ALIGNMENT-((unsigned)nodeData & BVH_ALIGNMENT_MASK))&BVH_ALIGNMENT_MASK; + nodeData += sizeToAdd; + + int nodeCount = bvh->m_curNodeIndex; + + // Must call placement new to fill in virtual function table, etc, but we don't want to overwrite most data, so call a special version of the constructor + // Also, m_leafNodes and m_quantizedLeafNodes will be initialized to default values by the constructor + new (bvh) btQuantizedBvh(*bvh, false); + + if (bvh->m_useQuantization) + { + bvh->m_quantizedContiguousNodes.initializeFromBuffer(nodeData, nodeCount, nodeCount); + + if (i_swapEndian) + { + for (int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++) + { + bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0] = btSwapEndian(bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0]); + bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[1] = btSwapEndian(bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[1]); + bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[2] = btSwapEndian(bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[2]); + + bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0] = btSwapEndian(bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0]); + bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[1] = btSwapEndian(bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[1]); + bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[2] = btSwapEndian(bvh->m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[2]); + + bvh->m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex = static_cast(btSwapEndian(bvh->m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex)); + } + } + nodeData += sizeof(btQuantizedBvhNode) * nodeCount; + } + else + { + bvh->m_contiguousNodes.initializeFromBuffer(nodeData, nodeCount, nodeCount); + + if (i_swapEndian) + { + for (int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++) + { + btUnSwapVector3Endian(bvh->m_contiguousNodes[nodeIndex].m_aabbMinOrg); + btUnSwapVector3Endian(bvh->m_contiguousNodes[nodeIndex].m_aabbMaxOrg); + + bvh->m_contiguousNodes[nodeIndex].m_escapeIndex = static_cast(btSwapEndian(bvh->m_contiguousNodes[nodeIndex].m_escapeIndex)); + bvh->m_contiguousNodes[nodeIndex].m_subPart = static_cast(btSwapEndian(bvh->m_contiguousNodes[nodeIndex].m_subPart)); + bvh->m_contiguousNodes[nodeIndex].m_triangleIndex = static_cast(btSwapEndian(bvh->m_contiguousNodes[nodeIndex].m_triangleIndex)); + } + } + nodeData += sizeof(btOptimizedBvhNode) * nodeCount; + } + + sizeToAdd = 0; //(BVH_ALIGNMENT-((unsigned)nodeData & BVH_ALIGNMENT_MASK))&BVH_ALIGNMENT_MASK; + nodeData += sizeToAdd; + + // Now serialize the subtree headers + bvh->m_SubtreeHeaders.initializeFromBuffer(nodeData, bvh->m_subtreeHeaderCount, bvh->m_subtreeHeaderCount); + if (i_swapEndian) + { + for (int i = 0; i < bvh->m_subtreeHeaderCount; i++) + { + bvh->m_SubtreeHeaders[i].m_quantizedAabbMin[0] = btSwapEndian(bvh->m_SubtreeHeaders[i].m_quantizedAabbMin[0]); + bvh->m_SubtreeHeaders[i].m_quantizedAabbMin[1] = btSwapEndian(bvh->m_SubtreeHeaders[i].m_quantizedAabbMin[1]); + bvh->m_SubtreeHeaders[i].m_quantizedAabbMin[2] = btSwapEndian(bvh->m_SubtreeHeaders[i].m_quantizedAabbMin[2]); + + bvh->m_SubtreeHeaders[i].m_quantizedAabbMax[0] = btSwapEndian(bvh->m_SubtreeHeaders[i].m_quantizedAabbMax[0]); + bvh->m_SubtreeHeaders[i].m_quantizedAabbMax[1] = btSwapEndian(bvh->m_SubtreeHeaders[i].m_quantizedAabbMax[1]); + bvh->m_SubtreeHeaders[i].m_quantizedAabbMax[2] = btSwapEndian(bvh->m_SubtreeHeaders[i].m_quantizedAabbMax[2]); + + bvh->m_SubtreeHeaders[i].m_rootNodeIndex = static_cast(btSwapEndian(bvh->m_SubtreeHeaders[i].m_rootNodeIndex)); + bvh->m_SubtreeHeaders[i].m_subtreeSize = static_cast(btSwapEndian(bvh->m_SubtreeHeaders[i].m_subtreeSize)); + } + } + + return bvh; +} + +// Constructor that prevents btVector3's default constructor from being called +btQuantizedBvh::btQuantizedBvh(btQuantizedBvh& self, bool /* ownsMemory */) : m_bvhAabbMin(self.m_bvhAabbMin), + m_bvhAabbMax(self.m_bvhAabbMax), + m_bvhQuantization(self.m_bvhQuantization), + m_bulletVersion(BT_BULLET_VERSION) +{ +} + +void btQuantizedBvh::deSerializeFloat(struct btQuantizedBvhFloatData& quantizedBvhFloatData) +{ + m_bvhAabbMax.deSerializeFloat(quantizedBvhFloatData.m_bvhAabbMax); + m_bvhAabbMin.deSerializeFloat(quantizedBvhFloatData.m_bvhAabbMin); + m_bvhQuantization.deSerializeFloat(quantizedBvhFloatData.m_bvhQuantization); + + m_curNodeIndex = quantizedBvhFloatData.m_curNodeIndex; + m_useQuantization = quantizedBvhFloatData.m_useQuantization != 0; + + { + int numElem = quantizedBvhFloatData.m_numContiguousLeafNodes; + m_contiguousNodes.resize(numElem); + + if (numElem) + { + btOptimizedBvhNodeFloatData* memPtr = quantizedBvhFloatData.m_contiguousNodesPtr; + + for (int i = 0; i < numElem; i++, memPtr++) + { + m_contiguousNodes[i].m_aabbMaxOrg.deSerializeFloat(memPtr->m_aabbMaxOrg); + m_contiguousNodes[i].m_aabbMinOrg.deSerializeFloat(memPtr->m_aabbMinOrg); + m_contiguousNodes[i].m_escapeIndex = memPtr->m_escapeIndex; + m_contiguousNodes[i].m_subPart = memPtr->m_subPart; + m_contiguousNodes[i].m_triangleIndex = memPtr->m_triangleIndex; + } + } + } + + { + int numElem = quantizedBvhFloatData.m_numQuantizedContiguousNodes; + m_quantizedContiguousNodes.resize(numElem); + + if (numElem) + { + btQuantizedBvhNodeData* memPtr = quantizedBvhFloatData.m_quantizedContiguousNodesPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + m_quantizedContiguousNodes[i].m_escapeIndexOrTriangleIndex = memPtr->m_escapeIndexOrTriangleIndex; + m_quantizedContiguousNodes[i].m_quantizedAabbMax[0] = memPtr->m_quantizedAabbMax[0]; + m_quantizedContiguousNodes[i].m_quantizedAabbMax[1] = memPtr->m_quantizedAabbMax[1]; + m_quantizedContiguousNodes[i].m_quantizedAabbMax[2] = memPtr->m_quantizedAabbMax[2]; + m_quantizedContiguousNodes[i].m_quantizedAabbMin[0] = memPtr->m_quantizedAabbMin[0]; + m_quantizedContiguousNodes[i].m_quantizedAabbMin[1] = memPtr->m_quantizedAabbMin[1]; + m_quantizedContiguousNodes[i].m_quantizedAabbMin[2] = memPtr->m_quantizedAabbMin[2]; + } + } + } + + m_traversalMode = btTraversalMode(quantizedBvhFloatData.m_traversalMode); + + { + int numElem = quantizedBvhFloatData.m_numSubtreeHeaders; + m_SubtreeHeaders.resize(numElem); + if (numElem) + { + btBvhSubtreeInfoData* memPtr = quantizedBvhFloatData.m_subTreeInfoPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + m_SubtreeHeaders[i].m_quantizedAabbMax[0] = memPtr->m_quantizedAabbMax[0]; + m_SubtreeHeaders[i].m_quantizedAabbMax[1] = memPtr->m_quantizedAabbMax[1]; + m_SubtreeHeaders[i].m_quantizedAabbMax[2] = memPtr->m_quantizedAabbMax[2]; + m_SubtreeHeaders[i].m_quantizedAabbMin[0] = memPtr->m_quantizedAabbMin[0]; + m_SubtreeHeaders[i].m_quantizedAabbMin[1] = memPtr->m_quantizedAabbMin[1]; + m_SubtreeHeaders[i].m_quantizedAabbMin[2] = memPtr->m_quantizedAabbMin[2]; + m_SubtreeHeaders[i].m_rootNodeIndex = memPtr->m_rootNodeIndex; + m_SubtreeHeaders[i].m_subtreeSize = memPtr->m_subtreeSize; + } + } + } +} + +void btQuantizedBvh::deSerializeDouble(struct btQuantizedBvhDoubleData& quantizedBvhDoubleData) +{ + m_bvhAabbMax.deSerializeDouble(quantizedBvhDoubleData.m_bvhAabbMax); + m_bvhAabbMin.deSerializeDouble(quantizedBvhDoubleData.m_bvhAabbMin); + m_bvhQuantization.deSerializeDouble(quantizedBvhDoubleData.m_bvhQuantization); + + m_curNodeIndex = quantizedBvhDoubleData.m_curNodeIndex; + m_useQuantization = quantizedBvhDoubleData.m_useQuantization != 0; + + { + int numElem = quantizedBvhDoubleData.m_numContiguousLeafNodes; + m_contiguousNodes.resize(numElem); + + if (numElem) + { + btOptimizedBvhNodeDoubleData* memPtr = quantizedBvhDoubleData.m_contiguousNodesPtr; + + for (int i = 0; i < numElem; i++, memPtr++) + { + m_contiguousNodes[i].m_aabbMaxOrg.deSerializeDouble(memPtr->m_aabbMaxOrg); + m_contiguousNodes[i].m_aabbMinOrg.deSerializeDouble(memPtr->m_aabbMinOrg); + m_contiguousNodes[i].m_escapeIndex = memPtr->m_escapeIndex; + m_contiguousNodes[i].m_subPart = memPtr->m_subPart; + m_contiguousNodes[i].m_triangleIndex = memPtr->m_triangleIndex; + } + } + } + + { + int numElem = quantizedBvhDoubleData.m_numQuantizedContiguousNodes; + m_quantizedContiguousNodes.resize(numElem); + + if (numElem) + { + btQuantizedBvhNodeData* memPtr = quantizedBvhDoubleData.m_quantizedContiguousNodesPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + m_quantizedContiguousNodes[i].m_escapeIndexOrTriangleIndex = memPtr->m_escapeIndexOrTriangleIndex; + m_quantizedContiguousNodes[i].m_quantizedAabbMax[0] = memPtr->m_quantizedAabbMax[0]; + m_quantizedContiguousNodes[i].m_quantizedAabbMax[1] = memPtr->m_quantizedAabbMax[1]; + m_quantizedContiguousNodes[i].m_quantizedAabbMax[2] = memPtr->m_quantizedAabbMax[2]; + m_quantizedContiguousNodes[i].m_quantizedAabbMin[0] = memPtr->m_quantizedAabbMin[0]; + m_quantizedContiguousNodes[i].m_quantizedAabbMin[1] = memPtr->m_quantizedAabbMin[1]; + m_quantizedContiguousNodes[i].m_quantizedAabbMin[2] = memPtr->m_quantizedAabbMin[2]; + } + } + } + + m_traversalMode = btTraversalMode(quantizedBvhDoubleData.m_traversalMode); + + { + int numElem = quantizedBvhDoubleData.m_numSubtreeHeaders; + m_SubtreeHeaders.resize(numElem); + if (numElem) + { + btBvhSubtreeInfoData* memPtr = quantizedBvhDoubleData.m_subTreeInfoPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + m_SubtreeHeaders[i].m_quantizedAabbMax[0] = memPtr->m_quantizedAabbMax[0]; + m_SubtreeHeaders[i].m_quantizedAabbMax[1] = memPtr->m_quantizedAabbMax[1]; + m_SubtreeHeaders[i].m_quantizedAabbMax[2] = memPtr->m_quantizedAabbMax[2]; + m_SubtreeHeaders[i].m_quantizedAabbMin[0] = memPtr->m_quantizedAabbMin[0]; + m_SubtreeHeaders[i].m_quantizedAabbMin[1] = memPtr->m_quantizedAabbMin[1]; + m_SubtreeHeaders[i].m_quantizedAabbMin[2] = memPtr->m_quantizedAabbMin[2]; + m_SubtreeHeaders[i].m_rootNodeIndex = memPtr->m_rootNodeIndex; + m_SubtreeHeaders[i].m_subtreeSize = memPtr->m_subtreeSize; + } + } + } +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +const char* btQuantizedBvh::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btQuantizedBvhData* quantizedData = (btQuantizedBvhData*)dataBuffer; + + m_bvhAabbMax.serialize(quantizedData->m_bvhAabbMax); + m_bvhAabbMin.serialize(quantizedData->m_bvhAabbMin); + m_bvhQuantization.serialize(quantizedData->m_bvhQuantization); + + quantizedData->m_curNodeIndex = m_curNodeIndex; + quantizedData->m_useQuantization = m_useQuantization; + + quantizedData->m_numContiguousLeafNodes = m_contiguousNodes.size(); + quantizedData->m_contiguousNodesPtr = (btOptimizedBvhNodeData*)(m_contiguousNodes.size() ? serializer->getUniquePointer((void*)&m_contiguousNodes[0]) : 0); + if (quantizedData->m_contiguousNodesPtr) + { + int sz = sizeof(btOptimizedBvhNodeData); + int numElem = m_contiguousNodes.size(); + btChunk* chunk = serializer->allocate(sz, numElem); + btOptimizedBvhNodeData* memPtr = (btOptimizedBvhNodeData*)chunk->m_oldPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + m_contiguousNodes[i].m_aabbMaxOrg.serialize(memPtr->m_aabbMaxOrg); + m_contiguousNodes[i].m_aabbMinOrg.serialize(memPtr->m_aabbMinOrg); + memPtr->m_escapeIndex = m_contiguousNodes[i].m_escapeIndex; + memPtr->m_subPart = m_contiguousNodes[i].m_subPart; + memPtr->m_triangleIndex = m_contiguousNodes[i].m_triangleIndex; + // Fill padding with zeros to appease msan. + memset(memPtr->m_pad, 0, sizeof(memPtr->m_pad)); + } + serializer->finalizeChunk(chunk, "btOptimizedBvhNodeData", BT_ARRAY_CODE, (void*)&m_contiguousNodes[0]); + } + + quantizedData->m_numQuantizedContiguousNodes = m_quantizedContiguousNodes.size(); + // printf("quantizedData->m_numQuantizedContiguousNodes=%d\n",quantizedData->m_numQuantizedContiguousNodes); + quantizedData->m_quantizedContiguousNodesPtr = (btQuantizedBvhNodeData*)(m_quantizedContiguousNodes.size() ? serializer->getUniquePointer((void*)&m_quantizedContiguousNodes[0]) : 0); + if (quantizedData->m_quantizedContiguousNodesPtr) + { + int sz = sizeof(btQuantizedBvhNodeData); + int numElem = m_quantizedContiguousNodes.size(); + btChunk* chunk = serializer->allocate(sz, numElem); + btQuantizedBvhNodeData* memPtr = (btQuantizedBvhNodeData*)chunk->m_oldPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + memPtr->m_escapeIndexOrTriangleIndex = m_quantizedContiguousNodes[i].m_escapeIndexOrTriangleIndex; + memPtr->m_quantizedAabbMax[0] = m_quantizedContiguousNodes[i].m_quantizedAabbMax[0]; + memPtr->m_quantizedAabbMax[1] = m_quantizedContiguousNodes[i].m_quantizedAabbMax[1]; + memPtr->m_quantizedAabbMax[2] = m_quantizedContiguousNodes[i].m_quantizedAabbMax[2]; + memPtr->m_quantizedAabbMin[0] = m_quantizedContiguousNodes[i].m_quantizedAabbMin[0]; + memPtr->m_quantizedAabbMin[1] = m_quantizedContiguousNodes[i].m_quantizedAabbMin[1]; + memPtr->m_quantizedAabbMin[2] = m_quantizedContiguousNodes[i].m_quantizedAabbMin[2]; + } + serializer->finalizeChunk(chunk, "btQuantizedBvhNodeData", BT_ARRAY_CODE, (void*)&m_quantizedContiguousNodes[0]); + } + + quantizedData->m_traversalMode = int(m_traversalMode); + quantizedData->m_numSubtreeHeaders = m_SubtreeHeaders.size(); + + quantizedData->m_subTreeInfoPtr = (btBvhSubtreeInfoData*)(m_SubtreeHeaders.size() ? serializer->getUniquePointer((void*)&m_SubtreeHeaders[0]) : 0); + if (quantizedData->m_subTreeInfoPtr) + { + int sz = sizeof(btBvhSubtreeInfoData); + int numElem = m_SubtreeHeaders.size(); + btChunk* chunk = serializer->allocate(sz, numElem); + btBvhSubtreeInfoData* memPtr = (btBvhSubtreeInfoData*)chunk->m_oldPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + memPtr->m_quantizedAabbMax[0] = m_SubtreeHeaders[i].m_quantizedAabbMax[0]; + memPtr->m_quantizedAabbMax[1] = m_SubtreeHeaders[i].m_quantizedAabbMax[1]; + memPtr->m_quantizedAabbMax[2] = m_SubtreeHeaders[i].m_quantizedAabbMax[2]; + memPtr->m_quantizedAabbMin[0] = m_SubtreeHeaders[i].m_quantizedAabbMin[0]; + memPtr->m_quantizedAabbMin[1] = m_SubtreeHeaders[i].m_quantizedAabbMin[1]; + memPtr->m_quantizedAabbMin[2] = m_SubtreeHeaders[i].m_quantizedAabbMin[2]; + + memPtr->m_rootNodeIndex = m_SubtreeHeaders[i].m_rootNodeIndex; + memPtr->m_subtreeSize = m_SubtreeHeaders[i].m_subtreeSize; + } + serializer->finalizeChunk(chunk, "btBvhSubtreeInfoData", BT_ARRAY_CODE, (void*)&m_SubtreeHeaders[0]); + } + return btQuantizedBvhDataName; +} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp.i new file mode 100644 index 00000000..d164783a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp ---------------- + +%include "BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp" + +%{ +#include "BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.h new file mode 100644 index 00000000..659a6ea1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.h @@ -0,0 +1,545 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_QUANTIZED_BVH_H +#define BT_QUANTIZED_BVH_H + +class btSerializer; + +//#define DEBUG_CHECK_DEQUANTIZATION 1 +#ifdef DEBUG_CHECK_DEQUANTIZATION +#ifdef __SPU__ +#define printf spu_printf +#endif //__SPU__ + +#include +#include +#endif //DEBUG_CHECK_DEQUANTIZATION + +#include "LinearMath/btVector3.h" +#include "LinearMath/btAlignedAllocator.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define btQuantizedBvhData btQuantizedBvhDoubleData +#define btOptimizedBvhNodeData btOptimizedBvhNodeDoubleData +#define btQuantizedBvhDataName "btQuantizedBvhDoubleData" +#else +#define btQuantizedBvhData btQuantizedBvhFloatData +#define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData +#define btQuantizedBvhDataName "btQuantizedBvhFloatData" +#endif + +//http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrf__m128.asp + +//Note: currently we have 16 bytes per quantized node +#define MAX_SUBTREE_SIZE_IN_BYTES 2048 + +// 10 gives the potential for 1024 parts, with at most 2^21 (2097152) (minus one +// 4 gives the potential for 16 parts, each with 2^27 triangles (134217728) +// actually) triangles each (since the sign bit is reserved +//#define MAX_NUM_PARTS_IN_BITS 10 +#define MAX_NUM_PARTS_IN_BITS 4 + +///btQuantizedBvhNode is a compressed aabb node, 16 bytes. +///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range). +ATTRIBUTE_ALIGNED16(struct) +btQuantizedBvhNode +{ + BT_DECLARE_ALIGNED_ALLOCATOR(); + + //12 bytes + unsigned short int m_quantizedAabbMin[3]; + unsigned short int m_quantizedAabbMax[3]; + //4 bytes + int m_escapeIndexOrTriangleIndex; + + bool isLeafNode() const + { + //skipindex is negative (internal node), triangleindex >=0 (leafnode) + return (m_escapeIndexOrTriangleIndex >= 0); + } + int getEscapeIndex() const + { + btAssert(!isLeafNode()); + return -m_escapeIndexOrTriangleIndex; + } + int getTriangleIndex() const + { + btAssert(isLeafNode()); + unsigned int x = 0; + unsigned int y = (~(x & 0)) << (31 - MAX_NUM_PARTS_IN_BITS); + // Get only the lower bits where the triangle index is stored + return (m_escapeIndexOrTriangleIndex & ~(y)); + } + int getPartId() const + { + btAssert(isLeafNode()); + // Get only the highest bits where the part index is stored + return (m_escapeIndexOrTriangleIndex >> (31 - MAX_NUM_PARTS_IN_BITS)); + } +}; + +/// btOptimizedBvhNode contains both internal and leaf node information. +/// Total node size is 44 bytes / node. You can use the compressed version of 16 bytes. +ATTRIBUTE_ALIGNED16(struct) +btOptimizedBvhNode +{ + BT_DECLARE_ALIGNED_ALLOCATOR(); + + //32 bytes + btVector3 m_aabbMinOrg; + btVector3 m_aabbMaxOrg; + + //4 + int m_escapeIndex; + + //8 + //for child nodes + int m_subPart; + int m_triangleIndex; + + //pad the size to 64 bytes + char m_padding[20]; +}; + +///btBvhSubtreeInfo provides info to gather a subtree of limited size +ATTRIBUTE_ALIGNED16(class) +btBvhSubtreeInfo +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + //12 bytes + unsigned short int m_quantizedAabbMin[3]; + unsigned short int m_quantizedAabbMax[3]; + //4 bytes, points to the root of the subtree + int m_rootNodeIndex; + //4 bytes + int m_subtreeSize; + int m_padding[3]; + + btBvhSubtreeInfo() + { + //memset(&m_padding[0], 0, sizeof(m_padding)); + } + + void setAabbFromQuantizeNode(const btQuantizedBvhNode& quantizedNode) + { + m_quantizedAabbMin[0] = quantizedNode.m_quantizedAabbMin[0]; + m_quantizedAabbMin[1] = quantizedNode.m_quantizedAabbMin[1]; + m_quantizedAabbMin[2] = quantizedNode.m_quantizedAabbMin[2]; + m_quantizedAabbMax[0] = quantizedNode.m_quantizedAabbMax[0]; + m_quantizedAabbMax[1] = quantizedNode.m_quantizedAabbMax[1]; + m_quantizedAabbMax[2] = quantizedNode.m_quantizedAabbMax[2]; + } +}; + +class btNodeOverlapCallback +{ +public: + virtual ~btNodeOverlapCallback(){}; + + virtual void processNode(int subPart, int triangleIndex) = 0; +}; + +#include "LinearMath/btAlignedAllocator.h" +#include "LinearMath/btAlignedObjectArray.h" + +///for code readability: +typedef btAlignedObjectArray NodeArray; +typedef btAlignedObjectArray QuantizedNodeArray; +typedef btAlignedObjectArray BvhSubtreeInfoArray; + +///The btQuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU. +///It is used by the btBvhTriangleMeshShape as midphase. +///It is recommended to use quantization for better performance and lower memory requirements. +ATTRIBUTE_ALIGNED16(class) +btQuantizedBvh +{ +public: + enum btTraversalMode + { + TRAVERSAL_STACKLESS = 0, + TRAVERSAL_STACKLESS_CACHE_FRIENDLY, + TRAVERSAL_RECURSIVE + }; + +protected: + btVector3 m_bvhAabbMin; + btVector3 m_bvhAabbMax; + btVector3 m_bvhQuantization; + + int m_bulletVersion; //for serialization versioning. It could also be used to detect endianess. + + int m_curNodeIndex; + //quantization data + bool m_useQuantization; + + NodeArray m_leafNodes; + NodeArray m_contiguousNodes; + QuantizedNodeArray m_quantizedLeafNodes; + QuantizedNodeArray m_quantizedContiguousNodes; + + btTraversalMode m_traversalMode; + BvhSubtreeInfoArray m_SubtreeHeaders; + + //This is only used for serialization so we don't have to add serialization directly to btAlignedObjectArray + mutable int m_subtreeHeaderCount; + + ///two versions, one for quantized and normal nodes. This allows code-reuse while maintaining readability (no template/macro!) + ///this might be refactored into a virtual, it is usually not calculated at run-time + void setInternalNodeAabbMin(int nodeIndex, const btVector3& aabbMin) + { + if (m_useQuantization) + { + quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0], aabbMin, 0); + } + else + { + m_contiguousNodes[nodeIndex].m_aabbMinOrg = aabbMin; + } + } + void setInternalNodeAabbMax(int nodeIndex, const btVector3& aabbMax) + { + if (m_useQuantization) + { + quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0], aabbMax, 1); + } + else + { + m_contiguousNodes[nodeIndex].m_aabbMaxOrg = aabbMax; + } + } + + btVector3 getAabbMin(int nodeIndex) const + { + if (m_useQuantization) + { + return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMin[0]); + } + //non-quantized + return m_leafNodes[nodeIndex].m_aabbMinOrg; + } + btVector3 getAabbMax(int nodeIndex) const + { + if (m_useQuantization) + { + return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMax[0]); + } + //non-quantized + return m_leafNodes[nodeIndex].m_aabbMaxOrg; + } + + void setInternalNodeEscapeIndex(int nodeIndex, int escapeIndex) + { + if (m_useQuantization) + { + m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex = -escapeIndex; + } + else + { + m_contiguousNodes[nodeIndex].m_escapeIndex = escapeIndex; + } + } + + void mergeInternalNodeAabb(int nodeIndex, const btVector3& newAabbMin, const btVector3& newAabbMax) + { + if (m_useQuantization) + { + unsigned short int quantizedAabbMin[3]; + unsigned short int quantizedAabbMax[3]; + quantize(quantizedAabbMin, newAabbMin, 0); + quantize(quantizedAabbMax, newAabbMax, 1); + for (int i = 0; i < 3; i++) + { + if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] > quantizedAabbMin[i]) + m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] = quantizedAabbMin[i]; + + if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] < quantizedAabbMax[i]) + m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] = quantizedAabbMax[i]; + } + } + else + { + //non-quantized + m_contiguousNodes[nodeIndex].m_aabbMinOrg.setMin(newAabbMin); + m_contiguousNodes[nodeIndex].m_aabbMaxOrg.setMax(newAabbMax); + } + } + + void swapLeafNodes(int firstIndex, int secondIndex); + + void assignInternalNodeFromLeafNode(int internalNode, int leafNodeIndex); + +protected: + void buildTree(int startIndex, int endIndex); + + int calcSplittingAxis(int startIndex, int endIndex); + + int sortAndCalcSplittingIndex(int startIndex, int endIndex, int splitAxis); + + void walkStacklessTree(btNodeOverlapCallback * nodeCallback, const btVector3& aabbMin, const btVector3& aabbMax) const; + + void walkStacklessQuantizedTreeAgainstRay(btNodeOverlapCallback * nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax, int startNodeIndex, int endNodeIndex) const; + void walkStacklessQuantizedTree(btNodeOverlapCallback * nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax, int startNodeIndex, int endNodeIndex) const; + void walkStacklessTreeAgainstRay(btNodeOverlapCallback * nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax, int startNodeIndex, int endNodeIndex) const; + + ///tree traversal designed for small-memory processors like PS3 SPU + void walkStacklessQuantizedTreeCacheFriendly(btNodeOverlapCallback * nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax) const; + + ///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal + void walkRecursiveQuantizedTreeAgainstQueryAabb(const btQuantizedBvhNode* currentNode, btNodeOverlapCallback* nodeCallback, unsigned short int* quantizedQueryAabbMin, unsigned short int* quantizedQueryAabbMax) const; + + ///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal + void walkRecursiveQuantizedTreeAgainstQuantizedTree(const btQuantizedBvhNode* treeNodeA, const btQuantizedBvhNode* treeNodeB, btNodeOverlapCallback* nodeCallback) const; + + void updateSubtreeHeaders(int leftChildNodexIndex, int rightChildNodexIndex); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btQuantizedBvh(); + + virtual ~btQuantizedBvh(); + + ///***************************************** expert/internal use only ************************* + void setQuantizationValues(const btVector3& bvhAabbMin, const btVector3& bvhAabbMax, btScalar quantizationMargin = btScalar(1.0)); + QuantizedNodeArray& getLeafNodeArray() { return m_quantizedLeafNodes; } + ///buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized + void buildInternal(); + ///***************************************** expert/internal use only ************************* + + void reportAabbOverlappingNodex(btNodeOverlapCallback * nodeCallback, const btVector3& aabbMin, const btVector3& aabbMax) const; + void reportRayOverlappingNodex(btNodeOverlapCallback * nodeCallback, const btVector3& raySource, const btVector3& rayTarget) const; + void reportBoxCastOverlappingNodex(btNodeOverlapCallback * nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax) const; + + SIMD_FORCE_INLINE void quantize(unsigned short* out, const btVector3& point, int isMax) const + { + btAssert(m_useQuantization); + + btAssert(point.getX() <= m_bvhAabbMax.getX()); + btAssert(point.getY() <= m_bvhAabbMax.getY()); + btAssert(point.getZ() <= m_bvhAabbMax.getZ()); + + btAssert(point.getX() >= m_bvhAabbMin.getX()); + btAssert(point.getY() >= m_bvhAabbMin.getY()); + btAssert(point.getZ() >= m_bvhAabbMin.getZ()); + + btVector3 v = (point - m_bvhAabbMin) * m_bvhQuantization; + ///Make sure rounding is done in a way that unQuantize(quantizeWithClamp(...)) is conservative + ///end-points always set the first bit, so that they are sorted properly (so that neighbouring AABBs overlap properly) + ///@todo: double-check this + if (isMax) + { + out[0] = (unsigned short)(((unsigned short)(v.getX() + btScalar(1.)) | 1)); + out[1] = (unsigned short)(((unsigned short)(v.getY() + btScalar(1.)) | 1)); + out[2] = (unsigned short)(((unsigned short)(v.getZ() + btScalar(1.)) | 1)); + } + else + { + out[0] = (unsigned short)(((unsigned short)(v.getX()) & 0xfffe)); + out[1] = (unsigned short)(((unsigned short)(v.getY()) & 0xfffe)); + out[2] = (unsigned short)(((unsigned short)(v.getZ()) & 0xfffe)); + } + +#ifdef DEBUG_CHECK_DEQUANTIZATION + btVector3 newPoint = unQuantize(out); + if (isMax) + { + if (newPoint.getX() < point.getX()) + { + printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.getX() - point.getX(), newPoint.getX(), point.getX()); + } + if (newPoint.getY() < point.getY()) + { + printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.getY() - point.getY(), newPoint.getY(), point.getY()); + } + if (newPoint.getZ() < point.getZ()) + { + printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.getZ() - point.getZ(), newPoint.getZ(), point.getZ()); + } + } + else + { + if (newPoint.getX() > point.getX()) + { + printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.getX() - point.getX(), newPoint.getX(), point.getX()); + } + if (newPoint.getY() > point.getY()) + { + printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.getY() - point.getY(), newPoint.getY(), point.getY()); + } + if (newPoint.getZ() > point.getZ()) + { + printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.getZ() - point.getZ(), newPoint.getZ(), point.getZ()); + } + } +#endif //DEBUG_CHECK_DEQUANTIZATION + } + + SIMD_FORCE_INLINE void quantizeWithClamp(unsigned short* out, const btVector3& point2, int isMax) const + { + btAssert(m_useQuantization); + + btVector3 clampedPoint(point2); + clampedPoint.setMax(m_bvhAabbMin); + clampedPoint.setMin(m_bvhAabbMax); + + quantize(out, clampedPoint, isMax); + } + + SIMD_FORCE_INLINE btVector3 unQuantize(const unsigned short* vecIn) const + { + btVector3 vecOut; + vecOut.setValue( + (btScalar)(vecIn[0]) / (m_bvhQuantization.getX()), + (btScalar)(vecIn[1]) / (m_bvhQuantization.getY()), + (btScalar)(vecIn[2]) / (m_bvhQuantization.getZ())); + vecOut += m_bvhAabbMin; + return vecOut; + } + + ///setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees. + void setTraversalMode(btTraversalMode traversalMode) + { + m_traversalMode = traversalMode; + } + + SIMD_FORCE_INLINE QuantizedNodeArray& getQuantizedNodeArray() + { + return m_quantizedContiguousNodes; + } + + SIMD_FORCE_INLINE BvhSubtreeInfoArray& getSubtreeInfoArray() + { + return m_SubtreeHeaders; + } + + //////////////////////////////////////////////////////////////////// + + /////Calculate space needed to store BVH for serialization + unsigned calculateSerializeBufferSize() const; + + /// Data buffer MUST be 16 byte aligned + virtual bool serialize(void* o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const; + + ///deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' + static btQuantizedBvh* deSerializeInPlace(void* i_alignedDataBuffer, unsigned int i_dataBufferSize, bool i_swapEndian); + + static unsigned int getAlignmentSerializationPadding(); + ////////////////////////////////////////////////////////////////////// + + virtual int calculateSerializeBufferSizeNew() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; + + virtual void deSerializeFloat(struct btQuantizedBvhFloatData & quantizedBvhFloatData); + + virtual void deSerializeDouble(struct btQuantizedBvhDoubleData & quantizedBvhDoubleData); + + //////////////////////////////////////////////////////////////////// + + SIMD_FORCE_INLINE bool isQuantized() + { + return m_useQuantization; + } + +private: + // Special "copy" constructor that allows for in-place deserialization + // Prevents btVector3's default constructor from being called, but doesn't inialize much else + // ownsMemory should most likely be false if deserializing, and if you are not, don't call this (it also changes the function signature, which we need) + btQuantizedBvh(btQuantizedBvh & other, bool ownsMemory); +}; + +// clang-format off +// parser needs * with the name +struct btBvhSubtreeInfoData +{ + int m_rootNodeIndex; + int m_subtreeSize; + unsigned short m_quantizedAabbMin[3]; + unsigned short m_quantizedAabbMax[3]; +}; + +struct btOptimizedBvhNodeFloatData +{ + btVector3FloatData m_aabbMinOrg; + btVector3FloatData m_aabbMaxOrg; + int m_escapeIndex; + int m_subPart; + int m_triangleIndex; + char m_pad[4]; +}; + +struct btOptimizedBvhNodeDoubleData +{ + btVector3DoubleData m_aabbMinOrg; + btVector3DoubleData m_aabbMaxOrg; + int m_escapeIndex; + int m_subPart; + int m_triangleIndex; + char m_pad[4]; +}; + + +struct btQuantizedBvhNodeData +{ + unsigned short m_quantizedAabbMin[3]; + unsigned short m_quantizedAabbMax[3]; + int m_escapeIndexOrTriangleIndex; +}; + +struct btQuantizedBvhFloatData +{ + btVector3FloatData m_bvhAabbMin; + btVector3FloatData m_bvhAabbMax; + btVector3FloatData m_bvhQuantization; + int m_curNodeIndex; + int m_useQuantization; + int m_numContiguousLeafNodes; + int m_numQuantizedContiguousNodes; + btOptimizedBvhNodeFloatData *m_contiguousNodesPtr; + btQuantizedBvhNodeData *m_quantizedContiguousNodesPtr; + btBvhSubtreeInfoData *m_subTreeInfoPtr; + int m_traversalMode; + int m_numSubtreeHeaders; + +}; + +struct btQuantizedBvhDoubleData +{ + btVector3DoubleData m_bvhAabbMin; + btVector3DoubleData m_bvhAabbMax; + btVector3DoubleData m_bvhQuantization; + int m_curNodeIndex; + int m_useQuantization; + int m_numContiguousLeafNodes; + int m_numQuantizedContiguousNodes; + btOptimizedBvhNodeDoubleData *m_contiguousNodesPtr; + btQuantizedBvhNodeData *m_quantizedContiguousNodesPtr; + + int m_traversalMode; + int m_numSubtreeHeaders; + btBvhSubtreeInfoData *m_subTreeInfoPtr; +}; +// clang-format on + +SIMD_FORCE_INLINE int btQuantizedBvh::calculateSerializeBufferSizeNew() const +{ + return sizeof(btQuantizedBvhData); +} + +#endif //BT_QUANTIZED_BVH_H diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.h.i new file mode 100644 index 00000000..4bec8817 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btQuantizedBvh.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btQuantizedBvh.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp new file mode 100644 index 00000000..bb02df89 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp @@ -0,0 +1,325 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btSimpleBroadphase.h" +#include "BulletCollision/BroadphaseCollision/btDispatcher.h" +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" + +#include "LinearMath/btVector3.h" +#include "LinearMath/btTransform.h" +#include "LinearMath/btMatrix3x3.h" +#include "LinearMath/btAabbUtil2.h" + +#include + +void btSimpleBroadphase::validate() +{ + for (int i = 0; i < m_numHandles; i++) + { + for (int j = i + 1; j < m_numHandles; j++) + { + btAssert(&m_pHandles[i] != &m_pHandles[j]); + } + } +} + +btSimpleBroadphase::btSimpleBroadphase(int maxProxies, btOverlappingPairCache* overlappingPairCache) + : m_pairCache(overlappingPairCache), + m_ownsPairCache(false), + m_invalidPair(0) +{ + if (!overlappingPairCache) + { + void* mem = btAlignedAlloc(sizeof(btHashedOverlappingPairCache), 16); + m_pairCache = new (mem) btHashedOverlappingPairCache(); + m_ownsPairCache = true; + } + + // allocate handles buffer and put all handles on free list + m_pHandlesRawPtr = btAlignedAlloc(sizeof(btSimpleBroadphaseProxy) * maxProxies, 16); + m_pHandles = new (m_pHandlesRawPtr) btSimpleBroadphaseProxy[maxProxies]; + m_maxHandles = maxProxies; + m_numHandles = 0; + m_firstFreeHandle = 0; + m_LastHandleIndex = -1; + + { + for (int i = m_firstFreeHandle; i < maxProxies; i++) + { + m_pHandles[i].SetNextFree(i + 1); + m_pHandles[i].m_uniqueId = i + 2; //any UID will do, we just avoid too trivial values (0,1) for debugging purposes + } + m_pHandles[maxProxies - 1].SetNextFree(0); + } +} + +btSimpleBroadphase::~btSimpleBroadphase() +{ + btAlignedFree(m_pHandlesRawPtr); + + if (m_ownsPairCache) + { + m_pairCache->~btOverlappingPairCache(); + btAlignedFree(m_pairCache); + } +} + +btBroadphaseProxy* btSimpleBroadphase::createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* /*dispatcher*/) +{ + if (m_numHandles >= m_maxHandles) + { + btAssert(0); + return 0; //should never happen, but don't let the game crash ;-) + } + btAssert(aabbMin[0] <= aabbMax[0] && aabbMin[1] <= aabbMax[1] && aabbMin[2] <= aabbMax[2]); + + int newHandleIndex = allocHandle(); + btSimpleBroadphaseProxy* proxy = new (&m_pHandles[newHandleIndex]) btSimpleBroadphaseProxy(aabbMin, aabbMax, shapeType, userPtr, collisionFilterGroup, collisionFilterMask); + + return proxy; +} + +class RemovingOverlapCallback : public btOverlapCallback +{ +protected: + virtual bool processOverlap(btBroadphasePair& pair) + { + (void)pair; + btAssert(0); + return false; + } +}; + +class RemovePairContainingProxy +{ + btBroadphaseProxy* m_targetProxy; + +public: + virtual ~RemovePairContainingProxy() + { + } + +protected: + virtual bool processOverlap(btBroadphasePair& pair) + { + btSimpleBroadphaseProxy* proxy0 = static_cast(pair.m_pProxy0); + btSimpleBroadphaseProxy* proxy1 = static_cast(pair.m_pProxy1); + + return ((m_targetProxy == proxy0 || m_targetProxy == proxy1)); + }; +}; + +void btSimpleBroadphase::destroyProxy(btBroadphaseProxy* proxyOrg, btDispatcher* dispatcher) +{ + m_pairCache->removeOverlappingPairsContainingProxy(proxyOrg, dispatcher); + + btSimpleBroadphaseProxy* proxy0 = static_cast(proxyOrg); + freeHandle(proxy0); + + //validate(); +} + +void btSimpleBroadphase::getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const +{ + const btSimpleBroadphaseProxy* sbp = getSimpleProxyFromProxy(proxy); + aabbMin = sbp->m_aabbMin; + aabbMax = sbp->m_aabbMax; +} + +void btSimpleBroadphase::setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* /*dispatcher*/) +{ + btSimpleBroadphaseProxy* sbp = getSimpleProxyFromProxy(proxy); + sbp->m_aabbMin = aabbMin; + sbp->m_aabbMax = aabbMax; +} + +void btSimpleBroadphase::rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin, const btVector3& aabbMax) +{ + for (int i = 0; i <= m_LastHandleIndex; i++) + { + btSimpleBroadphaseProxy* proxy = &m_pHandles[i]; + if (!proxy->m_clientObject) + { + continue; + } + rayCallback.process(proxy); + } +} + +void btSimpleBroadphase::aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback) +{ + for (int i = 0; i <= m_LastHandleIndex; i++) + { + btSimpleBroadphaseProxy* proxy = &m_pHandles[i]; + if (!proxy->m_clientObject) + { + continue; + } + if (TestAabbAgainstAabb2(aabbMin, aabbMax, proxy->m_aabbMin, proxy->m_aabbMax)) + { + callback.process(proxy); + } + } +} + +bool btSimpleBroadphase::aabbOverlap(btSimpleBroadphaseProxy* proxy0, btSimpleBroadphaseProxy* proxy1) +{ + return proxy0->m_aabbMin[0] <= proxy1->m_aabbMax[0] && proxy1->m_aabbMin[0] <= proxy0->m_aabbMax[0] && + proxy0->m_aabbMin[1] <= proxy1->m_aabbMax[1] && proxy1->m_aabbMin[1] <= proxy0->m_aabbMax[1] && + proxy0->m_aabbMin[2] <= proxy1->m_aabbMax[2] && proxy1->m_aabbMin[2] <= proxy0->m_aabbMax[2]; +} + +//then remove non-overlapping ones +class CheckOverlapCallback : public btOverlapCallback +{ +public: + virtual bool processOverlap(btBroadphasePair& pair) + { + return (!btSimpleBroadphase::aabbOverlap(static_cast(pair.m_pProxy0), static_cast(pair.m_pProxy1))); + } +}; + +void btSimpleBroadphase::calculateOverlappingPairs(btDispatcher* dispatcher) +{ + //first check for new overlapping pairs + int i, j; + if (m_numHandles >= 0) + { + int new_largest_index = -1; + for (i = 0; i <= m_LastHandleIndex; i++) + { + btSimpleBroadphaseProxy* proxy0 = &m_pHandles[i]; + if (!proxy0->m_clientObject) + { + continue; + } + new_largest_index = i; + for (j = i + 1; j <= m_LastHandleIndex; j++) + { + btSimpleBroadphaseProxy* proxy1 = &m_pHandles[j]; + btAssert(proxy0 != proxy1); + if (!proxy1->m_clientObject) + { + continue; + } + + btSimpleBroadphaseProxy* p0 = getSimpleProxyFromProxy(proxy0); + btSimpleBroadphaseProxy* p1 = getSimpleProxyFromProxy(proxy1); + + if (aabbOverlap(p0, p1)) + { + if (!m_pairCache->findPair(proxy0, proxy1)) + { + m_pairCache->addOverlappingPair(proxy0, proxy1); + } + } + else + { + if (!m_pairCache->hasDeferredRemoval()) + { + if (m_pairCache->findPair(proxy0, proxy1)) + { + m_pairCache->removeOverlappingPair(proxy0, proxy1, dispatcher); + } + } + } + } + } + + m_LastHandleIndex = new_largest_index; + + if (m_ownsPairCache && m_pairCache->hasDeferredRemoval()) + { + btBroadphasePairArray& overlappingPairArray = m_pairCache->getOverlappingPairArray(); + + //perform a sort, to find duplicates and to sort 'invalid' pairs to the end + overlappingPairArray.quickSort(btBroadphasePairSortPredicate()); + + overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair); + m_invalidPair = 0; + + btBroadphasePair previousPair; + previousPair.m_pProxy0 = 0; + previousPair.m_pProxy1 = 0; + previousPair.m_algorithm = 0; + + for (i = 0; i < overlappingPairArray.size(); i++) + { + btBroadphasePair& pair = overlappingPairArray[i]; + + bool isDuplicate = (pair == previousPair); + + previousPair = pair; + + bool needsRemoval = false; + + if (!isDuplicate) + { + bool hasOverlap = testAabbOverlap(pair.m_pProxy0, pair.m_pProxy1); + + if (hasOverlap) + { + needsRemoval = false; //callback->processOverlap(pair); + } + else + { + needsRemoval = true; + } + } + else + { + //remove duplicate + needsRemoval = true; + //should have no algorithm + btAssert(!pair.m_algorithm); + } + + if (needsRemoval) + { + m_pairCache->cleanOverlappingPair(pair, dispatcher); + + // m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1); + // m_overlappingPairArray.pop_back(); + pair.m_pProxy0 = 0; + pair.m_pProxy1 = 0; + m_invalidPair++; + } + } + + ///if you don't like to skip the invalid pairs in the array, execute following code: +#define CLEAN_INVALID_PAIRS 1 +#ifdef CLEAN_INVALID_PAIRS + + //perform a sort, to sort 'invalid' pairs to the end + overlappingPairArray.quickSort(btBroadphasePairSortPredicate()); + + overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair); + m_invalidPair = 0; +#endif //CLEAN_INVALID_PAIRS + } + } +} + +bool btSimpleBroadphase::testAabbOverlap(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) +{ + btSimpleBroadphaseProxy* p0 = getSimpleProxyFromProxy(proxy0); + btSimpleBroadphaseProxy* p1 = getSimpleProxyFromProxy(proxy1); + return aabbOverlap(p0, p1); +} + +void btSimpleBroadphase::resetPool(btDispatcher* dispatcher) +{ + //not yet +} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp.i new file mode 100644 index 00000000..faceb6b2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp ---------------- + +%include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp" + +%{ +#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h new file mode 100644 index 00000000..f97073c5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h @@ -0,0 +1,148 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SIMPLE_BROADPHASE_H +#define BT_SIMPLE_BROADPHASE_H + +#include "btOverlappingPairCache.h" + +struct btSimpleBroadphaseProxy : public btBroadphaseProxy +{ + int m_nextFree; + + // int m_handleId; + + btSimpleBroadphaseProxy(){}; + + btSimpleBroadphaseProxy(const btVector3& minpt, const btVector3& maxpt, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask) + : btBroadphaseProxy(minpt, maxpt, userPtr, collisionFilterGroup, collisionFilterMask) + { + (void)shapeType; + } + + SIMD_FORCE_INLINE void SetNextFree(int next) { m_nextFree = next; } + SIMD_FORCE_INLINE int GetNextFree() const { return m_nextFree; } +}; + +///The SimpleBroadphase is just a unit-test for btAxisSweep3, bt32BitAxisSweep3, or btDbvtBroadphase, so use those classes instead. +///It is a brute force aabb culling broadphase based on O(n^2) aabb checks +class btSimpleBroadphase : public btBroadphaseInterface +{ +protected: + int m_numHandles; // number of active handles + int m_maxHandles; // max number of handles + int m_LastHandleIndex; + + btSimpleBroadphaseProxy* m_pHandles; // handles pool + + void* m_pHandlesRawPtr; + int m_firstFreeHandle; // free handles list + + int allocHandle() + { + btAssert(m_numHandles < m_maxHandles); + int freeHandle = m_firstFreeHandle; + m_firstFreeHandle = m_pHandles[freeHandle].GetNextFree(); + m_numHandles++; + if (freeHandle > m_LastHandleIndex) + { + m_LastHandleIndex = freeHandle; + } + return freeHandle; + } + + void freeHandle(btSimpleBroadphaseProxy* proxy) + { + int handle = int(proxy - m_pHandles); + btAssert(handle >= 0 && handle < m_maxHandles); + if (handle == m_LastHandleIndex) + { + m_LastHandleIndex--; + } + proxy->SetNextFree(m_firstFreeHandle); + m_firstFreeHandle = handle; + + proxy->m_clientObject = 0; + + m_numHandles--; + } + + btOverlappingPairCache* m_pairCache; + bool m_ownsPairCache; + + int m_invalidPair; + + inline btSimpleBroadphaseProxy* getSimpleProxyFromProxy(btBroadphaseProxy* proxy) + { + btSimpleBroadphaseProxy* proxy0 = static_cast(proxy); + return proxy0; + } + + inline const btSimpleBroadphaseProxy* getSimpleProxyFromProxy(btBroadphaseProxy* proxy) const + { + const btSimpleBroadphaseProxy* proxy0 = static_cast(proxy); + return proxy0; + } + + ///reset broadphase internal structures, to ensure determinism/reproducability + virtual void resetPool(btDispatcher* dispatcher); + + void validate(); + +protected: +public: + btSimpleBroadphase(int maxProxies = 16384, btOverlappingPairCache* overlappingPairCache = 0); + virtual ~btSimpleBroadphase(); + + static bool aabbOverlap(btSimpleBroadphaseProxy* proxy0, btSimpleBroadphaseProxy* proxy1); + + virtual btBroadphaseProxy* createProxy(const btVector3& aabbMin, const btVector3& aabbMax, int shapeType, void* userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher* dispatcher); + + virtual void calculateOverlappingPairs(btDispatcher* dispatcher); + + virtual void destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher); + virtual void setAabb(btBroadphaseProxy* proxy, const btVector3& aabbMin, const btVector3& aabbMax, btDispatcher* dispatcher); + virtual void getAabb(btBroadphaseProxy* proxy, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin = btVector3(0, 0, 0), const btVector3& aabbMax = btVector3(0, 0, 0)); + virtual void aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback); + + btOverlappingPairCache* getOverlappingPairCache() + { + return m_pairCache; + } + const btOverlappingPairCache* getOverlappingPairCache() const + { + return m_pairCache; + } + + bool testAabbOverlap(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1); + + ///getAabb returns the axis aligned bounding box in the 'global' coordinate frame + ///will add some transform later + virtual void getBroadphaseAabb(btVector3& aabbMin, btVector3& aabbMax) const + { + aabbMin.setValue(-BT_LARGE_FLOAT, -BT_LARGE_FLOAT, -BT_LARGE_FLOAT); + aabbMax.setValue(BT_LARGE_FLOAT, BT_LARGE_FLOAT, BT_LARGE_FLOAT); + } + + virtual void printStats() + { + // printf("btSimpleBroadphase.h\n"); + // printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_maxHandles); + } +}; + +#endif //BT_SIMPLE_BROADPHASE_H diff --git a/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h.i b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h.i new file mode 100644 index 00000000..af965131 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/BroadphaseCollision/btSimpleBroadphase.h ---------------- + +%include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h" + +%{ +#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp new file mode 100644 index 00000000..57152105 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp @@ -0,0 +1,215 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "LinearMath/btScalar.h" +#include "SphereTriangleDetector.h" +#include "BulletCollision/CollisionShapes/btTriangleShape.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" + +SphereTriangleDetector::SphereTriangleDetector(btSphereShape* sphere, btTriangleShape* triangle, btScalar contactBreakingThreshold) + : m_sphere(sphere), + m_triangle(triangle), + m_contactBreakingThreshold(contactBreakingThreshold) +{ +} + +void SphereTriangleDetector::getClosestPoints(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw, bool swapResults) +{ + (void)debugDraw; + const btTransform& transformA = input.m_transformA; + const btTransform& transformB = input.m_transformB; + + btVector3 point, normal; + btScalar timeOfImpact = btScalar(1.); + btScalar depth = btScalar(0.); + // output.m_distance = btScalar(BT_LARGE_FLOAT); + //move sphere into triangle space + btTransform sphereInTr = transformB.inverseTimes(transformA); + + if (collide(sphereInTr.getOrigin(), point, normal, depth, timeOfImpact, m_contactBreakingThreshold)) + { + if (swapResults) + { + btVector3 normalOnB = transformB.getBasis() * normal; + btVector3 normalOnA = -normalOnB; + btVector3 pointOnA = transformB * point + normalOnB * depth; + output.addContactPoint(normalOnA, pointOnA, depth); + } + else + { + output.addContactPoint(transformB.getBasis() * normal, transformB * point, depth); + } + } +} + +// See also geometrictools.com +// Basic idea: D = |p - (lo + t0*lv)| where t0 = lv . (p - lo) / lv . lv +btScalar SegmentSqrDistance(const btVector3& from, const btVector3& to, const btVector3& p, btVector3& nearest); + +btScalar SegmentSqrDistance(const btVector3& from, const btVector3& to, const btVector3& p, btVector3& nearest) +{ + btVector3 diff = p - from; + btVector3 v = to - from; + btScalar t = v.dot(diff); + + if (t > 0) + { + btScalar dotVV = v.dot(v); + if (t < dotVV) + { + t /= dotVV; + diff -= t * v; + } + else + { + t = 1; + diff -= v; + } + } + else + t = 0; + + nearest = from + t * v; + return diff.dot(diff); +} + +bool SphereTriangleDetector::facecontains(const btVector3& p, const btVector3* vertices, btVector3& normal) +{ + btVector3 lp(p); + btVector3 lnormal(normal); + + return pointInTriangle(vertices, lnormal, &lp); +} + +bool SphereTriangleDetector::collide(const btVector3& sphereCenter, btVector3& point, btVector3& resultNormal, btScalar& depth, btScalar& timeOfImpact, btScalar contactBreakingThreshold) +{ + const btVector3* vertices = &m_triangle->getVertexPtr(0); + + btScalar radius = m_sphere->getRadius(); + btScalar radiusWithThreshold = radius + contactBreakingThreshold; + + btVector3 normal = (vertices[1] - vertices[0]).cross(vertices[2] - vertices[0]); + + btScalar l2 = normal.length2(); + bool hasContact = false; + btVector3 contactPoint; + + if (l2 >= SIMD_EPSILON * SIMD_EPSILON) + { + normal /= btSqrt(l2); + + btVector3 p1ToCentre = sphereCenter - vertices[0]; + btScalar distanceFromPlane = p1ToCentre.dot(normal); + + if (distanceFromPlane < btScalar(0.)) + { + //triangle facing the other way + distanceFromPlane *= btScalar(-1.); + normal *= btScalar(-1.); + } + + bool isInsideContactPlane = distanceFromPlane < radiusWithThreshold; + + // Check for contact / intersection + + if (isInsideContactPlane) + { + if (facecontains(sphereCenter, vertices, normal)) + { + // Inside the contact wedge - touches a point on the shell plane + hasContact = true; + contactPoint = sphereCenter - normal * distanceFromPlane; + } + else + { + // Could be inside one of the contact capsules + btScalar contactCapsuleRadiusSqr = radiusWithThreshold * radiusWithThreshold; + btScalar minDistSqr = contactCapsuleRadiusSqr; + btVector3 nearestOnEdge; + for (int i = 0; i < m_triangle->getNumEdges(); i++) + { + btVector3 pa; + btVector3 pb; + + m_triangle->getEdge(i, pa, pb); + + btScalar distanceSqr = SegmentSqrDistance(pa, pb, sphereCenter, nearestOnEdge); + if (distanceSqr < minDistSqr) + { + // Yep, we're inside a capsule, and record the capsule with smallest distance + minDistSqr = distanceSqr; + hasContact = true; + contactPoint = nearestOnEdge; + } + } + } + } + } + + if (hasContact) + { + btVector3 contactToCentre = sphereCenter - contactPoint; + btScalar distanceSqr = contactToCentre.length2(); + + if (distanceSqr < radiusWithThreshold * radiusWithThreshold) + { + if (distanceSqr > SIMD_EPSILON) + { + btScalar distance = btSqrt(distanceSqr); + resultNormal = contactToCentre; + resultNormal.normalize(); + point = contactPoint; + depth = -(radius - distance); + } + else + { + resultNormal = normal; + point = contactPoint; + depth = -radius; + } + return true; + } + } + + return false; +} + +bool SphereTriangleDetector::pointInTriangle(const btVector3 vertices[], const btVector3& normal, btVector3* p) +{ + const btVector3* p1 = &vertices[0]; + const btVector3* p2 = &vertices[1]; + const btVector3* p3 = &vertices[2]; + + btVector3 edge1(*p2 - *p1); + btVector3 edge2(*p3 - *p2); + btVector3 edge3(*p1 - *p3); + + btVector3 p1_to_p(*p - *p1); + btVector3 p2_to_p(*p - *p2); + btVector3 p3_to_p(*p - *p3); + + btVector3 edge1_normal(edge1.cross(normal)); + btVector3 edge2_normal(edge2.cross(normal)); + btVector3 edge3_normal(edge3.cross(normal)); + + btScalar r1, r2, r3; + r1 = edge1_normal.dot(p1_to_p); + r2 = edge2_normal.dot(p2_to_p); + r3 = edge3_normal.dot(p3_to_p); + if ((r1 > 0 && r2 > 0 && r3 > 0) || + (r1 <= 0 && r2 <= 0 && r3 <= 0)) + return true; + return false; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp.i new file mode 100644 index 00000000..22bfcbb9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.h new file mode 100644 index 00000000..01ebfe44 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.h @@ -0,0 +1,43 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SPHERE_TRIANGLE_DETECTOR_H +#define BT_SPHERE_TRIANGLE_DETECTOR_H + +#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" + +class btSphereShape; +class btTriangleShape; + +/// sphere-triangle to match the btDiscreteCollisionDetectorInterface +struct SphereTriangleDetector : public btDiscreteCollisionDetectorInterface +{ + virtual void getClosestPoints(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw, bool swapResults = false); + + SphereTriangleDetector(btSphereShape* sphere, btTriangleShape* triangle, btScalar contactBreakingThreshold); + + virtual ~SphereTriangleDetector(){}; + + bool collide(const btVector3& sphereCenter, btVector3& point, btVector3& resultNormal, btScalar& depth, btScalar& timeOfImpact, btScalar contactBreakingThreshold); + +private: + bool pointInTriangle(const btVector3 vertices[], const btVector3& normal, btVector3* p); + bool facecontains(const btVector3& p, const btVector3* vertices, btVector3& normal); + + btSphereShape* m_sphere; + btTriangleShape* m_triangle; + btScalar m_contactBreakingThreshold; +}; +#endif //BT_SPHERE_TRIANGLE_DETECTOR_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.h.i new file mode 100644 index 00000000..571150a0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/SphereTriangleDetector.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/SphereTriangleDetector.h ---------------- + +%include "BulletCollision/CollisionDispatch/SphereTriangleDetector.h" + +%{ +#include "BulletCollision/CollisionDispatch/SphereTriangleDetector.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp new file mode 100644 index 00000000..ac5de45d --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp @@ -0,0 +1,47 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btActivatingCollisionAlgorithm.h" +#include "btCollisionDispatcher.h" +#include "btCollisionObject.h" + +btActivatingCollisionAlgorithm::btActivatingCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci) + : btCollisionAlgorithm(ci) +//, +//m_colObj0(0), +//m_colObj1(0) +{ +} +btActivatingCollisionAlgorithm::btActivatingCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper*, const btCollisionObjectWrapper*) + : btCollisionAlgorithm(ci) +//, +//m_colObj0(0), +//m_colObj1(0) +{ + // if (ci.m_dispatcher1->needsCollision(colObj0,colObj1)) + // { + // m_colObj0 = colObj0; + // m_colObj1 = colObj1; + // + // m_colObj0->activate(); + // m_colObj1->activate(); + // } +} + +btActivatingCollisionAlgorithm::~btActivatingCollisionAlgorithm() +{ + // m_colObj0->activate(); + // m_colObj1->activate(); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..e65e8c73 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h new file mode 100644 index 00000000..86206057 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h @@ -0,0 +1,35 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H +#define __BT_ACTIVATING_COLLISION_ALGORITHM_H + +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" + +///This class is not enabled yet (work-in-progress) to more aggressively activate objects. +class btActivatingCollisionAlgorithm : public btCollisionAlgorithm +{ + // btCollisionObject* m_colObj0; + // btCollisionObject* m_colObj1; + +protected: + btActivatingCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci); + + btActivatingCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap); + +public: + virtual ~btActivatingCollisionAlgorithm(); +}; +#endif //__BT_ACTIVATING_COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h.i new file mode 100644 index 00000000..6d28fe77 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp new file mode 100644 index 00000000..6873a95d --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp @@ -0,0 +1,411 @@ +/* +Bullet Continuous Collision Detection and Physics Library +* The b2CollidePolygons routines are Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///btBox2dBox2dCollisionAlgorithm, with modified b2CollidePolygons routines from the Box2D library. +///The modifications include: switching from b2Vec to btVector3, redefinition of b2Dot, b2Cross + +#include "btBox2dBox2dCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/CollisionShapes/btBoxShape.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionDispatch/btBoxBoxDetector.h" +#include "BulletCollision/CollisionShapes/btBox2dShape.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +#define USE_PERSISTENT_CONTACTS 1 + +btBox2dBox2dCollisionAlgorithm::btBox2dBox2dCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* obj0Wrap, const btCollisionObjectWrapper* obj1Wrap) + : btActivatingCollisionAlgorithm(ci, obj0Wrap, obj1Wrap), + m_ownManifold(false), + m_manifoldPtr(mf) +{ + if (!m_manifoldPtr && m_dispatcher->needsCollision(obj0Wrap->getCollisionObject(), obj1Wrap->getCollisionObject())) + { + m_manifoldPtr = m_dispatcher->getNewManifold(obj0Wrap->getCollisionObject(), obj1Wrap->getCollisionObject()); + m_ownManifold = true; + } +} + +btBox2dBox2dCollisionAlgorithm::~btBox2dBox2dCollisionAlgorithm() +{ + if (m_ownManifold) + { + if (m_manifoldPtr) + m_dispatcher->releaseManifold(m_manifoldPtr); + } +} + +void b2CollidePolygons(btManifoldResult* manifold, const btBox2dShape* polyA, const btTransform& xfA, const btBox2dShape* polyB, const btTransform& xfB); + +//#include +void btBox2dBox2dCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + if (!m_manifoldPtr) + return; + + const btBox2dShape* box0 = (const btBox2dShape*)body0Wrap->getCollisionShape(); + const btBox2dShape* box1 = (const btBox2dShape*)body1Wrap->getCollisionShape(); + + resultOut->setPersistentManifold(m_manifoldPtr); + + b2CollidePolygons(resultOut, box0, body0Wrap->getWorldTransform(), box1, body1Wrap->getWorldTransform()); + + // refreshContactPoints is only necessary when using persistent contact points. otherwise all points are newly added + if (m_ownManifold) + { + resultOut->refreshContactPoints(); + } +} + +btScalar btBox2dBox2dCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* /*body0*/, btCollisionObject* /*body1*/, const btDispatcherInfo& /*dispatchInfo*/, btManifoldResult* /*resultOut*/) +{ + //not yet + return 1.f; +} + +struct ClipVertex +{ + btVector3 v; + int id; + //b2ContactID id; + //b2ContactID id; +}; + +#define b2Dot(a, b) (a).dot(b) +#define b2Mul(a, b) (a) * (b) +#define b2MulT(a, b) (a).transpose() * (b) +#define b2Cross(a, b) (a).cross(b) +#define btCrossS(a, s) btVector3(s* a.getY(), -s* a.getX(), 0.f) + +int b2_maxManifoldPoints = 2; + +static int ClipSegmentToLine(ClipVertex vOut[2], ClipVertex vIn[2], + const btVector3& normal, btScalar offset) +{ + // Start with no output points + int numOut = 0; + + // Calculate the distance of end points to the line + btScalar distance0 = b2Dot(normal, vIn[0].v) - offset; + btScalar distance1 = b2Dot(normal, vIn[1].v) - offset; + + // If the points are behind the plane + if (distance0 <= 0.0f) vOut[numOut++] = vIn[0]; + if (distance1 <= 0.0f) vOut[numOut++] = vIn[1]; + + // If the points are on different sides of the plane + if (distance0 * distance1 < 0.0f) + { + // Find intersection point of edge and plane + btScalar interp = distance0 / (distance0 - distance1); + vOut[numOut].v = vIn[0].v + interp * (vIn[1].v - vIn[0].v); + if (distance0 > 0.0f) + { + vOut[numOut].id = vIn[0].id; + } + else + { + vOut[numOut].id = vIn[1].id; + } + ++numOut; + } + + return numOut; +} + +// Find the separation between poly1 and poly2 for a give edge normal on poly1. +static btScalar EdgeSeparation(const btBox2dShape* poly1, const btTransform& xf1, int edge1, + const btBox2dShape* poly2, const btTransform& xf2) +{ + const btVector3* vertices1 = poly1->getVertices(); + const btVector3* normals1 = poly1->getNormals(); + + int count2 = poly2->getVertexCount(); + const btVector3* vertices2 = poly2->getVertices(); + + btAssert(0 <= edge1 && edge1 < poly1->getVertexCount()); + + // Convert normal from poly1's frame into poly2's frame. + btVector3 normal1World = b2Mul(xf1.getBasis(), normals1[edge1]); + btVector3 normal1 = b2MulT(xf2.getBasis(), normal1World); + + // Find support vertex on poly2 for -normal. + int index = 0; + btScalar minDot = BT_LARGE_FLOAT; + + if (count2 > 0) + index = (int)normal1.minDot(vertices2, count2, minDot); + + btVector3 v1 = b2Mul(xf1, vertices1[edge1]); + btVector3 v2 = b2Mul(xf2, vertices2[index]); + btScalar separation = b2Dot(v2 - v1, normal1World); + return separation; +} + +// Find the max separation between poly1 and poly2 using edge normals from poly1. +static btScalar FindMaxSeparation(int* edgeIndex, + const btBox2dShape* poly1, const btTransform& xf1, + const btBox2dShape* poly2, const btTransform& xf2) +{ + int count1 = poly1->getVertexCount(); + const btVector3* normals1 = poly1->getNormals(); + + // Vector pointing from the centroid of poly1 to the centroid of poly2. + btVector3 d = b2Mul(xf2, poly2->getCentroid()) - b2Mul(xf1, poly1->getCentroid()); + btVector3 dLocal1 = b2MulT(xf1.getBasis(), d); + + // Find edge normal on poly1 that has the largest projection onto d. + int edge = 0; + btScalar maxDot; + if (count1 > 0) + edge = (int)dLocal1.maxDot(normals1, count1, maxDot); + + // Get the separation for the edge normal. + btScalar s = EdgeSeparation(poly1, xf1, edge, poly2, xf2); + if (s > 0.0f) + { + return s; + } + + // Check the separation for the previous edge normal. + int prevEdge = edge - 1 >= 0 ? edge - 1 : count1 - 1; + btScalar sPrev = EdgeSeparation(poly1, xf1, prevEdge, poly2, xf2); + if (sPrev > 0.0f) + { + return sPrev; + } + + // Check the separation for the next edge normal. + int nextEdge = edge + 1 < count1 ? edge + 1 : 0; + btScalar sNext = EdgeSeparation(poly1, xf1, nextEdge, poly2, xf2); + if (sNext > 0.0f) + { + return sNext; + } + + // Find the best edge and the search direction. + int bestEdge; + btScalar bestSeparation; + int increment; + if (sPrev > s && sPrev > sNext) + { + increment = -1; + bestEdge = prevEdge; + bestSeparation = sPrev; + } + else if (sNext > s) + { + increment = 1; + bestEdge = nextEdge; + bestSeparation = sNext; + } + else + { + *edgeIndex = edge; + return s; + } + + // Perform a local search for the best edge normal. + for (;;) + { + if (increment == -1) + edge = bestEdge - 1 >= 0 ? bestEdge - 1 : count1 - 1; + else + edge = bestEdge + 1 < count1 ? bestEdge + 1 : 0; + + s = EdgeSeparation(poly1, xf1, edge, poly2, xf2); + if (s > 0.0f) + { + return s; + } + + if (s > bestSeparation) + { + bestEdge = edge; + bestSeparation = s; + } + else + { + break; + } + } + + *edgeIndex = bestEdge; + return bestSeparation; +} + +static void FindIncidentEdge(ClipVertex c[2], + const btBox2dShape* poly1, const btTransform& xf1, int edge1, + const btBox2dShape* poly2, const btTransform& xf2) +{ + const btVector3* normals1 = poly1->getNormals(); + + int count2 = poly2->getVertexCount(); + const btVector3* vertices2 = poly2->getVertices(); + const btVector3* normals2 = poly2->getNormals(); + + btAssert(0 <= edge1 && edge1 < poly1->getVertexCount()); + + // Get the normal of the reference edge in poly2's frame. + btVector3 normal1 = b2MulT(xf2.getBasis(), b2Mul(xf1.getBasis(), normals1[edge1])); + + // Find the incident edge on poly2. + int index = 0; + btScalar minDot = BT_LARGE_FLOAT; + for (int i = 0; i < count2; ++i) + { + btScalar dot = b2Dot(normal1, normals2[i]); + if (dot < minDot) + { + minDot = dot; + index = i; + } + } + + // Build the clip vertices for the incident edge. + int i1 = index; + int i2 = i1 + 1 < count2 ? i1 + 1 : 0; + + c[0].v = b2Mul(xf2, vertices2[i1]); + // c[0].id.features.referenceEdge = (unsigned char)edge1; + // c[0].id.features.incidentEdge = (unsigned char)i1; + // c[0].id.features.incidentVertex = 0; + + c[1].v = b2Mul(xf2, vertices2[i2]); + // c[1].id.features.referenceEdge = (unsigned char)edge1; + // c[1].id.features.incidentEdge = (unsigned char)i2; + // c[1].id.features.incidentVertex = 1; +} + +// Find edge normal of max separation on A - return if separating axis is found +// Find edge normal of max separation on B - return if separation axis is found +// Choose reference edge as min(minA, minB) +// Find incident edge +// Clip + +// The normal points from 1 to 2 +void b2CollidePolygons(btManifoldResult* manifold, + const btBox2dShape* polyA, const btTransform& xfA, + const btBox2dShape* polyB, const btTransform& xfB) +{ + int edgeA = 0; + btScalar separationA = FindMaxSeparation(&edgeA, polyA, xfA, polyB, xfB); + if (separationA > 0.0f) + return; + + int edgeB = 0; + btScalar separationB = FindMaxSeparation(&edgeB, polyB, xfB, polyA, xfA); + if (separationB > 0.0f) + return; + + const btBox2dShape* poly1; // reference poly + const btBox2dShape* poly2; // incident poly + btTransform xf1, xf2; + int edge1; // reference edge + unsigned char flip; + const btScalar k_relativeTol = 0.98f; + const btScalar k_absoluteTol = 0.001f; + + // TODO_ERIN use "radius" of poly for absolute tolerance. + if (separationB > k_relativeTol * separationA + k_absoluteTol) + { + poly1 = polyB; + poly2 = polyA; + xf1 = xfB; + xf2 = xfA; + edge1 = edgeB; + flip = 1; + } + else + { + poly1 = polyA; + poly2 = polyB; + xf1 = xfA; + xf2 = xfB; + edge1 = edgeA; + flip = 0; + } + + ClipVertex incidentEdge[2]; + FindIncidentEdge(incidentEdge, poly1, xf1, edge1, poly2, xf2); + + int count1 = poly1->getVertexCount(); + const btVector3* vertices1 = poly1->getVertices(); + + btVector3 v11 = vertices1[edge1]; + btVector3 v12 = edge1 + 1 < count1 ? vertices1[edge1 + 1] : vertices1[0]; + + //btVector3 dv = v12 - v11; + btVector3 sideNormal = b2Mul(xf1.getBasis(), v12 - v11); + sideNormal.normalize(); + btVector3 frontNormal = btCrossS(sideNormal, 1.0f); + + v11 = b2Mul(xf1, v11); + v12 = b2Mul(xf1, v12); + + btScalar frontOffset = b2Dot(frontNormal, v11); + btScalar sideOffset1 = -b2Dot(sideNormal, v11); + btScalar sideOffset2 = b2Dot(sideNormal, v12); + + // Clip incident edge against extruded edge1 side edges. + ClipVertex clipPoints1[2]; + clipPoints1[0].v.setValue(0, 0, 0); + clipPoints1[1].v.setValue(0, 0, 0); + + ClipVertex clipPoints2[2]; + clipPoints2[0].v.setValue(0, 0, 0); + clipPoints2[1].v.setValue(0, 0, 0); + + int np; + + // Clip to box side 1 + np = ClipSegmentToLine(clipPoints1, incidentEdge, -sideNormal, sideOffset1); + + if (np < 2) + return; + + // Clip to negative box side 1 + np = ClipSegmentToLine(clipPoints2, clipPoints1, sideNormal, sideOffset2); + + if (np < 2) + { + return; + } + + // Now clipPoints2 contains the clipped points. + btVector3 manifoldNormal = flip ? -frontNormal : frontNormal; + + int pointCount = 0; + for (int i = 0; i < b2_maxManifoldPoints; ++i) + { + btScalar separation = b2Dot(frontNormal, clipPoints2[i].v) - frontOffset; + + if (separation <= 0.0f) + { + //b2ManifoldPoint* cp = manifold->points + pointCount; + //btScalar separation = separation; + //cp->localPoint1 = b2MulT(xfA, clipPoints2[i].v); + //cp->localPoint2 = b2MulT(xfB, clipPoints2[i].v); + + manifold->addContactPoint(-manifoldNormal, clipPoints2[i].v, separation); + + // cp->id = clipPoints2[i].id; + // cp->id.features.flip = flip; + ++pointCount; + } + } + + // manifold->pointCount = pointCount;} +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..db4913e8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h new file mode 100644 index 00000000..f14fdc08 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h @@ -0,0 +1,63 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H +#define BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H + +#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/BroadphaseCollision/btDispatcher.h" +#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" + +class btPersistentManifold; + +///box-box collision detection +class btBox2dBox2dCollisionAlgorithm : public btActivatingCollisionAlgorithm +{ + bool m_ownManifold; + btPersistentManifold* m_manifoldPtr; + +public: + btBox2dBox2dCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci) + : btActivatingCollisionAlgorithm(ci) {} + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + btBox2dBox2dCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap); + + virtual ~btBox2dBox2dCollisionAlgorithm(); + + virtual void getAllContactManifolds(btManifoldArray& manifoldArray) + { + if (m_manifoldPtr && m_ownManifold) + { + manifoldArray.push_back(m_manifoldPtr); + } + } + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + int bbsize = sizeof(btBox2dBox2dCollisionAlgorithm); + void* ptr = ci.m_dispatcher1->allocateCollisionAlgorithm(bbsize); + return new (ptr) btBox2dBox2dCollisionAlgorithm(0, ci, body0Wrap, body1Wrap); + } + }; +}; + +#endif //BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h.i new file mode 100644 index 00000000..cd999edc --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp new file mode 100644 index 00000000..39807fcf --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp @@ -0,0 +1,80 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btBoxBoxCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/CollisionShapes/btBoxShape.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "btBoxBoxDetector.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" +#define USE_PERSISTENT_CONTACTS 1 + +btBoxBoxCollisionAlgorithm::btBoxBoxCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + : btActivatingCollisionAlgorithm(ci, body0Wrap, body1Wrap), + m_ownManifold(false), + m_manifoldPtr(mf) +{ + if (!m_manifoldPtr && m_dispatcher->needsCollision(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject())) + { + m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject()); + m_ownManifold = true; + } +} + +btBoxBoxCollisionAlgorithm::~btBoxBoxCollisionAlgorithm() +{ + if (m_ownManifold) + { + if (m_manifoldPtr) + m_dispatcher->releaseManifold(m_manifoldPtr); + } +} + +void btBoxBoxCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + if (!m_manifoldPtr) + return; + + const btBoxShape* box0 = (btBoxShape*)body0Wrap->getCollisionShape(); + const btBoxShape* box1 = (btBoxShape*)body1Wrap->getCollisionShape(); + + /// report a contact. internally this will be kept persistent, and contact reduction is done + resultOut->setPersistentManifold(m_manifoldPtr); +#ifndef USE_PERSISTENT_CONTACTS + m_manifoldPtr->clearManifold(); +#endif //USE_PERSISTENT_CONTACTS + + btDiscreteCollisionDetectorInterface::ClosestPointInput input; + input.m_maximumDistanceSquared = BT_LARGE_FLOAT; + input.m_transformA = body0Wrap->getWorldTransform(); + input.m_transformB = body1Wrap->getWorldTransform(); + + btBoxBoxDetector detector(box0, box1); + detector.getClosestPoints(input, *resultOut, dispatchInfo.m_debugDraw); + +#ifdef USE_PERSISTENT_CONTACTS + // refreshContactPoints is only necessary when using persistent contact points. otherwise all points are newly added + if (m_ownManifold) + { + resultOut->refreshContactPoints(); + } +#endif //USE_PERSISTENT_CONTACTS +} + +btScalar btBoxBoxCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* /*body0*/, btCollisionObject* /*body1*/, const btDispatcherInfo& /*dispatchInfo*/, btManifoldResult* /*resultOut*/) +{ + //not yet + return 1.f; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..a3e5e60a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h new file mode 100644 index 00000000..d657242f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h @@ -0,0 +1,63 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_BOX_BOX__COLLISION_ALGORITHM_H +#define BT_BOX_BOX__COLLISION_ALGORITHM_H + +#include "btActivatingCollisionAlgorithm.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/BroadphaseCollision/btDispatcher.h" +#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" + +class btPersistentManifold; + +///box-box collision detection +class btBoxBoxCollisionAlgorithm : public btActivatingCollisionAlgorithm +{ + bool m_ownManifold; + btPersistentManifold* m_manifoldPtr; + +public: + btBoxBoxCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci) + : btActivatingCollisionAlgorithm(ci) {} + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + btBoxBoxCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap); + + virtual ~btBoxBoxCollisionAlgorithm(); + + virtual void getAllContactManifolds(btManifoldArray& manifoldArray) + { + if (m_manifoldPtr && m_ownManifold) + { + manifoldArray.push_back(m_manifoldPtr); + } + } + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + int bbsize = sizeof(btBoxBoxCollisionAlgorithm); + void* ptr = ci.m_dispatcher1->allocateCollisionAlgorithm(bbsize); + return new (ptr) btBoxBoxCollisionAlgorithm(0, ci, body0Wrap, body1Wrap); + } + }; +}; + +#endif //BT_BOX_BOX__COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h.i new file mode 100644 index 00000000..d55c7b6f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp new file mode 100644 index 00000000..4b516463 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp @@ -0,0 +1,767 @@ +/* + * Box-Box collision detection re-distributed under the ZLib license with permission from Russell L. Smith + * Original version is from Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith. + * All rights reserved. Email: russ@q12.org Web: www.q12.org + Bullet Continuous Collision Detection and Physics Library + Bullet is Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///ODE box-box collision detection is adapted to work with Bullet + +#include "btBoxBoxDetector.h" +#include "BulletCollision/CollisionShapes/btBoxShape.h" + +#include +#include + +btBoxBoxDetector::btBoxBoxDetector(const btBoxShape* box1, const btBoxShape* box2) + : m_box1(box1), + m_box2(box2) +{ +} + +// given two boxes (p1,R1,side1) and (p2,R2,side2), collide them together and +// generate contact points. this returns 0 if there is no contact otherwise +// it returns the number of contacts generated. +// `normal' returns the contact normal. +// `depth' returns the maximum penetration depth along that normal. +// `return_code' returns a number indicating the type of contact that was +// detected: +// 1,2,3 = box 2 intersects with a face of box 1 +// 4,5,6 = box 1 intersects with a face of box 2 +// 7..15 = edge-edge contact +// `maxc' is the maximum number of contacts allowed to be generated, i.e. +// the size of the `contact' array. +// `contact' and `skip' are the contact array information provided to the +// collision functions. this function only fills in the position and depth +// fields. +struct dContactGeom; +#define dDOTpq(a, b, p, q) ((a)[0] * (b)[0] + (a)[p] * (b)[q] + (a)[2 * (p)] * (b)[2 * (q)]) +#define dInfinity FLT_MAX + +/*PURE_INLINE btScalar dDOT (const btScalar *a, const btScalar *b) { return dDOTpq(a,b,1,1); } +PURE_INLINE btScalar dDOT13 (const btScalar *a, const btScalar *b) { return dDOTpq(a,b,1,3); } +PURE_INLINE btScalar dDOT31 (const btScalar *a, const btScalar *b) { return dDOTpq(a,b,3,1); } +PURE_INLINE btScalar dDOT33 (const btScalar *a, const btScalar *b) { return dDOTpq(a,b,3,3); } +*/ +static btScalar dDOT(const btScalar* a, const btScalar* b) { return dDOTpq(a, b, 1, 1); } +static btScalar dDOT44(const btScalar* a, const btScalar* b) { return dDOTpq(a, b, 4, 4); } +static btScalar dDOT41(const btScalar* a, const btScalar* b) { return dDOTpq(a, b, 4, 1); } +static btScalar dDOT14(const btScalar* a, const btScalar* b) { return dDOTpq(a, b, 1, 4); } +#define dMULTIPLYOP1_331(A, op, B, C) \ + { \ + (A)[0] op dDOT41((B), (C)); \ + (A)[1] op dDOT41((B + 1), (C)); \ + (A)[2] op dDOT41((B + 2), (C)); \ + } + +#define dMULTIPLYOP0_331(A, op, B, C) \ + { \ + (A)[0] op dDOT((B), (C)); \ + (A)[1] op dDOT((B + 4), (C)); \ + (A)[2] op dDOT((B + 8), (C)); \ + } + +#define dMULTIPLY1_331(A, B, C) dMULTIPLYOP1_331(A, =, B, C) +#define dMULTIPLY0_331(A, B, C) dMULTIPLYOP0_331(A, =, B, C) + +typedef btScalar dMatrix3[4 * 3]; + +void dLineClosestApproach(const btVector3& pa, const btVector3& ua, + const btVector3& pb, const btVector3& ub, + btScalar* alpha, btScalar* beta); +void dLineClosestApproach(const btVector3& pa, const btVector3& ua, + const btVector3& pb, const btVector3& ub, + btScalar* alpha, btScalar* beta) +{ + btVector3 p; + p[0] = pb[0] - pa[0]; + p[1] = pb[1] - pa[1]; + p[2] = pb[2] - pa[2]; + btScalar uaub = dDOT(ua, ub); + btScalar q1 = dDOT(ua, p); + btScalar q2 = -dDOT(ub, p); + btScalar d = 1 - uaub * uaub; + if (d <= btScalar(0.0001f)) + { + // @@@ this needs to be made more robust + *alpha = 0; + *beta = 0; + } + else + { + d = 1.f / d; + *alpha = (q1 + uaub * q2) * d; + *beta = (uaub * q1 + q2) * d; + } +} + +// find all the intersection points between the 2D rectangle with vertices +// at (+/-h[0],+/-h[1]) and the 2D quadrilateral with vertices (p[0],p[1]), +// (p[2],p[3]),(p[4],p[5]),(p[6],p[7]). +// +// the intersection points are returned as x,y pairs in the 'ret' array. +// the number of intersection points is returned by the function (this will +// be in the range 0 to 8). + +static int intersectRectQuad2(btScalar h[2], btScalar p[8], btScalar ret[16]) +{ + // q (and r) contain nq (and nr) coordinate points for the current (and + // chopped) polygons + int nq = 4, nr = 0; + btScalar buffer[16]; + btScalar* q = p; + btScalar* r = ret; + for (int dir = 0; dir <= 1; dir++) + { + // direction notation: xy[0] = x axis, xy[1] = y axis + for (int sign = -1; sign <= 1; sign += 2) + { + // chop q along the line xy[dir] = sign*h[dir] + btScalar* pq = q; + btScalar* pr = r; + nr = 0; + for (int i = nq; i > 0; i--) + { + // go through all points in q and all lines between adjacent points + if (sign * pq[dir] < h[dir]) + { + // this point is inside the chopping line + pr[0] = pq[0]; + pr[1] = pq[1]; + pr += 2; + nr++; + if (nr & 8) + { + q = r; + goto done; + } + } + btScalar* nextq = (i > 1) ? pq + 2 : q; + if ((sign * pq[dir] < h[dir]) ^ (sign * nextq[dir] < h[dir])) + { + // this line crosses the chopping line + pr[1 - dir] = pq[1 - dir] + (nextq[1 - dir] - pq[1 - dir]) / + (nextq[dir] - pq[dir]) * (sign * h[dir] - pq[dir]); + pr[dir] = sign * h[dir]; + pr += 2; + nr++; + if (nr & 8) + { + q = r; + goto done; + } + } + pq += 2; + } + q = r; + r = (q == ret) ? buffer : ret; + nq = nr; + } + } +done: + if (q != ret) memcpy(ret, q, nr * 2 * sizeof(btScalar)); + return nr; +} + +#define M__PI 3.14159265f + +// given n points in the plane (array p, of size 2*n), generate m points that +// best represent the whole set. the definition of 'best' here is not +// predetermined - the idea is to select points that give good box-box +// collision detection behavior. the chosen point indexes are returned in the +// array iret (of size m). 'i0' is always the first entry in the array. +// n must be in the range [1..8]. m must be in the range [1..n]. i0 must be +// in the range [0..n-1]. + +void cullPoints2(int n, btScalar p[], int m, int i0, int iret[]); +void cullPoints2(int n, btScalar p[], int m, int i0, int iret[]) +{ + // compute the centroid of the polygon in cx,cy + int i, j; + btScalar a, cx, cy, q; + if (n == 1) + { + cx = p[0]; + cy = p[1]; + } + else if (n == 2) + { + cx = btScalar(0.5) * (p[0] + p[2]); + cy = btScalar(0.5) * (p[1] + p[3]); + } + else + { + a = 0; + cx = 0; + cy = 0; + for (i = 0; i < (n - 1); i++) + { + q = p[i * 2] * p[i * 2 + 3] - p[i * 2 + 2] * p[i * 2 + 1]; + a += q; + cx += q * (p[i * 2] + p[i * 2 + 2]); + cy += q * (p[i * 2 + 1] + p[i * 2 + 3]); + } + q = p[n * 2 - 2] * p[1] - p[0] * p[n * 2 - 1]; + if (btFabs(a + q) > SIMD_EPSILON) + { + a = 1.f / (btScalar(3.0) * (a + q)); + } + else + { + a = BT_LARGE_FLOAT; + } + cx = a * (cx + q * (p[n * 2 - 2] + p[0])); + cy = a * (cy + q * (p[n * 2 - 1] + p[1])); + } + + // compute the angle of each point w.r.t. the centroid + btScalar A[8]; + for (i = 0; i < n; i++) A[i] = btAtan2(p[i * 2 + 1] - cy, p[i * 2] - cx); + + // search for points that have angles closest to A[i0] + i*(2*pi/m). + int avail[8]; + for (i = 0; i < n; i++) avail[i] = 1; + avail[i0] = 0; + iret[0] = i0; + iret++; + for (j = 1; j < m; j++) + { + a = btScalar(j) * (2 * M__PI / m) + A[i0]; + if (a > M__PI) a -= 2 * M__PI; + btScalar maxdiff = 1e9, diff; + + *iret = i0; // iret is not allowed to keep this value, but it sometimes does, when diff=#QNAN0 + + for (i = 0; i < n; i++) + { + if (avail[i]) + { + diff = btFabs(A[i] - a); + if (diff > M__PI) diff = 2 * M__PI - diff; + if (diff < maxdiff) + { + maxdiff = diff; + *iret = i; + } + } + } +#if defined(DEBUG) || defined(_DEBUG) + btAssert(*iret != i0); // ensure iret got set +#endif + avail[*iret] = 0; + iret++; + } +} + +int dBoxBox2(const btVector3& p1, const dMatrix3 R1, + const btVector3& side1, const btVector3& p2, + const dMatrix3 R2, const btVector3& side2, + btVector3& normal, btScalar* depth, int* return_code, + int maxc, dContactGeom* /*contact*/, int /*skip*/, btDiscreteCollisionDetectorInterface::Result& output); +int dBoxBox2(const btVector3& p1, const dMatrix3 R1, + const btVector3& side1, const btVector3& p2, + const dMatrix3 R2, const btVector3& side2, + btVector3& normal, btScalar* depth, int* return_code, + int maxc, dContactGeom* /*contact*/, int /*skip*/, btDiscreteCollisionDetectorInterface::Result& output) +{ + const btScalar fudge_factor = btScalar(1.05); + btVector3 p, pp, normalC(0.f, 0.f, 0.f); + const btScalar* normalR = 0; + btScalar A[3], B[3], R11, R12, R13, R21, R22, R23, R31, R32, R33, + Q11, Q12, Q13, Q21, Q22, Q23, Q31, Q32, Q33, s, s2, l; + int i, j, invert_normal, code; + + // get vector from centers of box 1 to box 2, relative to box 1 + p = p2 - p1; + dMULTIPLY1_331(pp, R1, p); // get pp = p relative to body 1 + + // get side lengths / 2 + A[0] = side1[0] * btScalar(0.5); + A[1] = side1[1] * btScalar(0.5); + A[2] = side1[2] * btScalar(0.5); + B[0] = side2[0] * btScalar(0.5); + B[1] = side2[1] * btScalar(0.5); + B[2] = side2[2] * btScalar(0.5); + + // Rij is R1'*R2, i.e. the relative rotation between R1 and R2 + R11 = dDOT44(R1 + 0, R2 + 0); + R12 = dDOT44(R1 + 0, R2 + 1); + R13 = dDOT44(R1 + 0, R2 + 2); + R21 = dDOT44(R1 + 1, R2 + 0); + R22 = dDOT44(R1 + 1, R2 + 1); + R23 = dDOT44(R1 + 1, R2 + 2); + R31 = dDOT44(R1 + 2, R2 + 0); + R32 = dDOT44(R1 + 2, R2 + 1); + R33 = dDOT44(R1 + 2, R2 + 2); + + Q11 = btFabs(R11); + Q12 = btFabs(R12); + Q13 = btFabs(R13); + Q21 = btFabs(R21); + Q22 = btFabs(R22); + Q23 = btFabs(R23); + Q31 = btFabs(R31); + Q32 = btFabs(R32); + Q33 = btFabs(R33); + + // for all 15 possible separating axes: + // * see if the axis separates the boxes. if so, return 0. + // * find the depth of the penetration along the separating axis (s2) + // * if this is the largest depth so far, record it. + // the normal vector will be set to the separating axis with the smallest + // depth. note: normalR is set to point to a column of R1 or R2 if that is + // the smallest depth normal so far. otherwise normalR is 0 and normalC is + // set to a vector relative to body 1. invert_normal is 1 if the sign of + // the normal should be flipped. + +#define TST(expr1, expr2, norm, cc) \ + s2 = btFabs(expr1) - (expr2); \ + if (s2 > 0) return 0; \ + if (s2 > s) \ + { \ + s = s2; \ + normalR = norm; \ + invert_normal = ((expr1) < 0); \ + code = (cc); \ + } + + s = -dInfinity; + invert_normal = 0; + code = 0; + + // separating axis = u1,u2,u3 + TST(pp[0], (A[0] + B[0] * Q11 + B[1] * Q12 + B[2] * Q13), R1 + 0, 1); + TST(pp[1], (A[1] + B[0] * Q21 + B[1] * Q22 + B[2] * Q23), R1 + 1, 2); + TST(pp[2], (A[2] + B[0] * Q31 + B[1] * Q32 + B[2] * Q33), R1 + 2, 3); + + // separating axis = v1,v2,v3 + TST(dDOT41(R2 + 0, p), (A[0] * Q11 + A[1] * Q21 + A[2] * Q31 + B[0]), R2 + 0, 4); + TST(dDOT41(R2 + 1, p), (A[0] * Q12 + A[1] * Q22 + A[2] * Q32 + B[1]), R2 + 1, 5); + TST(dDOT41(R2 + 2, p), (A[0] * Q13 + A[1] * Q23 + A[2] * Q33 + B[2]), R2 + 2, 6); + + // note: cross product axes need to be scaled when s is computed. + // normal (n1,n2,n3) is relative to box 1. +#undef TST +#define TST(expr1, expr2, n1, n2, n3, cc) \ + s2 = btFabs(expr1) - (expr2); \ + if (s2 > SIMD_EPSILON) return 0; \ + l = btSqrt((n1) * (n1) + (n2) * (n2) + (n3) * (n3)); \ + if (l > SIMD_EPSILON) \ + { \ + s2 /= l; \ + if (s2 * fudge_factor > s) \ + { \ + s = s2; \ + normalR = 0; \ + normalC[0] = (n1) / l; \ + normalC[1] = (n2) / l; \ + normalC[2] = (n3) / l; \ + invert_normal = ((expr1) < 0); \ + code = (cc); \ + } \ + } + + btScalar fudge2(1.0e-5f); + + Q11 += fudge2; + Q12 += fudge2; + Q13 += fudge2; + + Q21 += fudge2; + Q22 += fudge2; + Q23 += fudge2; + + Q31 += fudge2; + Q32 += fudge2; + Q33 += fudge2; + + // separating axis = u1 x (v1,v2,v3) + TST(pp[2] * R21 - pp[1] * R31, (A[1] * Q31 + A[2] * Q21 + B[1] * Q13 + B[2] * Q12), 0, -R31, R21, 7); + TST(pp[2] * R22 - pp[1] * R32, (A[1] * Q32 + A[2] * Q22 + B[0] * Q13 + B[2] * Q11), 0, -R32, R22, 8); + TST(pp[2] * R23 - pp[1] * R33, (A[1] * Q33 + A[2] * Q23 + B[0] * Q12 + B[1] * Q11), 0, -R33, R23, 9); + + // separating axis = u2 x (v1,v2,v3) + TST(pp[0] * R31 - pp[2] * R11, (A[0] * Q31 + A[2] * Q11 + B[1] * Q23 + B[2] * Q22), R31, 0, -R11, 10); + TST(pp[0] * R32 - pp[2] * R12, (A[0] * Q32 + A[2] * Q12 + B[0] * Q23 + B[2] * Q21), R32, 0, -R12, 11); + TST(pp[0] * R33 - pp[2] * R13, (A[0] * Q33 + A[2] * Q13 + B[0] * Q22 + B[1] * Q21), R33, 0, -R13, 12); + + // separating axis = u3 x (v1,v2,v3) + TST(pp[1] * R11 - pp[0] * R21, (A[0] * Q21 + A[1] * Q11 + B[1] * Q33 + B[2] * Q32), -R21, R11, 0, 13); + TST(pp[1] * R12 - pp[0] * R22, (A[0] * Q22 + A[1] * Q12 + B[0] * Q33 + B[2] * Q31), -R22, R12, 0, 14); + TST(pp[1] * R13 - pp[0] * R23, (A[0] * Q23 + A[1] * Q13 + B[0] * Q32 + B[1] * Q31), -R23, R13, 0, 15); + +#undef TST + + if (!code) return 0; + + // if we get to this point, the boxes interpenetrate. compute the normal + // in global coordinates. + if (normalR) + { + normal[0] = normalR[0]; + normal[1] = normalR[4]; + normal[2] = normalR[8]; + } + else + { + dMULTIPLY0_331(normal, R1, normalC); + } + if (invert_normal) + { + normal[0] = -normal[0]; + normal[1] = -normal[1]; + normal[2] = -normal[2]; + } + *depth = -s; + + // compute contact point(s) + + if (code > 6) + { + // an edge from box 1 touches an edge from box 2. + // find a point pa on the intersecting edge of box 1 + btVector3 pa; + btScalar sign; + for (i = 0; i < 3; i++) pa[i] = p1[i]; + for (j = 0; j < 3; j++) + { + sign = (dDOT14(normal, R1 + j) > 0) ? btScalar(1.0) : btScalar(-1.0); + for (i = 0; i < 3; i++) pa[i] += sign * A[j] * R1[i * 4 + j]; + } + + // find a point pb on the intersecting edge of box 2 + btVector3 pb; + for (i = 0; i < 3; i++) pb[i] = p2[i]; + for (j = 0; j < 3; j++) + { + sign = (dDOT14(normal, R2 + j) > 0) ? btScalar(-1.0) : btScalar(1.0); + for (i = 0; i < 3; i++) pb[i] += sign * B[j] * R2[i * 4 + j]; + } + + btScalar alpha, beta; + btVector3 ua, ub; + for (i = 0; i < 3; i++) ua[i] = R1[((code)-7) / 3 + i * 4]; + for (i = 0; i < 3; i++) ub[i] = R2[((code)-7) % 3 + i * 4]; + + dLineClosestApproach(pa, ua, pb, ub, &alpha, &beta); + for (i = 0; i < 3; i++) pa[i] += ua[i] * alpha; + for (i = 0; i < 3; i++) pb[i] += ub[i] * beta; + + { + //contact[0].pos[i] = btScalar(0.5)*(pa[i]+pb[i]); + //contact[0].depth = *depth; + btVector3 pointInWorld; + +#ifdef USE_CENTER_POINT + for (i = 0; i < 3; i++) + pointInWorld[i] = (pa[i] + pb[i]) * btScalar(0.5); + output.addContactPoint(-normal, pointInWorld, -*depth); +#else + output.addContactPoint(-normal, pb, -*depth); + +#endif // + *return_code = code; + } + return 1; + } + + // okay, we have a face-something intersection (because the separating + // axis is perpendicular to a face). define face 'a' to be the reference + // face (i.e. the normal vector is perpendicular to this) and face 'b' to be + // the incident face (the closest face of the other box). + + const btScalar *Ra, *Rb, *pa, *pb, *Sa, *Sb; + if (code <= 3) + { + Ra = R1; + Rb = R2; + pa = p1; + pb = p2; + Sa = A; + Sb = B; + } + else + { + Ra = R2; + Rb = R1; + pa = p2; + pb = p1; + Sa = B; + Sb = A; + } + + // nr = normal vector of reference face dotted with axes of incident box. + // anr = absolute values of nr. + btVector3 normal2, nr, anr; + if (code <= 3) + { + normal2[0] = normal[0]; + normal2[1] = normal[1]; + normal2[2] = normal[2]; + } + else + { + normal2[0] = -normal[0]; + normal2[1] = -normal[1]; + normal2[2] = -normal[2]; + } + dMULTIPLY1_331(nr, Rb, normal2); + anr[0] = btFabs(nr[0]); + anr[1] = btFabs(nr[1]); + anr[2] = btFabs(nr[2]); + + // find the largest compontent of anr: this corresponds to the normal + // for the indident face. the other axis numbers of the indicent face + // are stored in a1,a2. + int lanr, a1, a2; + if (anr[1] > anr[0]) + { + if (anr[1] > anr[2]) + { + a1 = 0; + lanr = 1; + a2 = 2; + } + else + { + a1 = 0; + a2 = 1; + lanr = 2; + } + } + else + { + if (anr[0] > anr[2]) + { + lanr = 0; + a1 = 1; + a2 = 2; + } + else + { + a1 = 0; + a2 = 1; + lanr = 2; + } + } + + // compute center point of incident face, in reference-face coordinates + btVector3 center; + if (nr[lanr] < 0) + { + for (i = 0; i < 3; i++) center[i] = pb[i] - pa[i] + Sb[lanr] * Rb[i * 4 + lanr]; + } + else + { + for (i = 0; i < 3; i++) center[i] = pb[i] - pa[i] - Sb[lanr] * Rb[i * 4 + lanr]; + } + + // find the normal and non-normal axis numbers of the reference box + int codeN, code1, code2; + if (code <= 3) + codeN = code - 1; + else + codeN = code - 4; + if (codeN == 0) + { + code1 = 1; + code2 = 2; + } + else if (codeN == 1) + { + code1 = 0; + code2 = 2; + } + else + { + code1 = 0; + code2 = 1; + } + + // find the four corners of the incident face, in reference-face coordinates + btScalar quad[8]; // 2D coordinate of incident face (x,y pairs) + btScalar c1, c2, m11, m12, m21, m22; + c1 = dDOT14(center, Ra + code1); + c2 = dDOT14(center, Ra + code2); + // optimize this? - we have already computed this data above, but it is not + // stored in an easy-to-index format. for now it's quicker just to recompute + // the four dot products. + m11 = dDOT44(Ra + code1, Rb + a1); + m12 = dDOT44(Ra + code1, Rb + a2); + m21 = dDOT44(Ra + code2, Rb + a1); + m22 = dDOT44(Ra + code2, Rb + a2); + { + btScalar k1 = m11 * Sb[a1]; + btScalar k2 = m21 * Sb[a1]; + btScalar k3 = m12 * Sb[a2]; + btScalar k4 = m22 * Sb[a2]; + quad[0] = c1 - k1 - k3; + quad[1] = c2 - k2 - k4; + quad[2] = c1 - k1 + k3; + quad[3] = c2 - k2 + k4; + quad[4] = c1 + k1 + k3; + quad[5] = c2 + k2 + k4; + quad[6] = c1 + k1 - k3; + quad[7] = c2 + k2 - k4; + } + + // find the size of the reference face + btScalar rect[2]; + rect[0] = Sa[code1]; + rect[1] = Sa[code2]; + + // intersect the incident and reference faces + btScalar ret[16]; + int n = intersectRectQuad2(rect, quad, ret); + if (n < 1) return 0; // this should never happen + + // convert the intersection points into reference-face coordinates, + // and compute the contact position and depth for each point. only keep + // those points that have a positive (penetrating) depth. delete points in + // the 'ret' array as necessary so that 'point' and 'ret' correspond. + btScalar point[3 * 8]; // penetrating contact points + btScalar dep[8]; // depths for those points + btScalar det1 = 1.f / (m11 * m22 - m12 * m21); + m11 *= det1; + m12 *= det1; + m21 *= det1; + m22 *= det1; + int cnum = 0; // number of penetrating contact points found + for (j = 0; j < n; j++) + { + btScalar k1 = m22 * (ret[j * 2] - c1) - m12 * (ret[j * 2 + 1] - c2); + btScalar k2 = -m21 * (ret[j * 2] - c1) + m11 * (ret[j * 2 + 1] - c2); + for (i = 0; i < 3; i++) point[cnum * 3 + i] = + center[i] + k1 * Rb[i * 4 + a1] + k2 * Rb[i * 4 + a2]; + dep[cnum] = Sa[codeN] - dDOT(normal2, point + cnum * 3); + if (dep[cnum] >= 0) + { + ret[cnum * 2] = ret[j * 2]; + ret[cnum * 2 + 1] = ret[j * 2 + 1]; + cnum++; + } + } + if (cnum < 1) return 0; // this should never happen + + // we can't generate more contacts than we actually have + if (maxc > cnum) maxc = cnum; + if (maxc < 1) maxc = 1; + + if (cnum <= maxc) + { + if (code < 4) + { + // we have less contacts than we need, so we use them all + for (j = 0; j < cnum; j++) + { + btVector3 pointInWorld; + for (i = 0; i < 3; i++) + pointInWorld[i] = point[j * 3 + i] + pa[i]; + output.addContactPoint(-normal, pointInWorld, -dep[j]); + } + } + else + { + // we have less contacts than we need, so we use them all + for (j = 0; j < cnum; j++) + { + btVector3 pointInWorld; + for (i = 0; i < 3; i++) + pointInWorld[i] = point[j * 3 + i] + pa[i] - normal[i] * dep[j]; + //pointInWorld[i] = point[j*3+i] + pa[i]; + output.addContactPoint(-normal, pointInWorld, -dep[j]); + } + } + } + else + { + // we have more contacts than are wanted, some of them must be culled. + // find the deepest point, it is always the first contact. + int i1 = 0; + btScalar maxdepth = dep[0]; + for (i = 1; i < cnum; i++) + { + if (dep[i] > maxdepth) + { + maxdepth = dep[i]; + i1 = i; + } + } + + int iret[8]; + cullPoints2(cnum, ret, maxc, i1, iret); + + for (j = 0; j < maxc; j++) + { + // dContactGeom *con = CONTACT(contact,skip*j); + // for (i=0; i<3; i++) con->pos[i] = point[iret[j]*3+i] + pa[i]; + // con->depth = dep[iret[j]]; + + btVector3 posInWorld; + for (i = 0; i < 3; i++) + posInWorld[i] = point[iret[j] * 3 + i] + pa[i]; + if (code < 4) + { + output.addContactPoint(-normal, posInWorld, -dep[iret[j]]); + } + else + { + output.addContactPoint(-normal, posInWorld - normal * dep[iret[j]], -dep[iret[j]]); + } + } + cnum = maxc; + } + + *return_code = code; + return cnum; +} + +void btBoxBoxDetector::getClosestPoints(const ClosestPointInput& input, Result& output, class btIDebugDraw* /*debugDraw*/, bool /*swapResults*/) +{ + const btTransform& transformA = input.m_transformA; + const btTransform& transformB = input.m_transformB; + + int skip = 0; + dContactGeom* contact = 0; + + dMatrix3 R1; + dMatrix3 R2; + + for (int j = 0; j < 3; j++) + { + R1[0 + 4 * j] = transformA.getBasis()[j].x(); + R2[0 + 4 * j] = transformB.getBasis()[j].x(); + + R1[1 + 4 * j] = transformA.getBasis()[j].y(); + R2[1 + 4 * j] = transformB.getBasis()[j].y(); + + R1[2 + 4 * j] = transformA.getBasis()[j].z(); + R2[2 + 4 * j] = transformB.getBasis()[j].z(); + } + + btVector3 normal; + btScalar depth; + int return_code; + int maxc = 4; + + dBoxBox2(transformA.getOrigin(), + R1, + 2.f * m_box1->getHalfExtentsWithMargin(), + transformB.getOrigin(), + R2, + 2.f * m_box2->getHalfExtentsWithMargin(), + normal, &depth, &return_code, + maxc, contact, skip, + output); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp.i new file mode 100644 index 00000000..82c50576 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.h new file mode 100644 index 00000000..9b1b36b6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.h @@ -0,0 +1,40 @@ +/* + * Box-Box collision detection re-distributed under the ZLib license with permission from Russell L. Smith + * Original version is from Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith. + * All rights reserved. Email: russ@q12.org Web: www.q12.org + +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +#ifndef BT_BOX_BOX_DETECTOR_H +#define BT_BOX_BOX_DETECTOR_H + +class btBoxShape; +#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" + +/// btBoxBoxDetector wraps the ODE box-box collision detector +/// re-distributed under the Zlib license with permission from Russell L. Smith +struct btBoxBoxDetector : public btDiscreteCollisionDetectorInterface +{ + const btBoxShape* m_box1; + const btBoxShape* m_box2; + +public: + btBoxBoxDetector(const btBoxShape* box1, const btBoxShape* box2); + + virtual ~btBoxBoxDetector(){}; + + virtual void getClosestPoints(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw, bool swapResults = false); +}; + +#endif //BT_BOX_BOX_DETECTOR_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.h.i new file mode 100644 index 00000000..4ddd9016 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btBoxBoxDetector.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btBoxBoxDetector.h ---------------- + +%include "BulletCollision/CollisionDispatch/btBoxBoxDetector.h" + +%{ +#include "BulletCollision/CollisionDispatch/btBoxBoxDetector.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionConfiguration.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionConfiguration.h new file mode 100644 index 00000000..3f578d66 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionConfiguration.h @@ -0,0 +1,43 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COLLISION_CONFIGURATION +#define BT_COLLISION_CONFIGURATION + +struct btCollisionAlgorithmCreateFunc; + +class btPoolAllocator; + +///btCollisionConfiguration allows to configure Bullet collision detection +///stack allocator size, default collision algorithms and persistent manifold pool size +///@todo: describe the meaning +class btCollisionConfiguration +{ +public: + virtual ~btCollisionConfiguration() + { + } + + ///memory pools + virtual btPoolAllocator* getPersistentManifoldPool() = 0; + + virtual btPoolAllocator* getCollisionAlgorithmPool() = 0; + + virtual btCollisionAlgorithmCreateFunc* getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1) = 0; + + virtual btCollisionAlgorithmCreateFunc* getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1) = 0; +}; + +#endif //BT_COLLISION_CONFIGURATION diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionConfiguration.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionConfiguration.h.i new file mode 100644 index 00000000..4c9388d1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionConfiguration.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionConfiguration.h ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionConfiguration.h" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionConfiguration.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h new file mode 100644 index 00000000..597f2602 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h @@ -0,0 +1,43 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COLLISION_CREATE_FUNC +#define BT_COLLISION_CREATE_FUNC + +#include "LinearMath/btAlignedObjectArray.h" +class btCollisionAlgorithm; +class btCollisionObject; +struct btCollisionObjectWrapper; +struct btCollisionAlgorithmConstructionInfo; + +///Used by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm +struct btCollisionAlgorithmCreateFunc +{ + bool m_swapped; + + btCollisionAlgorithmCreateFunc() + : m_swapped(false) + { + } + virtual ~btCollisionAlgorithmCreateFunc(){}; + + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo&, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + (void)body0Wrap; + (void)body1Wrap; + return 0; + } +}; +#endif //BT_COLLISION_CREATE_FUNC diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h.i new file mode 100644 index 00000000..4d9ddad2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionCreateFunc.h ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp new file mode 100644 index 00000000..4d86df51 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp @@ -0,0 +1,289 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btCollisionDispatcher.h" +#include "LinearMath/btQuickprof.h" + +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" + +#include "BulletCollision/CollisionShapes/btCollisionShape.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" +#include "LinearMath/btPoolAllocator.h" +#include "BulletCollision/CollisionDispatch/btCollisionConfiguration.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +#ifdef BT_DEBUG +#include +#endif + +btCollisionDispatcher::btCollisionDispatcher(btCollisionConfiguration* collisionConfiguration) : m_dispatcherFlags(btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD), + m_collisionConfiguration(collisionConfiguration) +{ + int i; + + setNearCallback(defaultNearCallback); + + m_collisionAlgorithmPoolAllocator = collisionConfiguration->getCollisionAlgorithmPool(); + + m_persistentManifoldPoolAllocator = collisionConfiguration->getPersistentManifoldPool(); + + for (i = 0; i < MAX_BROADPHASE_COLLISION_TYPES; i++) + { + for (int j = 0; j < MAX_BROADPHASE_COLLISION_TYPES; j++) + { + m_doubleDispatchContactPoints[i][j] = m_collisionConfiguration->getCollisionAlgorithmCreateFunc(i, j); + btAssert(m_doubleDispatchContactPoints[i][j]); + m_doubleDispatchClosestPoints[i][j] = m_collisionConfiguration->getClosestPointsAlgorithmCreateFunc(i, j); + } + } +} + +void btCollisionDispatcher::registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc* createFunc) +{ + m_doubleDispatchContactPoints[proxyType0][proxyType1] = createFunc; +} + +void btCollisionDispatcher::registerClosestPointsCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc* createFunc) +{ + m_doubleDispatchClosestPoints[proxyType0][proxyType1] = createFunc; +} + +btCollisionDispatcher::~btCollisionDispatcher() +{ +} + +btPersistentManifold* btCollisionDispatcher::getNewManifold(const btCollisionObject* body0, const btCollisionObject* body1) +{ + //btAssert(gNumManifold < 65535); + + //optional relative contact breaking threshold, turned on by default (use setDispatcherFlags to switch off feature for improved performance) + + btScalar contactBreakingThreshold = (m_dispatcherFlags & btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD) ? btMin(body0->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold), body1->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold)) + : gContactBreakingThreshold; + + btScalar contactProcessingThreshold = btMin(body0->getContactProcessingThreshold(), body1->getContactProcessingThreshold()); + + void* mem = m_persistentManifoldPoolAllocator->allocate(sizeof(btPersistentManifold)); + if (NULL == mem) + { + //we got a pool memory overflow, by default we fallback to dynamically allocate memory. If we require a contiguous contact pool then assert. + if ((m_dispatcherFlags & CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION) == 0) + { + mem = btAlignedAlloc(sizeof(btPersistentManifold), 16); + } + else + { + btAssert(0); + //make sure to increase the m_defaultMaxPersistentManifoldPoolSize in the btDefaultCollisionConstructionInfo/btDefaultCollisionConfiguration + return 0; + } + } + btPersistentManifold* manifold = new (mem) btPersistentManifold(body0, body1, 0, contactBreakingThreshold, contactProcessingThreshold); + manifold->m_index1a = m_manifoldsPtr.size(); + m_manifoldsPtr.push_back(manifold); + + return manifold; +} + +void btCollisionDispatcher::clearManifold(btPersistentManifold* manifold) +{ + manifold->clearManifold(); +} + +void btCollisionDispatcher::releaseManifold(btPersistentManifold* manifold) +{ + //printf("releaseManifold: gNumManifold %d\n",gNumManifold); + clearManifold(manifold); + + int findIndex = manifold->m_index1a; + btAssert(findIndex < m_manifoldsPtr.size()); + m_manifoldsPtr.swap(findIndex, m_manifoldsPtr.size() - 1); + m_manifoldsPtr[findIndex]->m_index1a = findIndex; + m_manifoldsPtr.pop_back(); + + manifold->~btPersistentManifold(); + if (m_persistentManifoldPoolAllocator->validPtr(manifold)) + { + m_persistentManifoldPoolAllocator->freeMemory(manifold); + } + else + { + btAlignedFree(manifold); + } +} + +btCollisionAlgorithm* btCollisionDispatcher::findAlgorithm(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btPersistentManifold* sharedManifold, ebtDispatcherQueryType algoType) +{ + btCollisionAlgorithmConstructionInfo ci; + + ci.m_dispatcher1 = this; + ci.m_manifold = sharedManifold; + btCollisionAlgorithm* algo = 0; + if (algoType == BT_CONTACT_POINT_ALGORITHMS) + { + algo = m_doubleDispatchContactPoints[body0Wrap->getCollisionShape()->getShapeType()][body1Wrap->getCollisionShape()->getShapeType()]->CreateCollisionAlgorithm(ci, body0Wrap, body1Wrap); + } + else + { + algo = m_doubleDispatchClosestPoints[body0Wrap->getCollisionShape()->getShapeType()][body1Wrap->getCollisionShape()->getShapeType()]->CreateCollisionAlgorithm(ci, body0Wrap, body1Wrap); + } + + return algo; +} + +bool btCollisionDispatcher::needsResponse(const btCollisionObject* body0, const btCollisionObject* body1) +{ + //here you can do filtering + bool hasResponse = + (body0->hasContactResponse() && body1->hasContactResponse()); + //no response between two static/kinematic bodies: + hasResponse = hasResponse && + ((!body0->isStaticOrKinematicObject()) || (!body1->isStaticOrKinematicObject())); + return hasResponse; +} + +bool btCollisionDispatcher::needsCollision(const btCollisionObject* body0, const btCollisionObject* body1) +{ + btAssert(body0); + btAssert(body1); + + bool needsCollision = true; + +#ifdef BT_DEBUG + if (!(m_dispatcherFlags & btCollisionDispatcher::CD_STATIC_STATIC_REPORTED)) + { + //broadphase filtering already deals with this + if (body0->isStaticOrKinematicObject() && body1->isStaticOrKinematicObject()) + { + m_dispatcherFlags |= btCollisionDispatcher::CD_STATIC_STATIC_REPORTED; + printf("warning btCollisionDispatcher::needsCollision: static-static collision!\n"); + } + } +#endif //BT_DEBUG + + if ((!body0->isActive()) && (!body1->isActive())) + needsCollision = false; + else if ((!body0->checkCollideWith(body1)) || (!body1->checkCollideWith(body0))) + needsCollision = false; + + return needsCollision; +} + +///interface for iterating all overlapping collision pairs, no matter how those pairs are stored (array, set, map etc) +///this is useful for the collision dispatcher. +class btCollisionPairCallback : public btOverlapCallback +{ + const btDispatcherInfo& m_dispatchInfo; + btCollisionDispatcher* m_dispatcher; + +public: + btCollisionPairCallback(const btDispatcherInfo& dispatchInfo, btCollisionDispatcher* dispatcher) + : m_dispatchInfo(dispatchInfo), + m_dispatcher(dispatcher) + { + } + + /*btCollisionPairCallback& operator=(btCollisionPairCallback& other) + { + m_dispatchInfo = other.m_dispatchInfo; + m_dispatcher = other.m_dispatcher; + return *this; + } + */ + + virtual ~btCollisionPairCallback() {} + + virtual bool processOverlap(btBroadphasePair& pair) + { + (*m_dispatcher->getNearCallback())(pair, *m_dispatcher, m_dispatchInfo); + return false; + } +}; + +void btCollisionDispatcher::dispatchAllCollisionPairs(btOverlappingPairCache* pairCache, const btDispatcherInfo& dispatchInfo, btDispatcher* dispatcher) +{ + //m_blockedForChanges = true; + + btCollisionPairCallback collisionCallback(dispatchInfo, this); + + { +//\1("processAllOverlappingPairs"); + pairCache->processAllOverlappingPairs(&collisionCallback, dispatcher, dispatchInfo); + } + + //m_blockedForChanges = false; +} + +//by default, Bullet will use this near callback +void btCollisionDispatcher::defaultNearCallback(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatchInfo) +{ + btCollisionObject* colObj0 = (btCollisionObject*)collisionPair.m_pProxy0->m_clientObject; + btCollisionObject* colObj1 = (btCollisionObject*)collisionPair.m_pProxy1->m_clientObject; + + if (dispatcher.needsCollision(colObj0, colObj1)) + { + btCollisionObjectWrapper obj0Wrap(0, colObj0->getCollisionShape(), colObj0, colObj0->getWorldTransform(), -1, -1); + btCollisionObjectWrapper obj1Wrap(0, colObj1->getCollisionShape(), colObj1, colObj1->getWorldTransform(), -1, -1); + + //dispatcher will keep algorithms persistent in the collision pair + if (!collisionPair.m_algorithm) + { + collisionPair.m_algorithm = dispatcher.findAlgorithm(&obj0Wrap, &obj1Wrap, 0, BT_CONTACT_POINT_ALGORITHMS); + } + + if (collisionPair.m_algorithm) + { + btManifoldResult contactPointResult(&obj0Wrap, &obj1Wrap); + + if (dispatchInfo.m_dispatchFunc == btDispatcherInfo::DISPATCH_DISCRETE) + { + //discrete collision detection query + + collisionPair.m_algorithm->processCollision(&obj0Wrap, &obj1Wrap, dispatchInfo, &contactPointResult); + } + else + { + //continuous collision detection query, time of impact (toi) + btScalar toi = collisionPair.m_algorithm->calculateTimeOfImpact(colObj0, colObj1, dispatchInfo, &contactPointResult); + if (dispatchInfo.m_timeOfImpact > toi) + dispatchInfo.m_timeOfImpact = toi; + } + } + } +} + +void* btCollisionDispatcher::allocateCollisionAlgorithm(int size) +{ + void* mem = m_collisionAlgorithmPoolAllocator->allocate(size); + if (NULL == mem) + { + //warn user for overflow? + return btAlignedAlloc(static_cast(size), 16); + } + return mem; +} + +void btCollisionDispatcher::freeCollisionAlgorithm(void* ptr) +{ + if (m_collisionAlgorithmPoolAllocator->validPtr(ptr)) + { + m_collisionAlgorithmPoolAllocator->freeMemory(ptr); + } + else + { + btAlignedFree(ptr); + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp.i new file mode 100644 index 00000000..08fc29b0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcher.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcher.h new file mode 100644 index 00000000..3a466bf4 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcher.h @@ -0,0 +1,169 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COLLISION__DISPATCHER_H +#define BT_COLLISION__DISPATCHER_H + +#include "BulletCollision/BroadphaseCollision/btDispatcher.h" +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" + +#include "BulletCollision/CollisionDispatch/btManifoldResult.h" + +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "LinearMath/btAlignedObjectArray.h" + +class btIDebugDraw; +class btOverlappingPairCache; +class btPoolAllocator; +class btCollisionConfiguration; + +#include "btCollisionCreateFunc.h" + +#define USE_DISPATCH_REGISTRY_ARRAY 1 + +class btCollisionDispatcher; +///user can override this nearcallback for collision filtering and more finegrained control over collision detection +typedef void (*btNearCallback)(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatchInfo); + +///btCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs. +///Time of Impact, Closest Points and Penetration Depth. +class btCollisionDispatcher : public btDispatcher +{ +protected: + int m_dispatcherFlags; + + btAlignedObjectArray m_manifoldsPtr; + + btNearCallback m_nearCallback; + + btPoolAllocator* m_collisionAlgorithmPoolAllocator; + + btPoolAllocator* m_persistentManifoldPoolAllocator; + + btCollisionAlgorithmCreateFunc* m_doubleDispatchContactPoints[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES]; + + btCollisionAlgorithmCreateFunc* m_doubleDispatchClosestPoints[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES]; + + btCollisionConfiguration* m_collisionConfiguration; + +public: + enum DispatcherFlags + { + CD_STATIC_STATIC_REPORTED = 1, + CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD = 2, + CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION = 4 + }; + + int getDispatcherFlags() const + { + return m_dispatcherFlags; + } + + void setDispatcherFlags(int flags) + { + m_dispatcherFlags = flags; + } + + ///registerCollisionCreateFunc allows registration of custom/alternative collision create functions + void registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc* createFunc); + + void registerClosestPointsCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc* createFunc); + + int getNumManifolds() const + { + return int(m_manifoldsPtr.size()); + } + + btPersistentManifold** getInternalManifoldPointer() + { + return m_manifoldsPtr.size() ? &m_manifoldsPtr[0] : 0; + } + + btPersistentManifold* getManifoldByIndexInternal(int index) + { + btAssert(index>=0); + btAssert(index=0); + // btAssert(indexgetNumThreads()); + m_batchReleasePtr.resize(btGetTaskScheduler()->getNumThreads()); + + m_batchUpdating = false; + m_grainSize = grainSize; // iterations per task +} + +btPersistentManifold* btCollisionDispatcherMt::getNewManifold(const btCollisionObject* body0, const btCollisionObject* body1) +{ + //optional relative contact breaking threshold, turned on by default (use setDispatcherFlags to switch off feature for improved performance) + + btScalar contactBreakingThreshold = (m_dispatcherFlags & btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD) ? btMin(body0->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold), body1->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold)) + : gContactBreakingThreshold; + + btScalar contactProcessingThreshold = btMin(body0->getContactProcessingThreshold(), body1->getContactProcessingThreshold()); + + void* mem = m_persistentManifoldPoolAllocator->allocate(sizeof(btPersistentManifold)); + if (NULL == mem) + { + //we got a pool memory overflow, by default we fallback to dynamically allocate memory. If we require a contiguous contact pool then assert. + if ((m_dispatcherFlags & CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION) == 0) + { + mem = btAlignedAlloc(sizeof(btPersistentManifold), 16); + } + else + { + btAssert(0); + //make sure to increase the m_defaultMaxPersistentManifoldPoolSize in the btDefaultCollisionConstructionInfo/btDefaultCollisionConfiguration + return 0; + } + } + btPersistentManifold* manifold = new (mem) btPersistentManifold(body0, body1, 0, contactBreakingThreshold, contactProcessingThreshold); + if (!m_batchUpdating) + { + // batch updater will update manifold pointers array after finishing, so + // only need to update array when not batch-updating + //btAssert( !btThreadsAreRunning() ); + manifold->m_index1a = m_manifoldsPtr.size(); + m_manifoldsPtr.push_back(manifold); + } + else + { + m_batchManifoldsPtr[btGetCurrentThreadIndex()].push_back(manifold); + } + + return manifold; +} + +void btCollisionDispatcherMt::releaseManifold(btPersistentManifold* manifold) +{ + //btAssert( !btThreadsAreRunning() ); + + if (!m_batchUpdating) + { + clearManifold(manifold); + // batch updater will update manifold pointers array after finishing, so + // only need to update array when not batch-updating + int findIndex = manifold->m_index1a; + btAssert(findIndex < m_manifoldsPtr.size()); + m_manifoldsPtr.swap(findIndex, m_manifoldsPtr.size() - 1); + m_manifoldsPtr[findIndex]->m_index1a = findIndex; + m_manifoldsPtr.pop_back(); + } else { + m_batchReleasePtr[btGetCurrentThreadIndex()].push_back(manifold); + return; + } + + manifold->~btPersistentManifold(); + if (m_persistentManifoldPoolAllocator->validPtr(manifold)) + { + m_persistentManifoldPoolAllocator->freeMemory(manifold); + } + else + { + btAlignedFree(manifold); + } +} + +struct CollisionDispatcherUpdater : public btIParallelForBody +{ + btBroadphasePair* mPairArray; + btNearCallback mCallback; + btCollisionDispatcher* mDispatcher; + const btDispatcherInfo* mInfo; + + CollisionDispatcherUpdater() + { + mPairArray = NULL; + mCallback = NULL; + mDispatcher = NULL; + mInfo = NULL; + } + void forLoop(int iBegin, int iEnd) const + { + for (int i = iBegin; i < iEnd; ++i) + { + btBroadphasePair* pair = &mPairArray[i]; + mCallback(*pair, *mDispatcher, *mInfo); + } + } +}; + +void btCollisionDispatcherMt::dispatchAllCollisionPairs(btOverlappingPairCache* pairCache, const btDispatcherInfo& info, btDispatcher* dispatcher) +{ + const int pairCount = pairCache->getNumOverlappingPairs(); + if (pairCount == 0) + { + return; + } + CollisionDispatcherUpdater updater; + updater.mCallback = getNearCallback(); + updater.mPairArray = pairCache->getOverlappingPairArrayPtr(); + updater.mDispatcher = this; + updater.mInfo = &info; + + m_batchUpdating = true; + btParallelFor(0, pairCount, m_grainSize, updater); + m_batchUpdating = false; + + // merge new manifolds, if any + for (int i = 0; i < m_batchManifoldsPtr.size(); ++i) + { + btAlignedObjectArray& batchManifoldsPtr = m_batchManifoldsPtr[i]; + + for (int j = 0; j < batchManifoldsPtr.size(); ++j) + { + m_manifoldsPtr.push_back(batchManifoldsPtr[j]); + } + + batchManifoldsPtr.resizeNoInitialize(0); + } + + // remove batched remove manifolds. + for (int i = 0; i < m_batchReleasePtr.size(); ++i) + { + btAlignedObjectArray& batchManifoldsPtr = m_batchReleasePtr[i]; + for (int j = 0; j < batchManifoldsPtr.size(); ++j) + { + releaseManifold(batchManifoldsPtr[j]); + } + batchManifoldsPtr.resizeNoInitialize(0); + } + + // update the indices (used when releasing manifolds) + for (int i = 0; i < m_manifoldsPtr.size(); ++i) + { + m_manifoldsPtr[i]->m_index1a = i; + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.cpp.i new file mode 100644 index 00000000..2987a9c6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionDispatcherMt.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionDispatcherMt.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionDispatcherMt.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h new file mode 100644 index 00000000..094e928b --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h @@ -0,0 +1,39 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COLLISION_DISPATCHER_MT_H +#define BT_COLLISION_DISPATCHER_MT_H + +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "LinearMath/btThreads.h" + +class btCollisionDispatcherMt : public btCollisionDispatcher +{ +public: + btCollisionDispatcherMt(btCollisionConfiguration* config, int grainSize = 40); + + virtual btPersistentManifold* getNewManifold(const btCollisionObject* body0, const btCollisionObject* body1) BT_OVERRIDE; + virtual void releaseManifold(btPersistentManifold* manifold) BT_OVERRIDE; + + virtual void dispatchAllCollisionPairs(btOverlappingPairCache* pairCache, const btDispatcherInfo& info, btDispatcher* dispatcher) BT_OVERRIDE; + +protected: + btAlignedObjectArray > m_batchManifoldsPtr; + btAlignedObjectArray > m_batchReleasePtr; + bool m_batchUpdating; + int m_grainSize; +}; + +#endif //BT_COLLISION_DISPATCHER_MT_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h.i new file mode 100644 index 00000000..95b611fd --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.cpp new file mode 100644 index 00000000..04dbbf23 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.cpp @@ -0,0 +1,138 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btCollisionObject.h" +#include "LinearMath/btSerializer.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" + +btCollisionObject::btCollisionObject() + : m_interpolationLinearVelocity(0.f, 0.f, 0.f), + m_interpolationAngularVelocity(0.f, 0.f, 0.f), + m_anisotropicFriction(1.f, 1.f, 1.f), + m_hasAnisotropicFriction(false), + m_contactProcessingThreshold(BT_LARGE_FLOAT), + m_broadphaseHandle(0), + m_collisionShape(0), + m_extensionPointer(0), + m_rootCollisionShape(0), + m_collisionFlags(btCollisionObject::CF_STATIC_OBJECT), + m_islandTag1(-1), + m_companionId(-1), + m_worldArrayIndex(-1), + m_activationState1(1), + m_deactivationTime(btScalar(0.)), + m_friction(btScalar(0.5)), + m_restitution(btScalar(0.)), + m_rollingFriction(0.0f), + m_spinningFriction(0.f), + m_contactDamping(.1), + m_contactStiffness(BT_LARGE_FLOAT), + m_internalType(CO_COLLISION_OBJECT), + m_userObjectPointer(0), + m_userIndex2(-1), + m_userIndex(-1), + m_userIndex3(-1), + m_hitFraction(btScalar(1.)), + m_ccdSweptSphereRadius(btScalar(0.)), + m_ccdMotionThreshold(btScalar(0.)), + m_checkCollideWith(false), + m_updateRevision(0) +{ + m_worldTransform.setIdentity(); + m_interpolationWorldTransform.setIdentity(); +} + +btCollisionObject::~btCollisionObject() +{ +} + +void btCollisionObject::setActivationState(int newState) const +{ + if ((m_activationState1 != DISABLE_DEACTIVATION) && (m_activationState1 != DISABLE_SIMULATION)) + m_activationState1 = newState; +} + +void btCollisionObject::forceActivationState(int newState) const +{ + m_activationState1 = newState; +} + +void btCollisionObject::activate(bool forceActivation) const +{ + if (forceActivation || !(m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT))) + { + setActivationState(ACTIVE_TAG); + m_deactivationTime = btScalar(0.); + } +} + +const char* btCollisionObject::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btCollisionObjectData* dataOut = (btCollisionObjectData*)dataBuffer; + + m_worldTransform.serialize(dataOut->m_worldTransform); + m_interpolationWorldTransform.serialize(dataOut->m_interpolationWorldTransform); + m_interpolationLinearVelocity.serialize(dataOut->m_interpolationLinearVelocity); + m_interpolationAngularVelocity.serialize(dataOut->m_interpolationAngularVelocity); + m_anisotropicFriction.serialize(dataOut->m_anisotropicFriction); + dataOut->m_hasAnisotropicFriction = m_hasAnisotropicFriction; + dataOut->m_contactProcessingThreshold = m_contactProcessingThreshold; + dataOut->m_broadphaseHandle = 0; + dataOut->m_collisionShape = serializer->getUniquePointer(m_collisionShape); + dataOut->m_rootCollisionShape = 0; //@todo + dataOut->m_collisionFlags = m_collisionFlags; + dataOut->m_islandTag1 = m_islandTag1; + dataOut->m_companionId = m_companionId; + dataOut->m_activationState1 = m_activationState1; + dataOut->m_deactivationTime = m_deactivationTime; + dataOut->m_friction = m_friction; + dataOut->m_rollingFriction = m_rollingFriction; + dataOut->m_contactDamping = m_contactDamping; + dataOut->m_contactStiffness = m_contactStiffness; + dataOut->m_restitution = m_restitution; + dataOut->m_internalType = m_internalType; + + char* name = (char*)serializer->findNameForPointer(this); + dataOut->m_name = (char*)serializer->getUniquePointer(name); + if (dataOut->m_name) + { + serializer->serializeName(name); + } + dataOut->m_hitFraction = m_hitFraction; + dataOut->m_ccdSweptSphereRadius = m_ccdSweptSphereRadius; + dataOut->m_ccdMotionThreshold = m_ccdMotionThreshold; + dataOut->m_checkCollideWith = m_checkCollideWith; + if (m_broadphaseHandle) + { + dataOut->m_collisionFilterGroup = m_broadphaseHandle->m_collisionFilterGroup; + dataOut->m_collisionFilterMask = m_broadphaseHandle->m_collisionFilterMask; + dataOut->m_uniqueId = m_broadphaseHandle->m_uniqueId; + } + else + { + dataOut->m_collisionFilterGroup = 0; + dataOut->m_collisionFilterMask = 0; + dataOut->m_uniqueId = -1; + } + return btCollisionObjectDataName; +} + +void btCollisionObject::serializeSingleObject(class btSerializer* serializer) const +{ + int len = calculateSerializeBufferSize(); + btChunk* chunk = serializer->allocate(len, 1); + const char* structType = serialize(chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_COLLISIONOBJECT_CODE, (void*)this); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.cpp.i new file mode 100644 index 00000000..0cb2b804 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionObject.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionObject.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionObject.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.h new file mode 100644 index 00000000..d1456a90 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.h @@ -0,0 +1,690 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COLLISION_OBJECT_H +#define BT_COLLISION_OBJECT_H + +#include "LinearMath/btTransform.h" + +//island management, m_activationState1 +#define ACTIVE_TAG 1 +#define ISLAND_SLEEPING 2 +#define WANTS_DEACTIVATION 3 +#define DISABLE_DEACTIVATION 4 +#define DISABLE_SIMULATION 5 +#define FIXED_BASE_MULTI_BODY 6 + +struct btBroadphaseProxy; +class btCollisionShape; +struct btCollisionShapeData; +#include "LinearMath/btMotionState.h" +#include "LinearMath/btAlignedAllocator.h" +#include "LinearMath/btAlignedObjectArray.h" + +typedef btAlignedObjectArray btCollisionObjectArray; + +#ifdef BT_USE_DOUBLE_PRECISION +#define btCollisionObjectData btCollisionObjectDoubleData +#define btCollisionObjectDataName "btCollisionObjectDoubleData" +#else +#define btCollisionObjectData btCollisionObjectFloatData +#define btCollisionObjectDataName "btCollisionObjectFloatData" +#endif + +/// btCollisionObject can be used to manage collision detection objects. +/// btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy. +/// They can be added to the btCollisionWorld. +ATTRIBUTE_ALIGNED16(class) +btCollisionObject +{ +protected: + btTransform m_worldTransform; + + ///m_interpolationWorldTransform is used for CCD and interpolation + ///it can be either previous or future (predicted) transform + btTransform m_interpolationWorldTransform; + //those two are experimental: just added for bullet time effect, so you can still apply impulses (directly modifying velocities) + //without destroying the continuous interpolated motion (which uses this interpolation velocities) + btVector3 m_interpolationLinearVelocity; + btVector3 m_interpolationAngularVelocity; + + btVector3 m_anisotropicFriction; + int m_hasAnisotropicFriction; + btScalar m_contactProcessingThreshold; + + btBroadphaseProxy* m_broadphaseHandle; + btCollisionShape* m_collisionShape; + ///m_extensionPointer is used by some internal low-level Bullet extensions. + void* m_extensionPointer; + + ///m_rootCollisionShape is temporarily used to store the original collision shape + ///The m_collisionShape might be temporarily replaced by a child collision shape during collision detection purposes + ///If it is NULL, the m_collisionShape is not temporarily replaced. + btCollisionShape* m_rootCollisionShape; + + int m_collisionFlags; + + int m_islandTag1; + int m_companionId; + int m_worldArrayIndex; // index of object in world's collisionObjects array + + mutable int m_activationState1; + mutable btScalar m_deactivationTime; + + btScalar m_friction; + btScalar m_restitution; + btScalar m_rollingFriction; //torsional friction orthogonal to contact normal (useful to stop spheres rolling forever) + btScalar m_spinningFriction; // torsional friction around the contact normal (useful for grasping) + btScalar m_contactDamping; + btScalar m_contactStiffness; + + ///m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc. + ///do not assign your own m_internalType unless you write a new dynamics object class. + int m_internalType; + + ///users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPointer + + void* m_userObjectPointer; + + int m_userIndex2; + + int m_userIndex; + + int m_userIndex3; + + ///time of impact calculation + btScalar m_hitFraction; + + ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: + btScalar m_ccdSweptSphereRadius; + + /// Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold + btScalar m_ccdMotionThreshold; + + /// If some object should have elaborate collision filtering by sub-classes + int m_checkCollideWith; + + btAlignedObjectArray m_objectsWithoutCollisionCheck; + + ///internal update revision number. It will be increased when the object changes. This allows some subsystems to perform lazy evaluation. + int m_updateRevision; + + btVector3 m_customDebugColorRGB; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + enum CollisionFlags + { + CF_DYNAMIC_OBJECT = 0, + CF_STATIC_OBJECT = 1, + CF_KINEMATIC_OBJECT = 2, + CF_NO_CONTACT_RESPONSE = 4, + CF_CUSTOM_MATERIAL_CALLBACK = 8, //this allows per-triangle material (friction/restitution) + CF_CHARACTER_OBJECT = 16, + CF_DISABLE_VISUALIZE_OBJECT = 32, //disable debug drawing + CF_DISABLE_SPU_COLLISION_PROCESSING = 64, //disable parallel/SPU processing + CF_HAS_CONTACT_STIFFNESS_DAMPING = 128, + CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR = 256, + CF_HAS_FRICTION_ANCHOR = 512, + CF_HAS_COLLISION_SOUND_TRIGGER = 1024 + }; + + enum CollisionObjectTypes + { + CO_COLLISION_OBJECT = 1, + CO_RIGID_BODY = 2, + ///CO_GHOST_OBJECT keeps track of all objects overlapping its AABB and that pass its collision filter + ///It is useful for collision sensors, explosion objects, character controller etc. + CO_GHOST_OBJECT = 4, + CO_SOFT_BODY = 8, + CO_HF_FLUID = 16, + CO_USER_TYPE = 32, + CO_FEATHERSTONE_LINK = 64 + }; + + enum AnisotropicFrictionFlags + { + CF_ANISOTROPIC_FRICTION_DISABLED = 0, + CF_ANISOTROPIC_FRICTION = 1, + CF_ANISOTROPIC_ROLLING_FRICTION = 2 + }; + + SIMD_FORCE_INLINE bool mergesSimulationIslands() const + { + ///static objects, kinematic and object without contact response don't merge islands + return ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE)) == 0); + } + + const btVector3& getAnisotropicFriction() const + { + return m_anisotropicFriction; + } + void setAnisotropicFriction(const btVector3& anisotropicFriction, int frictionMode = CF_ANISOTROPIC_FRICTION) + { + m_anisotropicFriction = anisotropicFriction; + bool isUnity = (anisotropicFriction[0] != 1.f) || (anisotropicFriction[1] != 1.f) || (anisotropicFriction[2] != 1.f); + m_hasAnisotropicFriction = isUnity ? frictionMode : 0; + } + bool hasAnisotropicFriction(int frictionMode = CF_ANISOTROPIC_FRICTION) const + { + return (m_hasAnisotropicFriction & frictionMode) != 0; + } + + ///the constraint solver can discard solving contacts, if the distance is above this threshold. 0 by default. + ///Note that using contacts with positive distance can improve stability. It increases, however, the chance of colliding with degerate contacts, such as 'interior' triangle edges + void setContactProcessingThreshold(btScalar contactProcessingThreshold) + { + m_contactProcessingThreshold = contactProcessingThreshold; + } + btScalar getContactProcessingThreshold() const + { + return m_contactProcessingThreshold; + } + + SIMD_FORCE_INLINE bool isStaticObject() const + { + return (m_collisionFlags & CF_STATIC_OBJECT) != 0; + } + + SIMD_FORCE_INLINE bool isKinematicObject() const + { + return (m_collisionFlags & CF_KINEMATIC_OBJECT) != 0; + } + + SIMD_FORCE_INLINE bool isStaticOrKinematicObject() const + { + return (m_collisionFlags & (CF_KINEMATIC_OBJECT | CF_STATIC_OBJECT)) != 0; + } + + SIMD_FORCE_INLINE bool hasContactResponse() const + { + return (m_collisionFlags & CF_NO_CONTACT_RESPONSE) == 0; + } + + btCollisionObject(); + + virtual ~btCollisionObject(); + + virtual void setCollisionShape(btCollisionShape * collisionShape) + { + m_updateRevision++; + m_collisionShape = collisionShape; + m_rootCollisionShape = collisionShape; + } + + SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const + { + return m_collisionShape; + } + + SIMD_FORCE_INLINE btCollisionShape* getCollisionShape() + { + return m_collisionShape; + } + + void setIgnoreCollisionCheck(const btCollisionObject* co, bool ignoreCollisionCheck) + { + if (ignoreCollisionCheck) + { + //We don't check for duplicates. Is it ok to leave that up to the user of this API? + //int index = m_objectsWithoutCollisionCheck.findLinearSearch(co); + //if (index == m_objectsWithoutCollisionCheck.size()) + //{ + m_objectsWithoutCollisionCheck.push_back(co); + //} + } + else + { + m_objectsWithoutCollisionCheck.remove(co); + } + m_checkCollideWith = m_objectsWithoutCollisionCheck.size() > 0; + } + + int getNumObjectsWithoutCollision() const + { + return m_objectsWithoutCollisionCheck.size(); + } + + const btCollisionObject* getObjectWithoutCollision(int index) + { + return m_objectsWithoutCollisionCheck[index]; + } + + virtual bool checkCollideWithOverride(const btCollisionObject* co) const + { + int index = m_objectsWithoutCollisionCheck.findLinearSearch(co); + if (index < m_objectsWithoutCollisionCheck.size()) + { + return false; + } + return true; + } + + ///Avoid using this internal API call, the extension pointer is used by some Bullet extensions. + ///If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead. + void* internalGetExtensionPointer() const + { + return m_extensionPointer; + } + ///Avoid using this internal API call, the extension pointer is used by some Bullet extensions + ///If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead. + void internalSetExtensionPointer(void* pointer) + { + m_extensionPointer = pointer; + } + + SIMD_FORCE_INLINE int getActivationState() const { return m_activationState1; } + + void setActivationState(int newState) const; + + void setDeactivationTime(btScalar time) + { + m_deactivationTime = time; + } + btScalar getDeactivationTime() const + { + return m_deactivationTime; + } + + void forceActivationState(int newState) const; + + void activate(bool forceActivation = false) const; + + SIMD_FORCE_INLINE bool isActive() const + { + return ((getActivationState() != FIXED_BASE_MULTI_BODY) && (getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION)); + } + + void setRestitution(btScalar rest) + { + m_updateRevision++; + m_restitution = rest; + } + btScalar getRestitution() const + { + return m_restitution; + } + void setFriction(btScalar frict) + { + m_updateRevision++; + m_friction = frict; + } + btScalar getFriction() const + { + return m_friction; + } + + void setRollingFriction(btScalar frict) + { + m_updateRevision++; + m_rollingFriction = frict; + } + btScalar getRollingFriction() const + { + return m_rollingFriction; + } + void setSpinningFriction(btScalar frict) + { + m_updateRevision++; + m_spinningFriction = frict; + } + btScalar getSpinningFriction() const + { + return m_spinningFriction; + } + void setContactStiffnessAndDamping(btScalar stiffness, btScalar damping) + { + m_updateRevision++; + m_contactStiffness = stiffness; + m_contactDamping = damping; + + m_collisionFlags |= CF_HAS_CONTACT_STIFFNESS_DAMPING; + + //avoid divisions by zero... + if (m_contactStiffness < SIMD_EPSILON) + { + m_contactStiffness = SIMD_EPSILON; + } + } + + btScalar getContactStiffness() const + { + return m_contactStiffness; + } + + btScalar getContactDamping() const + { + return m_contactDamping; + } + + ///reserved for Bullet internal usage + int getInternalType() const + { + return m_internalType; + } + + btTransform& getWorldTransform() + { + return m_worldTransform; + } + + const btTransform& getWorldTransform() const + { + return m_worldTransform; + } + + void setWorldTransform(const btTransform& worldTrans) + { + m_updateRevision++; + m_worldTransform = worldTrans; + } + + SIMD_FORCE_INLINE btBroadphaseProxy* getBroadphaseHandle() + { + return m_broadphaseHandle; + } + + SIMD_FORCE_INLINE const btBroadphaseProxy* getBroadphaseHandle() const + { + return m_broadphaseHandle; + } + + void setBroadphaseHandle(btBroadphaseProxy * handle) + { + m_broadphaseHandle = handle; + } + + const btTransform& getInterpolationWorldTransform() const + { + return m_interpolationWorldTransform; + } + + btTransform& getInterpolationWorldTransform() + { + return m_interpolationWorldTransform; + } + + void setInterpolationWorldTransform(const btTransform& trans) + { + m_updateRevision++; + m_interpolationWorldTransform = trans; + } + + void setInterpolationLinearVelocity(const btVector3& linvel) + { + m_updateRevision++; + m_interpolationLinearVelocity = linvel; + } + + void setInterpolationAngularVelocity(const btVector3& angvel) + { + m_updateRevision++; + m_interpolationAngularVelocity = angvel; + } + + const btVector3& getInterpolationLinearVelocity() const + { + return m_interpolationLinearVelocity; + } + + const btVector3& getInterpolationAngularVelocity() const + { + return m_interpolationAngularVelocity; + } + + SIMD_FORCE_INLINE int getIslandTag() const + { + return m_islandTag1; + } + + void setIslandTag(int tag) + { + m_islandTag1 = tag; + } + + SIMD_FORCE_INLINE int getCompanionId() const + { + return m_companionId; + } + + void setCompanionId(int id) + { + m_companionId = id; + } + + SIMD_FORCE_INLINE int getWorldArrayIndex() const + { + return m_worldArrayIndex; + } + + // only should be called by CollisionWorld + void setWorldArrayIndex(int ix) + { + m_worldArrayIndex = ix; + } + + SIMD_FORCE_INLINE btScalar getHitFraction() const + { + return m_hitFraction; + } + + void setHitFraction(btScalar hitFraction) + { + m_hitFraction = hitFraction; + } + + SIMD_FORCE_INLINE int getCollisionFlags() const + { + return m_collisionFlags; + } + + void setCollisionFlags(int flags) + { + m_collisionFlags = flags; + } + + ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: + btScalar getCcdSweptSphereRadius() const + { + return m_ccdSweptSphereRadius; + } + + ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: + void setCcdSweptSphereRadius(btScalar radius) + { + m_ccdSweptSphereRadius = radius; + } + + btScalar getCcdMotionThreshold() const + { + return m_ccdMotionThreshold; + } + + btScalar getCcdSquareMotionThreshold() const + { + return m_ccdMotionThreshold * m_ccdMotionThreshold; + } + + /// Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold + void setCcdMotionThreshold(btScalar ccdMotionThreshold) + { + m_ccdMotionThreshold = ccdMotionThreshold; + } + + ///users can point to their objects, userPointer is not used by Bullet + void* getUserPointer() const + { + return m_userObjectPointer; + } + + int getUserIndex() const + { + return m_userIndex; + } + + int getUserIndex2() const + { + return m_userIndex2; + } + + int getUserIndex3() const + { + return m_userIndex3; + } + + ///users can point to their objects, userPointer is not used by Bullet + void setUserPointer(void* userPointer) + { + m_userObjectPointer = userPointer; + } + + ///users can point to their objects, userPointer is not used by Bullet + void setUserIndex(int index) + { + m_userIndex = index; + } + + void setUserIndex2(int index) + { + m_userIndex2 = index; + } + + void setUserIndex3(int index) + { + m_userIndex3 = index; + } + + int getUpdateRevisionInternal() const + { + return m_updateRevision; + } + + void setCustomDebugColor(const btVector3& colorRGB) + { + m_customDebugColorRGB = colorRGB; + m_collisionFlags |= CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR; + } + + void removeCustomDebugColor() + { + m_collisionFlags &= ~CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR; + } + + bool getCustomDebugColor(btVector3 & colorRGB) const + { + bool hasCustomColor = (0 != (m_collisionFlags & CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR)); + if (hasCustomColor) + { + colorRGB = m_customDebugColorRGB; + } + return hasCustomColor; + } + + inline bool checkCollideWith(const btCollisionObject* co) const + { + if (m_checkCollideWith) + return checkCollideWithOverride(co); + + return true; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const; + + virtual void serializeSingleObject(class btSerializer * serializer) const; +}; + +// clang-format off + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btCollisionObjectDoubleData +{ + void *m_broadphaseHandle; + void *m_collisionShape; + btCollisionShapeData *m_rootCollisionShape; + char *m_name; + + btTransformDoubleData m_worldTransform; + btTransformDoubleData m_interpolationWorldTransform; + btVector3DoubleData m_interpolationLinearVelocity; + btVector3DoubleData m_interpolationAngularVelocity; + btVector3DoubleData m_anisotropicFriction; + double m_contactProcessingThreshold; + double m_deactivationTime; + double m_friction; + double m_rollingFriction; + double m_contactDamping; + double m_contactStiffness; + double m_restitution; + double m_hitFraction; + double m_ccdSweptSphereRadius; + double m_ccdMotionThreshold; + int m_hasAnisotropicFriction; + int m_collisionFlags; + int m_islandTag1; + int m_companionId; + int m_activationState1; + int m_internalType; + int m_checkCollideWith; + int m_collisionFilterGroup; + int m_collisionFilterMask; + int m_uniqueId;//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btCollisionObjectFloatData +{ + void *m_broadphaseHandle; + void *m_collisionShape; + btCollisionShapeData *m_rootCollisionShape; + char *m_name; + + btTransformFloatData m_worldTransform; + btTransformFloatData m_interpolationWorldTransform; + btVector3FloatData m_interpolationLinearVelocity; + btVector3FloatData m_interpolationAngularVelocity; + btVector3FloatData m_anisotropicFriction; + float m_contactProcessingThreshold; + float m_deactivationTime; + float m_friction; + float m_rollingFriction; + float m_contactDamping; + float m_contactStiffness; + float m_restitution; + float m_hitFraction; + float m_ccdSweptSphereRadius; + float m_ccdMotionThreshold; + int m_hasAnisotropicFriction; + int m_collisionFlags; + int m_islandTag1; + int m_companionId; + int m_activationState1; + int m_internalType; + int m_checkCollideWith; + int m_collisionFilterGroup; + int m_collisionFilterMask; + int m_uniqueId; +}; +// clang-format on + +SIMD_FORCE_INLINE int btCollisionObject::calculateSerializeBufferSize() const +{ + return sizeof(btCollisionObjectData); +} + +#endif //BT_COLLISION_OBJECT_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.h.i new file mode 100644 index 00000000..972eb10e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObject.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionObject.h ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionObject.h" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h new file mode 100644 index 00000000..c0e46b4e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h @@ -0,0 +1,49 @@ +#ifndef BT_COLLISION_OBJECT_WRAPPER_H +#define BT_COLLISION_OBJECT_WRAPPER_H + +///btCollisionObjectWrapperis an internal data structure. +///Most users can ignore this and use btCollisionObject and btCollisionShape instead +class btCollisionShape; +class btCollisionObject; +class btTransform; +#include "LinearMath/btScalar.h" // for SIMD_FORCE_INLINE definition + +#define BT_DECLARE_STACK_ONLY_OBJECT \ +public: \ + void* operator new(size_t size); \ + void operator delete(void*); + +struct btCollisionObjectWrapper; +struct btCollisionObjectWrapper +{ + BT_DECLARE_STACK_ONLY_OBJECT + +private: + btCollisionObjectWrapper(const btCollisionObjectWrapper&); // not implemented. Not allowed. + btCollisionObjectWrapper* operator=(const btCollisionObjectWrapper&); + +public: + const btCollisionObjectWrapper* m_parent; + const btCollisionShape* m_shape; + const btCollisionObject* m_collisionObject; + const btTransform& m_worldTransform; + const btTransform* m_preTransform; + int m_partId; + int m_index; + + btCollisionObjectWrapper(const btCollisionObjectWrapper* parent, const btCollisionShape* shape, const btCollisionObject* collisionObject, const btTransform& worldTransform, int partId, int index) + : m_parent(parent), m_shape(shape), m_collisionObject(collisionObject), m_worldTransform(worldTransform), m_preTransform(NULL), m_partId(partId), m_index(index) + { + } + + btCollisionObjectWrapper(const btCollisionObjectWrapper* parent, const btCollisionShape* shape, const btCollisionObject* collisionObject, const btTransform& worldTransform, const btTransform& preTransform, int partId, int index) + : m_parent(parent), m_shape(shape), m_collisionObject(collisionObject), m_worldTransform(worldTransform), m_preTransform(&preTransform), m_partId(partId), m_index(index) + { + } + + SIMD_FORCE_INLINE const btTransform& getWorldTransform() const { return m_worldTransform; } + SIMD_FORCE_INLINE const btCollisionObject* getCollisionObject() const { return m_collisionObject; } + SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const { return m_shape; } +}; + +#endif //BT_COLLISION_OBJECT_WRAPPER_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h.i new file mode 100644 index 00000000..2ed691ef --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h ---------------- + +// %include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.cpp new file mode 100644 index 00000000..e6ffdd48 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.cpp @@ -0,0 +1,1645 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btCollisionWorld.h" +#include "btCollisionDispatcher.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionShapes/btCollisionShape.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" //for raycasting +#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" //for raycasting +#include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h" //for raycasting +#include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h" //for raycasting +#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h" +#include "BulletCollision/CollisionShapes/btCompoundShape.h" +#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h" +#include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h" +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" +#include "BulletCollision/BroadphaseCollision/btDbvt.h" +#include "LinearMath/btAabbUtil2.h" +#include "LinearMath/btQuickprof.h" +#include "LinearMath/btSerializer.h" +#include "BulletCollision/CollisionShapes/btConvexPolyhedron.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +//#define DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION + +//#define USE_BRUTEFORCE_RAYBROADPHASE 1 +//RECALCULATE_AABB is slower, but benefit is that you don't need to call 'stepSimulation' or 'updateAabbs' before using a rayTest +//#define RECALCULATE_AABB_RAYCAST 1 + +//When the user doesn't provide dispatcher or broadphase, create basic versions (and delete them in destructor) +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h" +#include "BulletCollision/CollisionDispatch/btCollisionConfiguration.h" + +///for debug drawing + +//for debug rendering +#include "BulletCollision/CollisionShapes/btBoxShape.h" +#include "BulletCollision/CollisionShapes/btCapsuleShape.h" +#include "BulletCollision/CollisionShapes/btCompoundShape.h" +#include "BulletCollision/CollisionShapes/btConeShape.h" +#include "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h" +#include "BulletCollision/CollisionShapes/btCylinderShape.h" +#include "BulletCollision/CollisionShapes/btMultiSphereShape.h" +#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" +#include "BulletCollision/CollisionShapes/btTriangleCallback.h" +#include "BulletCollision/CollisionShapes/btTriangleMeshShape.h" +#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h" + +btCollisionWorld::btCollisionWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btCollisionConfiguration* collisionConfiguration) + : m_dispatcher1(dispatcher), + m_broadphasePairCache(pairCache), + m_debugDrawer(0), + m_forceUpdateAllAabbs(true) +{ +} + +btCollisionWorld::~btCollisionWorld() +{ + //clean up remaining objects + int i; + for (i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* collisionObject = m_collisionObjects[i]; + + btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle(); + if (bp) + { + // + // only clear the cached algorithms + // + getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp, m_dispatcher1); + getBroadphase()->destroyProxy(bp, m_dispatcher1); + collisionObject->setBroadphaseHandle(0); + } + } +} + +void btCollisionWorld::refreshBroadphaseProxy(btCollisionObject* collisionObject) +{ + if (collisionObject->getBroadphaseHandle()) + { + int collisionFilterGroup = collisionObject->getBroadphaseHandle()->m_collisionFilterGroup; + int collisionFilterMask = collisionObject->getBroadphaseHandle()->m_collisionFilterMask; + + getBroadphase()->destroyProxy(collisionObject->getBroadphaseHandle(), getDispatcher()); + + //calculate new AABB + btTransform trans = collisionObject->getWorldTransform(); + + btVector3 minAabb; + btVector3 maxAabb; + collisionObject->getCollisionShape()->getAabb(trans, minAabb, maxAabb); + + int type = collisionObject->getCollisionShape()->getShapeType(); + collisionObject->setBroadphaseHandle(getBroadphase()->createProxy( + minAabb, + maxAabb, + type, + collisionObject, + collisionFilterGroup, + collisionFilterMask, + m_dispatcher1)); + } +} + +void btCollisionWorld::addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup, int collisionFilterMask) +{ + btAssert(collisionObject); + + //check that the object isn't already added + btAssert(m_collisionObjects.findLinearSearch(collisionObject) == m_collisionObjects.size()); + btAssert(collisionObject->getWorldArrayIndex() == -1); // do not add the same object to more than one collision world + + collisionObject->setWorldArrayIndex(m_collisionObjects.size()); + m_collisionObjects.push_back(collisionObject); + + //calculate new AABB + btTransform trans = collisionObject->getWorldTransform(); + + btVector3 minAabb; + btVector3 maxAabb; + collisionObject->getCollisionShape()->getAabb(trans, minAabb, maxAabb); + + int type = collisionObject->getCollisionShape()->getShapeType(); + collisionObject->setBroadphaseHandle(getBroadphase()->createProxy( + minAabb, + maxAabb, + type, + collisionObject, + collisionFilterGroup, + collisionFilterMask, + m_dispatcher1)); +} + +void btCollisionWorld::updateSingleAabb(btCollisionObject* colObj) +{ + btVector3 minAabb, maxAabb; + colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb, maxAabb); + //need to increase the aabb for contact thresholds + btVector3 contactThreshold(gContactBreakingThreshold, gContactBreakingThreshold, gContactBreakingThreshold); + minAabb -= contactThreshold; + maxAabb += contactThreshold; + + if (getDispatchInfo().m_useContinuous && colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY && !colObj->isStaticOrKinematicObject()) + { + btVector3 minAabb2, maxAabb2; + colObj->getCollisionShape()->getAabb(colObj->getInterpolationWorldTransform(), minAabb2, maxAabb2); + minAabb2 -= contactThreshold; + maxAabb2 += contactThreshold; + minAabb.setMin(minAabb2); + maxAabb.setMax(maxAabb2); + } + + btBroadphaseInterface* bp = (btBroadphaseInterface*)m_broadphasePairCache; + + //moving objects should be moderately sized, probably something wrong if not + if (colObj->isStaticObject() || ((maxAabb - minAabb).length2() < btScalar(1e12))) + { + bp->setAabb(colObj->getBroadphaseHandle(), minAabb, maxAabb, m_dispatcher1); + } + else + { + //something went wrong, investigate + //this assert is unwanted in 3D modelers (danger of loosing work) + colObj->setActivationState(DISABLE_SIMULATION); + + static bool reportMe = true; + if (reportMe && m_debugDrawer) + { + reportMe = false; + m_debugDrawer->reportErrorWarning("Overflow in AABB, object removed from simulation"); + m_debugDrawer->reportErrorWarning("If you can reproduce this, please email bugs@continuousphysics.com\n"); + m_debugDrawer->reportErrorWarning("Please include above information, your Platform, version of OS.\n"); + m_debugDrawer->reportErrorWarning("Thanks.\n"); + } + } +} + +void btCollisionWorld::updateAabbs() +{ +//\1("updateAabbs"); + + for (int i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + btAssert(colObj->getWorldArrayIndex() == i); + + //only update aabb of active objects + if (m_forceUpdateAllAabbs || colObj->isActive()) + { + updateSingleAabb(colObj); + } + } +} + +void btCollisionWorld::computeOverlappingPairs() +{ +//\1("calculateOverlappingPairs"); + m_broadphasePairCache->calculateOverlappingPairs(m_dispatcher1); +} + +void btCollisionWorld::performDiscreteCollisionDetection() +{ +//\1("performDiscreteCollisionDetection"); + + btDispatcherInfo& dispatchInfo = getDispatchInfo(); + + updateAabbs(); + + computeOverlappingPairs(); + + btDispatcher* dispatcher = getDispatcher(); + { +//\1("dispatchAllCollisionPairs"); + if (dispatcher) + dispatcher->dispatchAllCollisionPairs(m_broadphasePairCache->getOverlappingPairCache(), dispatchInfo, m_dispatcher1); + } +} + +void btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject) +{ + //bool removeFromBroadphase = false; + + { + btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle(); + if (bp) + { + // + // only clear the cached algorithms + // + getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp, m_dispatcher1); + getBroadphase()->destroyProxy(bp, m_dispatcher1); + collisionObject->setBroadphaseHandle(0); + } + } + + int iObj = collisionObject->getWorldArrayIndex(); + // btAssert(iObj >= 0 && iObj < m_collisionObjects.size()); // trying to remove an object that was never added or already removed previously? + if (iObj >= 0 && iObj < m_collisionObjects.size()) + { + btAssert(collisionObject == m_collisionObjects[iObj]); + m_collisionObjects.swap(iObj, m_collisionObjects.size() - 1); + m_collisionObjects.pop_back(); + if (iObj < m_collisionObjects.size()) + { + m_collisionObjects[iObj]->setWorldArrayIndex(iObj); + } + } + else + { + // slow linear search + //swapremove + m_collisionObjects.remove(collisionObject); + } + collisionObject->setWorldArrayIndex(-1); +} + +void btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans, const btTransform& rayToTrans, + btCollisionObject* collisionObject, + const btCollisionShape* collisionShape, + const btTransform& colObjWorldTransform, + RayResultCallback& resultCallback) +{ + btCollisionObjectWrapper colObWrap(0, collisionShape, collisionObject, colObjWorldTransform, -1, -1); + btCollisionWorld::rayTestSingleInternal(rayFromTrans, rayToTrans, &colObWrap, resultCallback); +} + +void btCollisionWorld::rayTestSingleInternal(const btTransform& rayFromTrans, const btTransform& rayToTrans, + const btCollisionObjectWrapper* collisionObjectWrap, + RayResultCallback& resultCallback) +{ + btSphereShape pointShape(btScalar(0.0)); + pointShape.setMargin(0.f); + const btConvexShape* castShape = &pointShape; + const btCollisionShape* collisionShape = collisionObjectWrap->getCollisionShape(); + const btTransform& colObjWorldTransform = collisionObjectWrap->getWorldTransform(); + + if (collisionShape->isConvex()) + { + // BT_PROFILE("rayTestConvex"); + btConvexCast::CastResult castResult; + castResult.m_fraction = resultCallback.m_closestHitFraction; + + btConvexShape* convexShape = (btConvexShape*)collisionShape; + btVoronoiSimplexSolver simplexSolver; + btSubsimplexConvexCast subSimplexConvexCaster(castShape, convexShape, &simplexSolver); + + btGjkConvexCast gjkConvexCaster(castShape, convexShape, &simplexSolver); + + //btContinuousConvexCollision convexCaster(castShape,convexShape,&simplexSolver,0); + + btConvexCast* convexCasterPtr = 0; + //use kF_UseSubSimplexConvexCastRaytest by default + if (resultCallback.m_flags & btTriangleRaycastCallback::kF_UseGjkConvexCastRaytest) + convexCasterPtr = &gjkConvexCaster; + else + convexCasterPtr = &subSimplexConvexCaster; + + btConvexCast& convexCaster = *convexCasterPtr; + + if (convexCaster.calcTimeOfImpact(rayFromTrans, rayToTrans, colObjWorldTransform, colObjWorldTransform, castResult)) + { + //add hit + if (castResult.m_normal.length2() > btScalar(0.0001)) + { + if (castResult.m_fraction < resultCallback.m_closestHitFraction) + { + //todo: figure out what this is about. When is rayFromTest.getBasis() not identity? +#ifdef USE_SUBSIMPLEX_CONVEX_CAST + //rotate normal into worldspace + castResult.m_normal = rayFromTrans.getBasis() * castResult.m_normal; +#endif //USE_SUBSIMPLEX_CONVEX_CAST + + castResult.m_normal.normalize(); + btCollisionWorld::LocalRayResult localRayResult( + collisionObjectWrap->getCollisionObject(), + 0, + castResult.m_normal, + castResult.m_fraction); + + bool normalInWorldSpace = true; + resultCallback.addSingleResult(localRayResult, normalInWorldSpace); + } + } + } + } + else + { + if (collisionShape->isConcave()) + { + //ConvexCast::CastResult + struct BridgeTriangleRaycastCallback : public btTriangleRaycastCallback + { + btCollisionWorld::RayResultCallback* m_resultCallback; + const btCollisionObject* m_collisionObject; + const btConcaveShape* m_triangleMesh; + + btTransform m_colObjWorldTransform; + + BridgeTriangleRaycastCallback(const btVector3& from, const btVector3& to, + btCollisionWorld::RayResultCallback* resultCallback, const btCollisionObject* collisionObject, const btConcaveShape* triangleMesh, const btTransform& colObjWorldTransform) : //@BP Mod + btTriangleRaycastCallback(from, to, resultCallback->m_flags), + m_resultCallback(resultCallback), + m_collisionObject(collisionObject), + m_triangleMesh(triangleMesh), + m_colObjWorldTransform(colObjWorldTransform) + { + } + + virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex) + { + btCollisionWorld::LocalShapeInfo shapeInfo; + shapeInfo.m_shapePart = partId; + shapeInfo.m_triangleIndex = triangleIndex; + + btVector3 hitNormalWorld = m_colObjWorldTransform.getBasis() * hitNormalLocal; + + btCollisionWorld::LocalRayResult rayResult(m_collisionObject, + &shapeInfo, + hitNormalWorld, + hitFraction); + + bool normalInWorldSpace = true; + return m_resultCallback->addSingleResult(rayResult, normalInWorldSpace); + } + }; + + btTransform worldTocollisionObject = colObjWorldTransform.inverse(); + btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin(); + btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin(); + + // BT_PROFILE("rayTestConcave"); + if (collisionShape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE) + { + ///optimized version for btBvhTriangleMeshShape + btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape; + + BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->getCollisionObject(), triangleMesh, colObjWorldTransform); + rcb.m_hitFraction = resultCallback.m_closestHitFraction; + triangleMesh->performRaycast(&rcb, rayFromLocal, rayToLocal); + } + else if (collisionShape->getShapeType() == SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE) + { + ///optimized version for btScaledBvhTriangleMeshShape + btScaledBvhTriangleMeshShape* scaledTriangleMesh = (btScaledBvhTriangleMeshShape*)collisionShape; + btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)scaledTriangleMesh->getChildShape(); + + //scale the ray positions + btVector3 scale = scaledTriangleMesh->getLocalScaling(); + btVector3 rayFromLocalScaled = rayFromLocal / scale; + btVector3 rayToLocalScaled = rayToLocal / scale; + + //perform raycast in the underlying btBvhTriangleMeshShape + BridgeTriangleRaycastCallback rcb(rayFromLocalScaled, rayToLocalScaled, &resultCallback, collisionObjectWrap->getCollisionObject(), triangleMesh, colObjWorldTransform); + rcb.m_hitFraction = resultCallback.m_closestHitFraction; + triangleMesh->performRaycast(&rcb, rayFromLocalScaled, rayToLocalScaled); + } + else if (((resultCallback.m_flags&btTriangleRaycastCallback::kF_DisableHeightfieldAccelerator)==0) + && collisionShape->getShapeType() == TERRAIN_SHAPE_PROXYTYPE + ) + { + ///optimized version for btHeightfieldTerrainShape + btHeightfieldTerrainShape* heightField = (btHeightfieldTerrainShape*)collisionShape; + btTransform worldTocollisionObject = colObjWorldTransform.inverse(); + btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin(); + btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin(); + + BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->getCollisionObject(), heightField, colObjWorldTransform); + rcb.m_hitFraction = resultCallback.m_closestHitFraction; + heightField->performRaycast(&rcb, rayFromLocal, rayToLocal); + } + else + { + //generic (slower) case + btConcaveShape* concaveShape = (btConcaveShape*)collisionShape; + + btTransform worldTocollisionObject = colObjWorldTransform.inverse(); + + btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin(); + btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin(); + + //ConvexCast::CastResult + + struct BridgeTriangleRaycastCallback : public btTriangleRaycastCallback + { + btCollisionWorld::RayResultCallback* m_resultCallback; + const btCollisionObject* m_collisionObject; + btConcaveShape* m_triangleMesh; + + btTransform m_colObjWorldTransform; + + BridgeTriangleRaycastCallback(const btVector3& from, const btVector3& to, + btCollisionWorld::RayResultCallback* resultCallback, const btCollisionObject* collisionObject, btConcaveShape* triangleMesh, const btTransform& colObjWorldTransform) : //@BP Mod + btTriangleRaycastCallback(from, to, resultCallback->m_flags), + m_resultCallback(resultCallback), + m_collisionObject(collisionObject), + m_triangleMesh(triangleMesh), + m_colObjWorldTransform(colObjWorldTransform) + { + } + + virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex) + { + btCollisionWorld::LocalShapeInfo shapeInfo; + shapeInfo.m_shapePart = partId; + shapeInfo.m_triangleIndex = triangleIndex; + + btVector3 hitNormalWorld = m_colObjWorldTransform.getBasis() * hitNormalLocal; + + btCollisionWorld::LocalRayResult rayResult(m_collisionObject, + &shapeInfo, + hitNormalWorld, + hitFraction); + + bool normalInWorldSpace = true; + return m_resultCallback->addSingleResult(rayResult, normalInWorldSpace); + } + }; + + BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->getCollisionObject(), concaveShape, colObjWorldTransform); + rcb.m_hitFraction = resultCallback.m_closestHitFraction; + + btVector3 rayAabbMinLocal = rayFromLocal; + rayAabbMinLocal.setMin(rayToLocal); + btVector3 rayAabbMaxLocal = rayFromLocal; + rayAabbMaxLocal.setMax(rayToLocal); + + concaveShape->processAllTriangles(&rcb, rayAabbMinLocal, rayAabbMaxLocal); + } + } + else + { + // BT_PROFILE("rayTestCompound"); + if (collisionShape->isCompound()) + { + struct LocalInfoAdder2 : public RayResultCallback + { + RayResultCallback* m_userCallback; + int m_i; + + LocalInfoAdder2(int i, RayResultCallback* user) + : m_userCallback(user), m_i(i) + { + m_closestHitFraction = m_userCallback->m_closestHitFraction; + m_flags = m_userCallback->m_flags; + } + virtual bool needsCollision(btBroadphaseProxy* p) const + { + return m_userCallback->needsCollision(p); + } + + virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& r, bool b) + { + btCollisionWorld::LocalShapeInfo shapeInfo; + shapeInfo.m_shapePart = -1; + shapeInfo.m_triangleIndex = m_i; + if (r.m_localShapeInfo == NULL) + r.m_localShapeInfo = &shapeInfo; + + const btScalar result = m_userCallback->addSingleResult(r, b); + m_closestHitFraction = m_userCallback->m_closestHitFraction; + return result; + } + }; + + struct RayTester : btDbvt::ICollide + { + const btCollisionObject* m_collisionObject; + const btCompoundShape* m_compoundShape; + const btTransform& m_colObjWorldTransform; + const btTransform& m_rayFromTrans; + const btTransform& m_rayToTrans; + RayResultCallback& m_resultCallback; + + RayTester(const btCollisionObject* collisionObject, + const btCompoundShape* compoundShape, + const btTransform& colObjWorldTransform, + const btTransform& rayFromTrans, + const btTransform& rayToTrans, + RayResultCallback& resultCallback) : m_collisionObject(collisionObject), + m_compoundShape(compoundShape), + m_colObjWorldTransform(colObjWorldTransform), + m_rayFromTrans(rayFromTrans), + m_rayToTrans(rayToTrans), + m_resultCallback(resultCallback) + { + } + + void ProcessLeaf(int i) + { + const btCollisionShape* childCollisionShape = m_compoundShape->getChildShape(i); + const btTransform& childTrans = m_compoundShape->getChildTransform(i); + btTransform childWorldTrans = m_colObjWorldTransform * childTrans; + + btCollisionObjectWrapper tmpOb(0, childCollisionShape, m_collisionObject, childWorldTrans, -1, i); + // replace collision shape so that callback can determine the triangle + + LocalInfoAdder2 my_cb(i, &m_resultCallback); + + rayTestSingleInternal( + m_rayFromTrans, + m_rayToTrans, + &tmpOb, + my_cb); + } + + void Process(const btDbvtNode* leaf) + { + ProcessLeaf(leaf->dataAsInt); + } + }; + + const btCompoundShape* compoundShape = static_cast(collisionShape); + const btDbvt* dbvt = compoundShape->getDynamicAabbTree(); + + RayTester rayCB( + collisionObjectWrap->getCollisionObject(), + compoundShape, + colObjWorldTransform, + rayFromTrans, + rayToTrans, + resultCallback); +#ifndef DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION + if (dbvt) + { + btVector3 localRayFrom = colObjWorldTransform.inverseTimes(rayFromTrans).getOrigin(); + btVector3 localRayTo = colObjWorldTransform.inverseTimes(rayToTrans).getOrigin(); + btDbvt::rayTest(dbvt->m_root, localRayFrom, localRayTo, rayCB); + } + else +#endif //DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION + { + for (int i = 0, n = compoundShape->getNumChildShapes(); i < n; ++i) + { + rayCB.ProcessLeaf(i); + } + } + } + } + } +} + +void btCollisionWorld::objectQuerySingle(const btConvexShape* castShape, const btTransform& convexFromTrans, const btTransform& convexToTrans, + btCollisionObject* collisionObject, + const btCollisionShape* collisionShape, + const btTransform& colObjWorldTransform, + ConvexResultCallback& resultCallback, btScalar allowedPenetration) +{ + btCollisionObjectWrapper tmpOb(0, collisionShape, collisionObject, colObjWorldTransform, -1, -1); + btCollisionWorld::objectQuerySingleInternal(castShape, convexFromTrans, convexToTrans, &tmpOb, resultCallback, allowedPenetration); +} + +void btCollisionWorld::objectQuerySingleInternal(const btConvexShape* castShape, const btTransform& convexFromTrans, const btTransform& convexToTrans, + const btCollisionObjectWrapper* colObjWrap, + ConvexResultCallback& resultCallback, btScalar allowedPenetration) +{ + const btCollisionShape* collisionShape = colObjWrap->getCollisionShape(); + const btTransform& colObjWorldTransform = colObjWrap->getWorldTransform(); + + if (collisionShape->isConvex()) + { + //BT_PROFILE("convexSweepConvex"); + btConvexCast::CastResult castResult; + castResult.m_allowedPenetration = allowedPenetration; + castResult.m_fraction = resultCallback.m_closestHitFraction; //btScalar(1.);//?? + + btConvexShape* convexShape = (btConvexShape*)collisionShape; + btVoronoiSimplexSolver simplexSolver; + btGjkEpaPenetrationDepthSolver gjkEpaPenetrationSolver; + + btContinuousConvexCollision convexCaster1(castShape, convexShape, &simplexSolver, &gjkEpaPenetrationSolver); + //btGjkConvexCast convexCaster2(castShape,convexShape,&simplexSolver); + //btSubsimplexConvexCast convexCaster3(castShape,convexShape,&simplexSolver); + + btConvexCast* castPtr = &convexCaster1; + + if (castPtr->calcTimeOfImpact(convexFromTrans, convexToTrans, colObjWorldTransform, colObjWorldTransform, castResult)) + { + //add hit + if (castResult.m_normal.length2() > btScalar(0.0001)) + { + if (castResult.m_fraction < resultCallback.m_closestHitFraction) + { + castResult.m_normal.normalize(); + btCollisionWorld::LocalConvexResult localConvexResult( + colObjWrap->getCollisionObject(), + 0, + castResult.m_normal, + castResult.m_hitPoint, + castResult.m_fraction); + + bool normalInWorldSpace = true; + resultCallback.addSingleResult(localConvexResult, normalInWorldSpace); + } + } + } + } + else + { + if (collisionShape->isConcave()) + { + if (collisionShape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE) + { + //BT_PROFILE("convexSweepbtBvhTriangleMesh"); + btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape; + btTransform worldTocollisionObject = colObjWorldTransform.inverse(); + btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin(); + btVector3 convexToLocal = worldTocollisionObject * convexToTrans.getOrigin(); + // rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation + btTransform rotationXform = btTransform(worldTocollisionObject.getBasis() * convexToTrans.getBasis()); + + //ConvexCast::CastResult + struct BridgeTriangleConvexcastCallback : public btTriangleConvexcastCallback + { + btCollisionWorld::ConvexResultCallback* m_resultCallback; + const btCollisionObject* m_collisionObject; + btTriangleMeshShape* m_triangleMesh; + + BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from, const btTransform& to, + btCollisionWorld::ConvexResultCallback* resultCallback, const btCollisionObject* collisionObject, btTriangleMeshShape* triangleMesh, const btTransform& triangleToWorld) : btTriangleConvexcastCallback(castShape, from, to, triangleToWorld, triangleMesh->getMargin()), + m_resultCallback(resultCallback), + m_collisionObject(collisionObject), + m_triangleMesh(triangleMesh) + { + } + + virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex) + { + btCollisionWorld::LocalShapeInfo shapeInfo; + shapeInfo.m_shapePart = partId; + shapeInfo.m_triangleIndex = triangleIndex; + if (hitFraction <= m_resultCallback->m_closestHitFraction) + { + btCollisionWorld::LocalConvexResult convexResult(m_collisionObject, + &shapeInfo, + hitNormalLocal, + hitPointLocal, + hitFraction); + + bool normalInWorldSpace = true; + + return m_resultCallback->addSingleResult(convexResult, normalInWorldSpace); + } + return hitFraction; + } + }; + + BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans, convexToTrans, &resultCallback, colObjWrap->getCollisionObject(), triangleMesh, colObjWorldTransform); + tccb.m_hitFraction = resultCallback.m_closestHitFraction; + tccb.m_allowedPenetration = allowedPenetration; + btVector3 boxMinLocal, boxMaxLocal; + castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal); + triangleMesh->performConvexcast(&tccb, convexFromLocal, convexToLocal, boxMinLocal, boxMaxLocal); + } + else + { + if (collisionShape->getShapeType() == STATIC_PLANE_PROXYTYPE) + { + btConvexCast::CastResult castResult; + castResult.m_allowedPenetration = allowedPenetration; + castResult.m_fraction = resultCallback.m_closestHitFraction; + btStaticPlaneShape* planeShape = (btStaticPlaneShape*)collisionShape; + btContinuousConvexCollision convexCaster1(castShape, planeShape); + btConvexCast* castPtr = &convexCaster1; + + if (castPtr->calcTimeOfImpact(convexFromTrans, convexToTrans, colObjWorldTransform, colObjWorldTransform, castResult)) + { + //add hit + if (castResult.m_normal.length2() > btScalar(0.0001)) + { + if (castResult.m_fraction < resultCallback.m_closestHitFraction) + { + castResult.m_normal.normalize(); + btCollisionWorld::LocalConvexResult localConvexResult( + colObjWrap->getCollisionObject(), + 0, + castResult.m_normal, + castResult.m_hitPoint, + castResult.m_fraction); + + bool normalInWorldSpace = true; + resultCallback.addSingleResult(localConvexResult, normalInWorldSpace); + } + } + } + } + else + { + //BT_PROFILE("convexSweepConcave"); + btConcaveShape* concaveShape = (btConcaveShape*)collisionShape; + btTransform worldTocollisionObject = colObjWorldTransform.inverse(); + btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin(); + btVector3 convexToLocal = worldTocollisionObject * convexToTrans.getOrigin(); + // rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation + btTransform rotationXform = btTransform(worldTocollisionObject.getBasis() * convexToTrans.getBasis()); + + //ConvexCast::CastResult + struct BridgeTriangleConvexcastCallback : public btTriangleConvexcastCallback + { + btCollisionWorld::ConvexResultCallback* m_resultCallback; + const btCollisionObject* m_collisionObject; + btConcaveShape* m_triangleMesh; + + BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from, const btTransform& to, + btCollisionWorld::ConvexResultCallback* resultCallback, const btCollisionObject* collisionObject, btConcaveShape* triangleMesh, const btTransform& triangleToWorld) : btTriangleConvexcastCallback(castShape, from, to, triangleToWorld, triangleMesh->getMargin()), + m_resultCallback(resultCallback), + m_collisionObject(collisionObject), + m_triangleMesh(triangleMesh) + { + } + + virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex) + { + btCollisionWorld::LocalShapeInfo shapeInfo; + shapeInfo.m_shapePart = partId; + shapeInfo.m_triangleIndex = triangleIndex; + if (hitFraction <= m_resultCallback->m_closestHitFraction) + { + btCollisionWorld::LocalConvexResult convexResult(m_collisionObject, + &shapeInfo, + hitNormalLocal, + hitPointLocal, + hitFraction); + + bool normalInWorldSpace = true; + + return m_resultCallback->addSingleResult(convexResult, normalInWorldSpace); + } + return hitFraction; + } + }; + + BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans, convexToTrans, &resultCallback, colObjWrap->getCollisionObject(), concaveShape, colObjWorldTransform); + tccb.m_hitFraction = resultCallback.m_closestHitFraction; + tccb.m_allowedPenetration = allowedPenetration; + btVector3 boxMinLocal, boxMaxLocal; + castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal); + + btVector3 rayAabbMinLocal = convexFromLocal; + rayAabbMinLocal.setMin(convexToLocal); + btVector3 rayAabbMaxLocal = convexFromLocal; + rayAabbMaxLocal.setMax(convexToLocal); + rayAabbMinLocal += boxMinLocal; + rayAabbMaxLocal += boxMaxLocal; + concaveShape->processAllTriangles(&tccb, rayAabbMinLocal, rayAabbMaxLocal); + } + } + } + else + { + if (collisionShape->isCompound()) + { + struct btCompoundLeafCallback : btDbvt::ICollide + { + btCompoundLeafCallback( + const btCollisionObjectWrapper* colObjWrap, + const btConvexShape* castShape, + const btTransform& convexFromTrans, + const btTransform& convexToTrans, + btScalar allowedPenetration, + const btCompoundShape* compoundShape, + const btTransform& colObjWorldTransform, + ConvexResultCallback& resultCallback) + : m_colObjWrap(colObjWrap), + m_castShape(castShape), + m_convexFromTrans(convexFromTrans), + m_convexToTrans(convexToTrans), + m_allowedPenetration(allowedPenetration), + m_compoundShape(compoundShape), + m_colObjWorldTransform(colObjWorldTransform), + m_resultCallback(resultCallback) + { + } + + const btCollisionObjectWrapper* m_colObjWrap; + const btConvexShape* m_castShape; + const btTransform& m_convexFromTrans; + const btTransform& m_convexToTrans; + btScalar m_allowedPenetration; + const btCompoundShape* m_compoundShape; + const btTransform& m_colObjWorldTransform; + ConvexResultCallback& m_resultCallback; + + public: + void ProcessChild(int index, const btTransform& childTrans, const btCollisionShape* childCollisionShape) + { + btTransform childWorldTrans = m_colObjWorldTransform * childTrans; + + struct LocalInfoAdder : public ConvexResultCallback + { + ConvexResultCallback* m_userCallback; + int m_i; + + LocalInfoAdder(int i, ConvexResultCallback* user) + : m_userCallback(user), m_i(i) + { + m_closestHitFraction = m_userCallback->m_closestHitFraction; + } + virtual bool needsCollision(btBroadphaseProxy* p) const + { + return m_userCallback->needsCollision(p); + } + virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& r, bool b) + { + btCollisionWorld::LocalShapeInfo shapeInfo; + shapeInfo.m_shapePart = -1; + shapeInfo.m_triangleIndex = m_i; + if (r.m_localShapeInfo == NULL) + r.m_localShapeInfo = &shapeInfo; + const btScalar result = m_userCallback->addSingleResult(r, b); + m_closestHitFraction = m_userCallback->m_closestHitFraction; + return result; + } + }; + + LocalInfoAdder my_cb(index, &m_resultCallback); + + btCollisionObjectWrapper tmpObj(m_colObjWrap, childCollisionShape, m_colObjWrap->getCollisionObject(), childWorldTrans, -1, index); + + objectQuerySingleInternal(m_castShape, m_convexFromTrans, m_convexToTrans, &tmpObj, my_cb, m_allowedPenetration); + } + + void Process(const btDbvtNode* leaf) + { + // Processing leaf node + int index = leaf->dataAsInt; + + btTransform childTrans = m_compoundShape->getChildTransform(index); + const btCollisionShape* childCollisionShape = m_compoundShape->getChildShape(index); + + ProcessChild(index, childTrans, childCollisionShape); + } + }; + +//\1("convexSweepCompound"); + const btCompoundShape* compoundShape = static_cast(collisionShape); + + btVector3 fromLocalAabbMin, fromLocalAabbMax; + btVector3 toLocalAabbMin, toLocalAabbMax; + + castShape->getAabb(colObjWorldTransform.inverse() * convexFromTrans, fromLocalAabbMin, fromLocalAabbMax); + castShape->getAabb(colObjWorldTransform.inverse() * convexToTrans, toLocalAabbMin, toLocalAabbMax); + + fromLocalAabbMin.setMin(toLocalAabbMin); + fromLocalAabbMax.setMax(toLocalAabbMax); + + btCompoundLeafCallback callback(colObjWrap, castShape, convexFromTrans, convexToTrans, + allowedPenetration, compoundShape, colObjWorldTransform, resultCallback); + + const btDbvt* tree = compoundShape->getDynamicAabbTree(); + if (tree) + { + const ATTRIBUTE_ALIGNED16(btDbvtVolume) bounds = btDbvtVolume::FromMM(fromLocalAabbMin, fromLocalAabbMax); + tree->collideTV(tree->m_root, bounds, callback); + } + else + { + int i; + for (i = 0; i < compoundShape->getNumChildShapes(); i++) + { + const btCollisionShape* childCollisionShape = compoundShape->getChildShape(i); + btTransform childTrans = compoundShape->getChildTransform(i); + callback.ProcessChild(i, childTrans, childCollisionShape); + } + } + } + } + } +} + +struct btSingleRayCallback : public btBroadphaseRayCallback +{ + btVector3 m_rayFromWorld; + btVector3 m_rayToWorld; + btTransform m_rayFromTrans; + btTransform m_rayToTrans; + btVector3 m_hitNormal; + + const btCollisionWorld* m_world; + btCollisionWorld::RayResultCallback& m_resultCallback; + + btSingleRayCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld, const btCollisionWorld* world, btCollisionWorld::RayResultCallback& resultCallback) + : m_rayFromWorld(rayFromWorld), + m_rayToWorld(rayToWorld), + m_world(world), + m_resultCallback(resultCallback) + { + m_rayFromTrans.setIdentity(); + m_rayFromTrans.setOrigin(m_rayFromWorld); + m_rayToTrans.setIdentity(); + m_rayToTrans.setOrigin(m_rayToWorld); + + btVector3 rayDir = (rayToWorld - rayFromWorld); + + rayDir.normalize(); + ///what about division by zero? --> just set rayDirection[i] to INF/BT_LARGE_FLOAT + m_rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[0]; + m_rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[1]; + m_rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[2]; + m_signs[0] = m_rayDirectionInverse[0] < 0.0; + m_signs[1] = m_rayDirectionInverse[1] < 0.0; + m_signs[2] = m_rayDirectionInverse[2] < 0.0; + + m_lambda_max = rayDir.dot(m_rayToWorld - m_rayFromWorld); + } + + virtual bool process(const btBroadphaseProxy* proxy) + { + ///terminate further ray tests, once the closestHitFraction reached zero + if (m_resultCallback.m_closestHitFraction == btScalar(0.f)) + return false; + + btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject; + + //only perform raycast if filterMask matches + if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) + { + //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject(); + //btVector3 collisionObjectAabbMin,collisionObjectAabbMax; +#if 0 +#ifdef RECALCULATE_AABB + btVector3 collisionObjectAabbMin,collisionObjectAabbMax; + collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax); +#else + //getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax); + const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin; + const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax; +#endif +#endif + //btScalar hitLambda = m_resultCallback.m_closestHitFraction; + //culling already done by broadphase + //if (btRayAabb(m_rayFromWorld,m_rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,m_hitNormal)) + { + m_world->rayTestSingle(m_rayFromTrans, m_rayToTrans, + collisionObject, + collisionObject->getCollisionShape(), + collisionObject->getWorldTransform(), + m_resultCallback); + } + } + return true; + } +}; + +void btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const +{ + //BT_PROFILE("rayTest"); + /// use the broadphase to accelerate the search for objects, based on their aabb + /// and for each object with ray-aabb overlap, perform an exact ray test + btSingleRayCallback rayCB(rayFromWorld, rayToWorld, this, resultCallback); + +#ifndef USE_BRUTEFORCE_RAYBROADPHASE + m_broadphasePairCache->rayTest(rayFromWorld, rayToWorld, rayCB); +#else + for (int i = 0; i < this->getNumCollisionObjects(); i++) + { + rayCB.process(m_collisionObjects[i]->getBroadphaseHandle()); + } +#endif //USE_BRUTEFORCE_RAYBROADPHASE +} + +struct btSingleSweepCallback : public btBroadphaseRayCallback +{ + btTransform m_convexFromTrans; + btTransform m_convexToTrans; + btVector3 m_hitNormal; + const btCollisionWorld* m_world; + btCollisionWorld::ConvexResultCallback& m_resultCallback; + btScalar m_allowedCcdPenetration; + const btConvexShape* m_castShape; + + btSingleSweepCallback(const btConvexShape* castShape, const btTransform& convexFromTrans, const btTransform& convexToTrans, const btCollisionWorld* world, btCollisionWorld::ConvexResultCallback& resultCallback, btScalar allowedPenetration) + : m_convexFromTrans(convexFromTrans), + m_convexToTrans(convexToTrans), + m_world(world), + m_resultCallback(resultCallback), + m_allowedCcdPenetration(allowedPenetration), + m_castShape(castShape) + { + btVector3 unnormalizedRayDir = (m_convexToTrans.getOrigin() - m_convexFromTrans.getOrigin()); + btVector3 rayDir = unnormalizedRayDir.fuzzyZero() ? btVector3(btScalar(0.0), btScalar(0.0), btScalar(0.0)) : unnormalizedRayDir.normalized(); + ///what about division by zero? --> just set rayDirection[i] to INF/BT_LARGE_FLOAT + m_rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[0]; + m_rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[1]; + m_rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[2]; + m_signs[0] = m_rayDirectionInverse[0] < 0.0; + m_signs[1] = m_rayDirectionInverse[1] < 0.0; + m_signs[2] = m_rayDirectionInverse[2] < 0.0; + + m_lambda_max = rayDir.dot(unnormalizedRayDir); + } + + virtual bool process(const btBroadphaseProxy* proxy) + { + ///terminate further convex sweep tests, once the closestHitFraction reached zero + if (m_resultCallback.m_closestHitFraction == btScalar(0.f)) + return false; + + btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject; + + //only perform raycast if filterMask matches + if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) + { + //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject(); + m_world->objectQuerySingle(m_castShape, m_convexFromTrans, m_convexToTrans, + collisionObject, + collisionObject->getCollisionShape(), + collisionObject->getWorldTransform(), + m_resultCallback, + m_allowedCcdPenetration); + } + + return true; + } +}; + +void btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration) const +{ +//\1("convexSweepTest"); + /// use the broadphase to accelerate the search for objects, based on their aabb + /// and for each object with ray-aabb overlap, perform an exact ray test + /// unfortunately the implementation for rayTest and convexSweepTest duplicated, albeit practically identical + + btTransform convexFromTrans, convexToTrans; + convexFromTrans = convexFromWorld; + convexToTrans = convexToWorld; + btVector3 castShapeAabbMin, castShapeAabbMax; + /* Compute AABB that encompasses angular movement */ + { + btVector3 linVel, angVel; + btTransformUtil::calculateVelocity(convexFromTrans, convexToTrans, 1.0f, linVel, angVel); + btVector3 zeroLinVel; + zeroLinVel.setValue(0, 0, 0); + btTransform R; + R.setIdentity(); + R.setRotation(convexFromTrans.getRotation()); + castShape->calculateTemporalAabb(R, zeroLinVel, angVel, 1.0f, castShapeAabbMin, castShapeAabbMax); + } + +#ifndef USE_BRUTEFORCE_RAYBROADPHASE + + btSingleSweepCallback convexCB(castShape, convexFromWorld, convexToWorld, this, resultCallback, allowedCcdPenetration); + + m_broadphasePairCache->rayTest(convexFromTrans.getOrigin(), convexToTrans.getOrigin(), convexCB, castShapeAabbMin, castShapeAabbMax); + +#else + /// go over all objects, and if the ray intersects their aabb + cast shape aabb, + // do a ray-shape query using convexCaster (CCD) + int i; + for (i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* collisionObject = m_collisionObjects[i]; + //only perform raycast if filterMask matches + if (resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) + { + //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject(); + btVector3 collisionObjectAabbMin, collisionObjectAabbMax; + collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(), collisionObjectAabbMin, collisionObjectAabbMax); + AabbExpand(collisionObjectAabbMin, collisionObjectAabbMax, castShapeAabbMin, castShapeAabbMax); + btScalar hitLambda = btScalar(1.); //could use resultCallback.m_closestHitFraction, but needs testing + btVector3 hitNormal; + if (btRayAabb(convexFromWorld.getOrigin(), convexToWorld.getOrigin(), collisionObjectAabbMin, collisionObjectAabbMax, hitLambda, hitNormal)) + { + objectQuerySingle(castShape, convexFromTrans, convexToTrans, + collisionObject, + collisionObject->getCollisionShape(), + collisionObject->getWorldTransform(), + resultCallback, + allowedCcdPenetration); + } + } + } +#endif //USE_BRUTEFORCE_RAYBROADPHASE +} + +struct btBridgedManifoldResult : public btManifoldResult +{ + btCollisionWorld::ContactResultCallback& m_resultCallback; + + btBridgedManifoldResult(const btCollisionObjectWrapper* obj0Wrap, const btCollisionObjectWrapper* obj1Wrap, btCollisionWorld::ContactResultCallback& resultCallback) + : btManifoldResult(obj0Wrap, obj1Wrap), + m_resultCallback(resultCallback) + { + } + + virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth) + { + bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject(); + btVector3 pointA = pointInWorld + normalOnBInWorld * depth; + btVector3 localA; + btVector3 localB; + if (isSwapped) + { + localA = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointA); + localB = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld); + } + else + { + localA = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointA); + localB = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld); + } + + btManifoldPoint newPt(localA, localB, normalOnBInWorld, depth); + newPt.m_positionWorldOnA = pointA; + newPt.m_positionWorldOnB = pointInWorld; + + //BP mod, store contact triangles. + if (isSwapped) + { + newPt.m_partId0 = m_partId1; + newPt.m_partId1 = m_partId0; + newPt.m_index0 = m_index1; + newPt.m_index1 = m_index0; + } + else + { + newPt.m_partId0 = m_partId0; + newPt.m_partId1 = m_partId1; + newPt.m_index0 = m_index0; + newPt.m_index1 = m_index1; + } + + //experimental feature info, for per-triangle material etc. + const btCollisionObjectWrapper* obj0Wrap = isSwapped ? m_body1Wrap : m_body0Wrap; + const btCollisionObjectWrapper* obj1Wrap = isSwapped ? m_body0Wrap : m_body1Wrap; + m_resultCallback.addSingleResult(newPt, obj0Wrap, newPt.m_partId0, newPt.m_index0, obj1Wrap, newPt.m_partId1, newPt.m_index1); + } +}; + +struct btSingleContactCallback : public btBroadphaseAabbCallback +{ + btCollisionObject* m_collisionObject; + btCollisionWorld* m_world; + btCollisionWorld::ContactResultCallback& m_resultCallback; + + btSingleContactCallback(btCollisionObject* collisionObject, btCollisionWorld* world, btCollisionWorld::ContactResultCallback& resultCallback) + : m_collisionObject(collisionObject), + m_world(world), + m_resultCallback(resultCallback) + { + } + + virtual bool process(const btBroadphaseProxy* proxy) + { + btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject; + if (collisionObject == m_collisionObject) + return true; + + //only perform raycast if filterMask matches + if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) + { + btCollisionObjectWrapper ob0(0, m_collisionObject->getCollisionShape(), m_collisionObject, m_collisionObject->getWorldTransform(), -1, -1); + btCollisionObjectWrapper ob1(0, collisionObject->getCollisionShape(), collisionObject, collisionObject->getWorldTransform(), -1, -1); + + btCollisionAlgorithm* algorithm = m_world->getDispatcher()->findAlgorithm(&ob0, &ob1, 0, BT_CLOSEST_POINT_ALGORITHMS); + if (algorithm) + { + btBridgedManifoldResult contactPointResult(&ob0, &ob1, m_resultCallback); + //discrete collision detection query + + algorithm->processCollision(&ob0, &ob1, m_world->getDispatchInfo(), &contactPointResult); + + algorithm->~btCollisionAlgorithm(); + m_world->getDispatcher()->freeCollisionAlgorithm(algorithm); + } + } + return true; + } +}; + +///contactTest performs a discrete collision test against all objects in the btCollisionWorld, and calls the resultCallback. +///it reports one or more contact points for every overlapping object (including the one with deepest penetration) +void btCollisionWorld::contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback) +{ + btVector3 aabbMin, aabbMax; + colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), aabbMin, aabbMax); + btSingleContactCallback contactCB(colObj, this, resultCallback); + + m_broadphasePairCache->aabbTest(aabbMin, aabbMax, contactCB); +} + +///contactTest performs a discrete collision test between two collision objects and calls the resultCallback if overlap if detected. +///it reports one or more contact points (including the one with deepest penetration) +void btCollisionWorld::contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback) +{ + btCollisionObjectWrapper obA(0, colObjA->getCollisionShape(), colObjA, colObjA->getWorldTransform(), -1, -1); + btCollisionObjectWrapper obB(0, colObjB->getCollisionShape(), colObjB, colObjB->getWorldTransform(), -1, -1); + + btCollisionAlgorithm* algorithm = getDispatcher()->findAlgorithm(&obA, &obB, 0, BT_CLOSEST_POINT_ALGORITHMS); + if (algorithm) + { + btBridgedManifoldResult contactPointResult(&obA, &obB, resultCallback); + contactPointResult.m_closestPointDistanceThreshold = resultCallback.m_closestDistanceThreshold; + //discrete collision detection query + algorithm->processCollision(&obA, &obB, getDispatchInfo(), &contactPointResult); + + algorithm->~btCollisionAlgorithm(); + getDispatcher()->freeCollisionAlgorithm(algorithm); + } +} + +class DebugDrawcallback : public btTriangleCallback, public btInternalTriangleIndexCallback +{ + btIDebugDraw* m_debugDrawer; + btVector3 m_color; + btTransform m_worldTrans; + +public: + DebugDrawcallback(btIDebugDraw* debugDrawer, const btTransform& worldTrans, const btVector3& color) : m_debugDrawer(debugDrawer), + m_color(color), + m_worldTrans(worldTrans) + { + } + + virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex) + { + processTriangle(triangle, partId, triangleIndex); + } + + virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex) + { + (void)partId; + (void)triangleIndex; + + btVector3 wv0, wv1, wv2; + wv0 = m_worldTrans * triangle[0]; + wv1 = m_worldTrans * triangle[1]; + wv2 = m_worldTrans * triangle[2]; + btVector3 center = (wv0 + wv1 + wv2) * btScalar(1. / 3.); + + if (m_debugDrawer->getDebugMode() & btIDebugDraw::DBG_DrawNormals) + { + btVector3 normal = (wv1 - wv0).cross(wv2 - wv0); + normal.normalize(); + btVector3 normalColor(1, 1, 0); + m_debugDrawer->drawLine(center, center + normal, normalColor); + } + m_debugDrawer->drawTriangle(wv0, wv1, wv2, m_color, 1.0); + } +}; + +void btCollisionWorld::debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color) +{ + // Draw a small simplex at the center of the object + if (getDebugDrawer() && getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawFrames) + { + getDebugDrawer()->drawTransform(worldTransform, .1); + } + + if (shape->getShapeType() == COMPOUND_SHAPE_PROXYTYPE) + { + const btCompoundShape* compoundShape = static_cast(shape); + for (int i = compoundShape->getNumChildShapes() - 1; i >= 0; i--) + { + btTransform childTrans = compoundShape->getChildTransform(i); + const btCollisionShape* colShape = compoundShape->getChildShape(i); + debugDrawObject(worldTransform * childTrans, colShape, color); + } + } + else + { + switch (shape->getShapeType()) + { + case BOX_SHAPE_PROXYTYPE: + { + const btBoxShape* boxShape = static_cast(shape); + btVector3 halfExtents = boxShape->getHalfExtentsWithMargin(); + getDebugDrawer()->drawBox(-halfExtents, halfExtents, worldTransform, color); + break; + } + + case SPHERE_SHAPE_PROXYTYPE: + { + const btSphereShape* sphereShape = static_cast(shape); + btScalar radius = sphereShape->getMargin(); //radius doesn't include the margin, so draw with margin + + getDebugDrawer()->drawSphere(radius, worldTransform, color); + break; + } + case MULTI_SPHERE_SHAPE_PROXYTYPE: + { + const btMultiSphereShape* multiSphereShape = static_cast(shape); + + btTransform childTransform; + childTransform.setIdentity(); + + for (int i = multiSphereShape->getSphereCount() - 1; i >= 0; i--) + { + childTransform.setOrigin(multiSphereShape->getSpherePosition(i)); + getDebugDrawer()->drawSphere(multiSphereShape->getSphereRadius(i), worldTransform * childTransform, color); + } + + break; + } + case CAPSULE_SHAPE_PROXYTYPE: + { + const btCapsuleShape* capsuleShape = static_cast(shape); + + btScalar radius = capsuleShape->getRadius(); + btScalar halfHeight = capsuleShape->getHalfHeight(); + + int upAxis = capsuleShape->getUpAxis(); + getDebugDrawer()->drawCapsule(radius, halfHeight, upAxis, worldTransform, color); + break; + } + case CONE_SHAPE_PROXYTYPE: + { + const btConeShape* coneShape = static_cast(shape); + btScalar radius = coneShape->getRadius(); //+coneShape->getMargin(); + btScalar height = coneShape->getHeight(); //+coneShape->getMargin(); + + int upAxis = coneShape->getConeUpIndex(); + getDebugDrawer()->drawCone(radius, height, upAxis, worldTransform, color); + break; + } + case CYLINDER_SHAPE_PROXYTYPE: + { + const btCylinderShape* cylinder = static_cast(shape); + int upAxis = cylinder->getUpAxis(); + btScalar radius = cylinder->getRadius(); + btScalar halfHeight = cylinder->getHalfExtentsWithMargin()[upAxis]; + getDebugDrawer()->drawCylinder(radius, halfHeight, upAxis, worldTransform, color); + break; + } + + case STATIC_PLANE_PROXYTYPE: + { + const btStaticPlaneShape* staticPlaneShape = static_cast(shape); + btScalar planeConst = staticPlaneShape->getPlaneConstant(); + const btVector3& planeNormal = staticPlaneShape->getPlaneNormal(); + getDebugDrawer()->drawPlane(planeNormal, planeConst, worldTransform, color); + break; + } + default: + { + /// for polyhedral shapes + if (shape->isPolyhedral()) + { + btPolyhedralConvexShape* polyshape = (btPolyhedralConvexShape*)shape; + + int i; + if (polyshape->getConvexPolyhedron()) + { + const btConvexPolyhedron* poly = polyshape->getConvexPolyhedron(); + for (i = 0; i < poly->m_faces.size(); i++) + { + btVector3 centroid(0, 0, 0); + int numVerts = poly->m_faces[i].m_indices.size(); + if (numVerts) + { + int lastV = poly->m_faces[i].m_indices[numVerts - 1]; + for (int v = 0; v < poly->m_faces[i].m_indices.size(); v++) + { + int curVert = poly->m_faces[i].m_indices[v]; + centroid += poly->m_vertices[curVert]; + getDebugDrawer()->drawLine(worldTransform * poly->m_vertices[lastV], worldTransform * poly->m_vertices[curVert], color); + lastV = curVert; + } + } + centroid *= btScalar(1.f) / btScalar(numVerts); + if (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawNormals) + { + btVector3 normalColor(1, 1, 0); + btVector3 faceNormal(poly->m_faces[i].m_plane[0], poly->m_faces[i].m_plane[1], poly->m_faces[i].m_plane[2]); + getDebugDrawer()->drawLine(worldTransform * centroid, worldTransform * (centroid + faceNormal), normalColor); + } + } + } + else + { + for (i = 0; i < polyshape->getNumEdges(); i++) + { + btVector3 a, b; + polyshape->getEdge(i, a, b); + btVector3 wa = worldTransform * a; + btVector3 wb = worldTransform * b; + getDebugDrawer()->drawLine(wa, wb, color); + } + } + } + + if (shape->isConcave()) + { + btConcaveShape* concaveMesh = (btConcaveShape*)shape; + + ///@todo pass camera, for some culling? no -> we are not a graphics lib + btVector3 aabbMax(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + btVector3 aabbMin(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + + DebugDrawcallback drawCallback(getDebugDrawer(), worldTransform, color); + concaveMesh->processAllTriangles(&drawCallback, aabbMin, aabbMax); + } + + if (shape->getShapeType() == CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE) + { + btConvexTriangleMeshShape* convexMesh = (btConvexTriangleMeshShape*)shape; + //todo: pass camera for some culling + btVector3 aabbMax(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + btVector3 aabbMin(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + //DebugDrawcallback drawCallback; + DebugDrawcallback drawCallback(getDebugDrawer(), worldTransform, color); + convexMesh->getMeshInterface()->InternalProcessAllTriangles(&drawCallback, aabbMin, aabbMax); + } + } + } + } +} + +void btCollisionWorld::debugDrawWorld() +{ + // printf("btCollisionWorld::debugDrawWorld\n"); + // printf("m_debugDrawer = %p\n", m_debugDrawer); + // printf("getDebugDrawer() = %p\n", getDebugDrawer()); + + if (getDebugDrawer()) + { + // printf("m_debugDrawer->getDebugMode() = %d\n", m_debugDrawer->getDebugMode()); + + getDebugDrawer()->clearLines(); + + // printf("m_debugDrawer->clearLines();\n"); + + btIDebugDraw::DefaultColors defaultColors = getDebugDrawer()->getDefaultColors(); + + // printf("defaultColors\n"); + + if (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawContactPoints) + { + if (getDispatcher()) + { + int numManifolds = getDispatcher()->getNumManifolds(); + + for (int i = 0; i < numManifolds; i++) + { + btPersistentManifold* contactManifold = getDispatcher()->getManifoldByIndexInternal(i); + //btCollisionObject* obA = static_cast(contactManifold->getBody0()); + //btCollisionObject* obB = static_cast(contactManifold->getBody1()); + + int numContacts = contactManifold->getNumContacts(); + for (int j = 0; j < numContacts; j++) + { + // printf("drawContactPoint[%d]\n", j); + btManifoldPoint& cp = contactManifold->getContactPoint(j); + getDebugDrawer()->drawContactPoint(cp.m_positionWorldOnB, cp.m_normalWorldOnB, cp.getDistance(), cp.getLifeTime(), defaultColors.m_contactPoint); + } + } + } + } + + if ((getDebugDrawer()->getDebugMode() & (btIDebugDraw::DBG_DrawWireframe | btIDebugDraw::DBG_DrawAabb))) + { + int i; + + for (i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + if ((colObj->getCollisionFlags() & btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT) == 0) + { + if (getDebugDrawer() && (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawWireframe)) + { + btVector3 color(btScalar(0.4), btScalar(0.4), btScalar(0.4)); + + // printf("color_start: %f, %f, %f\n", color.getX(), color.getY(), color.getZ()); + + switch (colObj->getActivationState()) + { + case ACTIVE_TAG: + color = defaultColors.m_activeObject; + // printf("color_ACTIVE: %f, %f, %f\n", color.getX(), color.getY(), color.getZ()); + break; + case ISLAND_SLEEPING: + color = defaultColors.m_deactivatedObject; + // printf("color_SLEEPING: %f, %f, %f\n", color.getX(), color.getY(), color.getZ()); + break; + case WANTS_DEACTIVATION: + color = defaultColors.m_wantsDeactivationObject; + // printf("color_WANTS_DEACTIVATION: %f, %f, %f\n", color.getX(), color.getY(), color.getZ()); + break; + case DISABLE_DEACTIVATION: + color = defaultColors.m_disabledDeactivationObject; + // printf("color_DISABLE_DEACTIVATION: %f, %f, %f\n", color.getX(), color.getY(), color.getZ()); + break; + case DISABLE_SIMULATION: + color = defaultColors.m_disabledSimulationObject; + // printf("color_DISABLE_SIMULATION: %f, %f, %f\n", color.getX(), color.getY(), color.getZ()); + break; + default: + { + color = btVector3(btScalar(.3), btScalar(0.3), btScalar(0.3)); + // printf("color_Default: %f, %f, %f\n", color.getX(), color.getY(), color.getZ()); + } + }; + + colObj->getCustomDebugColor(color); + + // printf("color_final: %f, %f, %f\n", color.getX(), color.getY(), color.getZ()); + + debugDrawObject(colObj->getWorldTransform(), colObj->getCollisionShape(), color); + } + if (m_debugDrawer && (m_debugDrawer->getDebugMode() & btIDebugDraw::DBG_DrawAabb)) + { + btVector3 minAabb, maxAabb; + btVector3 colorvec = defaultColors.m_aabb; + colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb, maxAabb); + btVector3 contactThreshold(gContactBreakingThreshold, gContactBreakingThreshold, gContactBreakingThreshold); + minAabb -= contactThreshold; + maxAabb += contactThreshold; + + btVector3 minAabb2, maxAabb2; + + if (getDispatchInfo().m_useContinuous && colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY && !colObj->isStaticOrKinematicObject()) + { + colObj->getCollisionShape()->getAabb(colObj->getInterpolationWorldTransform(), minAabb2, maxAabb2); + minAabb2 -= contactThreshold; + maxAabb2 += contactThreshold; + minAabb.setMin(minAabb2); + maxAabb.setMax(maxAabb2); + } + + m_debugDrawer->drawAabb(minAabb, maxAabb, colorvec); + } + } + } + } + } +} + +void btCollisionWorld::serializeCollisionObjects(btSerializer* serializer) +{ + int i; + + ///keep track of shapes already serialized + btHashMap serializedShapes; + + for (i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + btCollisionShape* shape = colObj->getCollisionShape(); + + if (!serializedShapes.find(shape)) + { + serializedShapes.insert(shape, shape); + shape->serializeSingleShape(serializer); + } + } + + //serialize all collision objects + for (i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + if (colObj->getInternalType() == btCollisionObject::CO_COLLISION_OBJECT) + { + colObj->serializeSingleObject(serializer); + } + } +} + +void btCollisionWorld::serializeContactManifolds(btSerializer* serializer) +{ + if (serializer->getSerializationFlags() & BT_SERIALIZE_CONTACT_MANIFOLDS) + { + int numManifolds = getDispatcher()->getNumManifolds(); + for (int i = 0; i < numManifolds; i++) + { + const btPersistentManifold* manifold = getDispatcher()->getInternalManifoldPointer()[i]; + //don't serialize empty manifolds, they just take space + //(may have to do it anyway if it destroys determinism) + if (manifold->getNumContacts() == 0) + continue; + + btChunk* chunk = serializer->allocate(manifold->calculateSerializeBufferSize(), 1); + const char* structType = manifold->serialize(manifold, chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_CONTACTMANIFOLD_CODE, (void*)manifold); + } + } +} + +void btCollisionWorld::serialize(btSerializer* serializer) +{ + serializer->startSerialization(); + + serializeCollisionObjects(serializer); + + serializeContactManifolds(serializer); + + serializer->finishSerialization(); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.cpp.i new file mode 100644 index 00000000..5f442af4 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionWorld.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionWorld.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionWorld.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.h new file mode 100644 index 00000000..fd0e5b9b --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.h @@ -0,0 +1,513 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/** + * @mainpage Bullet Documentation + * + * @section intro_sec Introduction + * Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license ( http://opensource.org/licenses/zlib-license.php ). + * + * The main documentation is Bullet_User_Manual.pdf, included in the source code distribution. + * There is the Physics Forum for feedback and general Collision Detection and Physics discussions. + * Please visit http://www.bulletphysics.org + * + * @section install_sec Installation + * + * @subsection step1 Step 1: Download + * You can download the Bullet Physics Library from the github repository: https://github.com/bulletphysics/bullet3/releases + * + * @subsection step2 Step 2: Building + * Bullet has multiple build systems, including premake, cmake and autotools. Premake and cmake support all platforms. + * Premake is included in the Bullet/build folder for Windows, Mac OSX and Linux. + * Under Windows you can click on Bullet/build/vs2010.bat to create Microsoft Visual Studio projects. + * On Mac OSX and Linux you can open a terminal and generate Makefile, codeblocks or Xcode4 projects: + * cd Bullet/build + * ./premake4_osx gmake or ./premake4_linux gmake or ./premake4_linux64 gmake or (for Mac) ./premake4_osx xcode4 + * cd Bullet/build/gmake + * make + * + * An alternative to premake is cmake. You can download cmake from http://www.cmake.org + * cmake can autogenerate projectfiles for Microsoft Visual Studio, Apple Xcode, KDevelop and Unix Makefiles. + * The easiest is to run the CMake cmake-gui graphical user interface and choose the options and generate projectfiles. + * You can also use cmake in the command-line. Here are some examples for various platforms: + * cmake . -G "Visual Studio 9 2008" + * cmake . -G Xcode + * cmake . -G "Unix Makefiles" + * Although cmake is recommended, you can also use autotools for UNIX: ./autogen.sh ./configure to create a Makefile and then run make. + * + * @subsection step3 Step 3: Testing demos + * Try to run and experiment with BasicDemo executable as a starting point. + * Bullet can be used in several ways, as Full Rigid Body simulation, as Collision Detector Library or Low Level / Snippets like the GJK Closest Point calculation. + * The Dependencies can be seen in this documentation under Directories + * + * @subsection step4 Step 4: Integrating in your application, full Rigid Body and Soft Body simulation + * Check out BasicDemo how to create a btDynamicsWorld, btRigidBody and btCollisionShape, Stepping the simulation and synchronizing your graphics object transform. + * Check out SoftDemo how to use soft body dynamics, using btSoftRigidDynamicsWorld. + * @subsection step5 Step 5 : Integrate the Collision Detection Library (without Dynamics and other Extras) + * Bullet Collision Detection can also be used without the Dynamics/Extras. + * Check out btCollisionWorld and btCollisionObject, and the CollisionInterfaceDemo. + * @subsection step6 Step 6 : Use Snippets like the GJK Closest Point calculation. + * Bullet has been designed in a modular way keeping dependencies to a minimum. The ConvexHullDistance demo demonstrates direct use of btGjkPairDetector. + * + * @section copyright Copyright + * For up-to-data information and copyright and contributors list check out the Bullet_User_Manual.pdf + * + */ + +#ifndef BT_COLLISION_WORLD_H +#define BT_COLLISION_WORLD_H + +class btCollisionShape; +class btConvexShape; +class btBroadphaseInterface; +class btSerializer; + +#include "LinearMath/btVector3.h" +#include "LinearMath/btTransform.h" +#include "btCollisionObject.h" +#include "btCollisionDispatcher.h" +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" +#include "LinearMath/btAlignedObjectArray.h" + +///CollisionWorld is interface and container for the collision detection +class btCollisionWorld +{ +protected: + btAlignedObjectArray m_collisionObjects; + + btDispatcher* m_dispatcher1; + + btDispatcherInfo m_dispatchInfo; + + btBroadphaseInterface* m_broadphasePairCache; + + btIDebugDraw* m_debugDrawer; + + ///m_forceUpdateAllAabbs can be set to false as an optimization to only update active object AABBs + ///it is true by default, because it is error-prone (setting the position of static objects wouldn't update their AABB) + bool m_forceUpdateAllAabbs; + + void serializeCollisionObjects(btSerializer* serializer); + + void serializeContactManifolds(btSerializer* serializer); + +public: + //this constructor doesn't own the dispatcher and paircache/broadphase + btCollisionWorld(btDispatcher* dispatcher, btBroadphaseInterface* broadphasePairCache, btCollisionConfiguration* collisionConfiguration); + + virtual ~btCollisionWorld(); + + void setBroadphase(btBroadphaseInterface* pairCache) + { + m_broadphasePairCache = pairCache; + } + + const btBroadphaseInterface* getBroadphase() const + { + return m_broadphasePairCache; + } + + btBroadphaseInterface* getBroadphase() + { + return m_broadphasePairCache; + } + + btOverlappingPairCache* getPairCache() + { + return m_broadphasePairCache->getOverlappingPairCache(); + } + + btDispatcher* getDispatcher() + { + return m_dispatcher1; + } + + const btDispatcher* getDispatcher() const + { + return m_dispatcher1; + } + + void updateSingleAabb(btCollisionObject* colObj); + + virtual void updateAabbs(); + + ///the computeOverlappingPairs is usually already called by performDiscreteCollisionDetection (or stepSimulation) + ///it can be useful to use if you perform ray tests without collision detection/simulation + virtual void computeOverlappingPairs(); + + virtual void setDebugDrawer(btIDebugDraw* debugDrawer) + { + m_debugDrawer = debugDrawer; + } + + virtual btIDebugDraw* getDebugDrawer() + { + return m_debugDrawer; + } + + virtual void debugDrawWorld(); + + virtual void debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color); + + ///LocalShapeInfo gives extra information for complex shapes + ///Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart + struct LocalShapeInfo + { + int m_shapePart; + int m_triangleIndex; + + //const btCollisionShape* m_shapeTemp; + //const btTransform* m_shapeLocalTransform; + }; + + struct LocalRayResult + { + LocalRayResult(const btCollisionObject* collisionObject, + LocalShapeInfo* localShapeInfo, + const btVector3& hitNormalLocal, + btScalar hitFraction) + : m_collisionObject(collisionObject), + m_localShapeInfo(localShapeInfo), + m_hitNormalLocal(hitNormalLocal), + m_hitFraction(hitFraction) + { + } + + const btCollisionObject* m_collisionObject; + LocalShapeInfo* m_localShapeInfo; + btVector3 m_hitNormalLocal; + btScalar m_hitFraction; + }; + + ///RayResultCallback is used to report new raycast results + struct RayResultCallback + { + btScalar m_closestHitFraction; + const btCollisionObject* m_collisionObject; + int m_collisionFilterGroup; + int m_collisionFilterMask; + //@BP Mod - Custom flags, currently used to enable backface culling on tri-meshes, see btRaycastCallback.h. Apply any of the EFlags defined there on m_flags here to invoke. + unsigned int m_flags; + + virtual ~RayResultCallback() + { + } + bool hasHit() const + { + return (m_collisionObject != 0); + } + + RayResultCallback() + : m_closestHitFraction(btScalar(1.)), + m_collisionObject(0), + m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter), + m_collisionFilterMask(btBroadphaseProxy::AllFilter), + //@BP Mod + m_flags(0) + { + } + + virtual bool needsCollision(btBroadphaseProxy* proxy0) const + { + bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0; + collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask); + return collides; + } + + virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace) = 0; + }; + + struct ClosestRayResultCallback : public RayResultCallback + { + ClosestRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld) + : m_rayFromWorld(rayFromWorld), + m_rayToWorld(rayToWorld) + { + } + + btVector3 m_rayFromWorld; //used to calculate hitPointWorld from hitFraction + btVector3 m_rayToWorld; + + btVector3 m_hitNormalWorld; + btVector3 m_hitPointWorld; + + virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace) + { + //caller already does the filter on the m_closestHitFraction + btAssert(rayResult.m_hitFraction <= m_closestHitFraction); + + m_closestHitFraction = rayResult.m_hitFraction; + m_collisionObject = rayResult.m_collisionObject; + if (normalInWorldSpace) + { + m_hitNormalWorld = rayResult.m_hitNormalLocal; + } + else + { + ///need to transform normal into worldspace + m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis() * rayResult.m_hitNormalLocal; + } + m_hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction); + return rayResult.m_hitFraction; + } + }; + + struct AllHitsRayResultCallback : public RayResultCallback + { + AllHitsRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld) + : m_rayFromWorld(rayFromWorld), + m_rayToWorld(rayToWorld) + { + } + + btAlignedObjectArray m_collisionObjects; + + btVector3 m_rayFromWorld; //used to calculate hitPointWorld from hitFraction + btVector3 m_rayToWorld; + + btAlignedObjectArray m_hitNormalWorld; + btAlignedObjectArray m_hitPointWorld; + btAlignedObjectArray m_hitFractions; + + virtual btScalar addSingleResult(LocalRayResult& rayResult, bool normalInWorldSpace) + { + m_collisionObject = rayResult.m_collisionObject; + m_collisionObjects.push_back(rayResult.m_collisionObject); + btVector3 hitNormalWorld; + if (normalInWorldSpace) + { + hitNormalWorld = rayResult.m_hitNormalLocal; + } + else + { + ///need to transform normal into worldspace + hitNormalWorld = m_collisionObject->getWorldTransform().getBasis() * rayResult.m_hitNormalLocal; + } + m_hitNormalWorld.push_back(hitNormalWorld); + btVector3 hitPointWorld; + hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction); + m_hitPointWorld.push_back(hitPointWorld); + m_hitFractions.push_back(rayResult.m_hitFraction); + return m_closestHitFraction; + } + }; + + struct LocalConvexResult + { + LocalConvexResult(const btCollisionObject* hitCollisionObject, + LocalShapeInfo* localShapeInfo, + const btVector3& hitNormalLocal, + const btVector3& hitPointLocal, + btScalar hitFraction) + : m_hitCollisionObject(hitCollisionObject), + m_localShapeInfo(localShapeInfo), + m_hitNormalLocal(hitNormalLocal), + m_hitPointLocal(hitPointLocal), + m_hitFraction(hitFraction) + { + } + + const btCollisionObject* m_hitCollisionObject; + LocalShapeInfo* m_localShapeInfo; + btVector3 m_hitNormalLocal; + btVector3 m_hitPointLocal; + btScalar m_hitFraction; + }; + + ///RayResultCallback is used to report new raycast results + struct ConvexResultCallback + { + btScalar m_closestHitFraction; + int m_collisionFilterGroup; + int m_collisionFilterMask; + + ConvexResultCallback() + : m_closestHitFraction(btScalar(1.)), + m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter), + m_collisionFilterMask(btBroadphaseProxy::AllFilter) + { + } + + virtual ~ConvexResultCallback() + { + } + + bool hasHit() const + { + return (m_closestHitFraction < btScalar(1.)); + } + + virtual bool needsCollision(btBroadphaseProxy* proxy0) const + { + bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0; + collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask); + return collides; + } + + virtual btScalar addSingleResult(LocalConvexResult& convexResult, bool normalInWorldSpace) = 0; + }; + + struct ClosestConvexResultCallback : public ConvexResultCallback + { + ClosestConvexResultCallback(const btVector3& convexFromWorld, const btVector3& convexToWorld) + : m_convexFromWorld(convexFromWorld), + m_convexToWorld(convexToWorld), + m_hitCollisionObject(0) + { + } + + btVector3 m_convexFromWorld; //used to calculate hitPointWorld from hitFraction + btVector3 m_convexToWorld; + + btVector3 m_hitNormalWorld; + btVector3 m_hitPointWorld; + const btCollisionObject* m_hitCollisionObject; + + virtual btScalar addSingleResult(LocalConvexResult& convexResult, bool normalInWorldSpace) + { + //caller already does the filter on the m_closestHitFraction + btAssert(convexResult.m_hitFraction <= m_closestHitFraction); + + m_closestHitFraction = convexResult.m_hitFraction; + m_hitCollisionObject = convexResult.m_hitCollisionObject; + if (normalInWorldSpace) + { + m_hitNormalWorld = convexResult.m_hitNormalLocal; + } + else + { + ///need to transform normal into worldspace + m_hitNormalWorld = m_hitCollisionObject->getWorldTransform().getBasis() * convexResult.m_hitNormalLocal; + } + m_hitPointWorld = convexResult.m_hitPointLocal; + return convexResult.m_hitFraction; + } + }; + + ///ContactResultCallback is used to report contact points + struct ContactResultCallback + { + int m_collisionFilterGroup; + int m_collisionFilterMask; + btScalar m_closestDistanceThreshold; + + ContactResultCallback() + : m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter), + m_collisionFilterMask(btBroadphaseProxy::AllFilter), + m_closestDistanceThreshold(0) + { + } + + virtual ~ContactResultCallback() + { + } + + virtual bool needsCollision(btBroadphaseProxy* proxy0) const + { + bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0; + collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask); + return collides; + } + + virtual btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper* colObj1Wrap, int partId1, int index1) = 0; + }; + + int getNumCollisionObjects() const + { + return int(m_collisionObjects.size()); + } + + /// rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback + /// This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback. + virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const; + + /// convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultCallback + /// This allows for several queries: first hit, all hits, any hit, dependent on the value return by the callback. + void convexSweepTest(const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration = btScalar(0.)) const; + + ///contactTest performs a discrete collision test between colObj against all objects in the btCollisionWorld, and calls the resultCallback. + ///it reports one or more contact points for every overlapping object (including the one with deepest penetration) + void contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback); + + ///contactTest performs a discrete collision test between two collision objects and calls the resultCallback if overlap if detected. + ///it reports one or more contact points (including the one with deepest penetration) + void contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback); + + /// 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); + + static void rayTestSingleInternal(const btTransform& rayFromTrans, const btTransform& rayToTrans, + const btCollisionObjectWrapper* collisionObjectWrap, + RayResultCallback& resultCallback); + + /// objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest. + static void objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans, const btTransform& rayToTrans, + btCollisionObject* collisionObject, + const btCollisionShape* collisionShape, + const btTransform& colObjWorldTransform, + ConvexResultCallback& resultCallback, btScalar allowedPenetration); + + static void objectQuerySingleInternal(const btConvexShape* castShape, const btTransform& convexFromTrans, const btTransform& convexToTrans, + const btCollisionObjectWrapper* colObjWrap, + ConvexResultCallback& resultCallback, btScalar allowedPenetration); + + virtual void addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup = btBroadphaseProxy::DefaultFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter); + + virtual void refreshBroadphaseProxy(btCollisionObject* collisionObject); + + btCollisionObjectArray& getCollisionObjectArray() + { + return m_collisionObjects; + } + + const btCollisionObjectArray& getCollisionObjectArray() const + { + return m_collisionObjects; + } + + virtual void removeCollisionObject(btCollisionObject* collisionObject); + + virtual void performDiscreteCollisionDetection(); + + btDispatcherInfo& getDispatchInfo() + { + return m_dispatchInfo; + } + + const btDispatcherInfo& getDispatchInfo() const + { + return m_dispatchInfo; + } + + bool getForceUpdateAllAabbs() const + { + return m_forceUpdateAllAabbs; + } + void setForceUpdateAllAabbs(bool forceUpdateAllAabbs) + { + m_forceUpdateAllAabbs = forceUpdateAllAabbs; + } + + ///Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bullet/Demos/SerializeDemo) + virtual void serialize(btSerializer* serializer); +}; + +#endif //BT_COLLISION_WORLD_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.h.i new file mode 100644 index 00000000..022d2295 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorld.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionWorld.h ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionWorld.h" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionWorld.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp new file mode 100644 index 00000000..e56e73dc --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp @@ -0,0 +1,1087 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2014 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btCollisionWorldImporter.h" +#include "btBulletCollisionCommon.h" +#include "LinearMath/btSerializer.h" //for btBulletSerializedArrays definition + +#ifdef SUPPORT_GIMPACT_SHAPE_IMPORT +#include "BulletCollision/Gimpact/btGImpactShape.h" +#endif //SUPPORT_GIMPACT_SHAPE_IMPORT + +btCollisionWorldImporter::btCollisionWorldImporter(btCollisionWorld* world) + : m_collisionWorld(world), + m_verboseMode(0) +{ +} + +btCollisionWorldImporter::~btCollisionWorldImporter() +{ +} + +bool btCollisionWorldImporter::convertAllObjects(btBulletSerializedArrays* arrays) +{ + m_shapeMap.clear(); + m_bodyMap.clear(); + + int i; + + for (i = 0; i < arrays->m_bvhsDouble.size(); i++) + { + btOptimizedBvh* bvh = createOptimizedBvh(); + btQuantizedBvhDoubleData* bvhData = arrays->m_bvhsDouble[i]; + bvh->deSerializeDouble(*bvhData); + m_bvhMap.insert(arrays->m_bvhsDouble[i], bvh); + } + for (i = 0; i < arrays->m_bvhsFloat.size(); i++) + { + btOptimizedBvh* bvh = createOptimizedBvh(); + btQuantizedBvhFloatData* bvhData = arrays->m_bvhsFloat[i]; + bvh->deSerializeFloat(*bvhData); + m_bvhMap.insert(arrays->m_bvhsFloat[i], bvh); + } + + for (i = 0; i < arrays->m_colShapeData.size(); i++) + { + btCollisionShapeData* shapeData = arrays->m_colShapeData[i]; + btCollisionShape* shape = convertCollisionShape(shapeData); + if (shape) + { + // printf("shapeMap.insert(%x,%x)\n",shapeData,shape); + m_shapeMap.insert(shapeData, shape); + } + + if (shape && shapeData->m_name) + { + char* newname = duplicateName(shapeData->m_name); + m_objectNameMap.insert(shape, newname); + m_nameShapeMap.insert(newname, shape); + } + } + + for (i = 0; i < arrays->m_collisionObjectDataDouble.size(); i++) + { + btCollisionObjectDoubleData* colObjData = arrays->m_collisionObjectDataDouble[i]; + btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionShape); + if (shapePtr && *shapePtr) + { + btTransform startTransform; + colObjData->m_worldTransform.m_origin.m_floats[3] = 0.f; + startTransform.deSerializeDouble(colObjData->m_worldTransform); + + btCollisionShape* shape = (btCollisionShape*)*shapePtr; + btCollisionObject* body = createCollisionObject(startTransform, shape, colObjData->m_name); + body->setFriction(btScalar(colObjData->m_friction)); + body->setRestitution(btScalar(colObjData->m_restitution)); + +#ifdef USE_INTERNAL_EDGE_UTILITY + if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE) + { + btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape; + if (trimesh->getTriangleInfoMap()) + { + body->setCollisionFlags(body->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK); + } + } +#endif //USE_INTERNAL_EDGE_UTILITY + m_bodyMap.insert(colObjData, body); + } + else + { + printf("error: no shape found\n"); + } + } + for (i = 0; i < arrays->m_collisionObjectDataFloat.size(); i++) + { + btCollisionObjectFloatData* colObjData = arrays->m_collisionObjectDataFloat[i]; + btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionShape); + if (shapePtr && *shapePtr) + { + btTransform startTransform; + colObjData->m_worldTransform.m_origin.m_floats[3] = 0.f; + startTransform.deSerializeFloat(colObjData->m_worldTransform); + + btCollisionShape* shape = (btCollisionShape*)*shapePtr; + btCollisionObject* body = createCollisionObject(startTransform, shape, colObjData->m_name); + +#ifdef USE_INTERNAL_EDGE_UTILITY + if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE) + { + btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape; + if (trimesh->getTriangleInfoMap()) + { + body->setCollisionFlags(body->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK); + } + } +#endif //USE_INTERNAL_EDGE_UTILITY + m_bodyMap.insert(colObjData, body); + } + else + { + printf("error: no shape found\n"); + } + } + + return true; +} + +void btCollisionWorldImporter::deleteAllData() +{ + int i; + + for (i = 0; i < m_allocatedCollisionObjects.size(); i++) + { + if (m_collisionWorld) + m_collisionWorld->removeCollisionObject(m_allocatedCollisionObjects[i]); + delete m_allocatedCollisionObjects[i]; + } + + m_allocatedCollisionObjects.clear(); + + for (i = 0; i < m_allocatedCollisionShapes.size(); i++) + { + delete m_allocatedCollisionShapes[i]; + } + m_allocatedCollisionShapes.clear(); + + for (i = 0; i < m_allocatedBvhs.size(); i++) + { + delete m_allocatedBvhs[i]; + } + m_allocatedBvhs.clear(); + + for (i = 0; i < m_allocatedTriangleInfoMaps.size(); i++) + { + delete m_allocatedTriangleInfoMaps[i]; + } + m_allocatedTriangleInfoMaps.clear(); + for (i = 0; i < m_allocatedTriangleIndexArrays.size(); i++) + { + delete m_allocatedTriangleIndexArrays[i]; + } + m_allocatedTriangleIndexArrays.clear(); + for (i = 0; i < m_allocatedNames.size(); i++) + { + delete[] m_allocatedNames[i]; + } + m_allocatedNames.clear(); + + for (i = 0; i < m_allocatedbtStridingMeshInterfaceDatas.size(); i++) + { + btStridingMeshInterfaceData* curData = m_allocatedbtStridingMeshInterfaceDatas[i]; + + for (int a = 0; a < curData->m_numMeshParts; a++) + { + btMeshPartData* curPart = &curData->m_meshPartsPtr[a]; + if (curPart->m_vertices3f) + delete[] curPart->m_vertices3f; + + if (curPart->m_vertices3d) + delete[] curPart->m_vertices3d; + + if (curPart->m_indices32) + delete[] curPart->m_indices32; + + if (curPart->m_3indices16) + delete[] curPart->m_3indices16; + + if (curPart->m_indices16) + delete[] curPart->m_indices16; + + if (curPart->m_3indices8) + delete[] curPart->m_3indices8; + } + delete[] curData->m_meshPartsPtr; + delete curData; + } + m_allocatedbtStridingMeshInterfaceDatas.clear(); + + for (i = 0; i < m_indexArrays.size(); i++) + { + btAlignedFree(m_indexArrays[i]); + } + m_indexArrays.clear(); + + for (i = 0; i < m_shortIndexArrays.size(); i++) + { + btAlignedFree(m_shortIndexArrays[i]); + } + m_shortIndexArrays.clear(); + + for (i = 0; i < m_charIndexArrays.size(); i++) + { + btAlignedFree(m_charIndexArrays[i]); + } + m_charIndexArrays.clear(); + + for (i = 0; i < m_floatVertexArrays.size(); i++) + { + btAlignedFree(m_floatVertexArrays[i]); + } + m_floatVertexArrays.clear(); + + for (i = 0; i < m_doubleVertexArrays.size(); i++) + { + btAlignedFree(m_doubleVertexArrays[i]); + } + m_doubleVertexArrays.clear(); +} + +btCollisionShape* btCollisionWorldImporter::convertCollisionShape(btCollisionShapeData* shapeData) +{ + btCollisionShape* shape = 0; + + switch (shapeData->m_shapeType) + { + case STATIC_PLANE_PROXYTYPE: + { + btStaticPlaneShapeData* planeData = (btStaticPlaneShapeData*)shapeData; + btVector3 planeNormal, localScaling; + planeNormal.deSerializeFloat(planeData->m_planeNormal); + localScaling.deSerializeFloat(planeData->m_localScaling); + shape = createPlaneShape(planeNormal, planeData->m_planeConstant); + shape->setLocalScaling(localScaling); + + break; + } + case SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE: + { + btScaledTriangleMeshShapeData* scaledMesh = (btScaledTriangleMeshShapeData*)shapeData; + btCollisionShapeData* colShapeData = (btCollisionShapeData*)&scaledMesh->m_trimeshShapeData; + colShapeData->m_shapeType = TRIANGLE_MESH_SHAPE_PROXYTYPE; + btCollisionShape* childShape = convertCollisionShape(colShapeData); + btBvhTriangleMeshShape* meshShape = (btBvhTriangleMeshShape*)childShape; + btVector3 localScaling; + localScaling.deSerializeFloat(scaledMesh->m_localScaling); + + shape = createScaledTrangleMeshShape(meshShape, localScaling); + break; + } +#ifdef SUPPORT_GIMPACT_SHAPE_IMPORT + case GIMPACT_SHAPE_PROXYTYPE: + { + btGImpactMeshShapeData* gimpactData = (btGImpactMeshShapeData*)shapeData; + if (gimpactData->m_gimpactSubType == CONST_GIMPACT_TRIMESH_SHAPE) + { + btStridingMeshInterfaceData* interfaceData = createStridingMeshInterfaceData(&gimpactData->m_meshInterface); + btTriangleIndexVertexArray* meshInterface = createMeshInterface(*interfaceData); + + btGImpactMeshShape* gimpactShape = createGimpactShape(meshInterface); + btVector3 localScaling; + localScaling.deSerializeFloat(gimpactData->m_localScaling); + gimpactShape->setLocalScaling(localScaling); + gimpactShape->setMargin(btScalar(gimpactData->m_collisionMargin)); + gimpactShape->updateBound(); + shape = gimpactShape; + } + else + { + printf("unsupported gimpact sub type\n"); + } + break; + } +#endif //SUPPORT_GIMPACT_SHAPE_IMPORT + //The btCapsuleShape* API has issue passing the margin/scaling/halfextents unmodified through the API + //so deal with this + case CAPSULE_SHAPE_PROXYTYPE: + { + btCapsuleShapeData* capData = (btCapsuleShapeData*)shapeData; + + switch (capData->m_upAxis) + { + case 0: + { + shape = createCapsuleShapeX(1, 1); + break; + } + case 1: + { + shape = createCapsuleShapeY(1, 1); + break; + } + case 2: + { + shape = createCapsuleShapeZ(1, 1); + break; + } + default: + { + printf("error: wrong up axis for btCapsuleShape\n"); + } + }; + if (shape) + { + btCapsuleShape* cap = (btCapsuleShape*)shape; + cap->deSerializeFloat(capData); + } + break; + } + case CYLINDER_SHAPE_PROXYTYPE: + case CONE_SHAPE_PROXYTYPE: + case BOX_SHAPE_PROXYTYPE: + case SPHERE_SHAPE_PROXYTYPE: + case MULTI_SPHERE_SHAPE_PROXYTYPE: + case CONVEX_HULL_SHAPE_PROXYTYPE: + { + btConvexInternalShapeData* bsd = (btConvexInternalShapeData*)shapeData; + btVector3 implicitShapeDimensions; + implicitShapeDimensions.deSerializeFloat(bsd->m_implicitShapeDimensions); + btVector3 localScaling; + localScaling.deSerializeFloat(bsd->m_localScaling); + btVector3 margin(bsd->m_collisionMargin, bsd->m_collisionMargin, bsd->m_collisionMargin); + switch (shapeData->m_shapeType) + { + case BOX_SHAPE_PROXYTYPE: + { + btBoxShape* box = (btBoxShape*)createBoxShape(implicitShapeDimensions / localScaling + margin); + //box->initializePolyhedralFeatures(); + shape = box; + + break; + } + case SPHERE_SHAPE_PROXYTYPE: + { + shape = createSphereShape(implicitShapeDimensions.getX()); + break; + } + + case CYLINDER_SHAPE_PROXYTYPE: + { + btCylinderShapeData* cylData = (btCylinderShapeData*)shapeData; + btVector3 halfExtents = implicitShapeDimensions + margin; + switch (cylData->m_upAxis) + { + case 0: + { + shape = createCylinderShapeX(halfExtents.getY(), halfExtents.getX()); + break; + } + case 1: + { + shape = createCylinderShapeY(halfExtents.getX(), halfExtents.getY()); + break; + } + case 2: + { + shape = createCylinderShapeZ(halfExtents.getX(), halfExtents.getZ()); + break; + } + default: + { + printf("unknown Cylinder up axis\n"); + } + }; + + break; + } + case CONE_SHAPE_PROXYTYPE: + { + btConeShapeData* conData = (btConeShapeData*)shapeData; + btVector3 halfExtents = implicitShapeDimensions; //+margin; + switch (conData->m_upIndex) + { + case 0: + { + shape = createConeShapeX(halfExtents.getY(), halfExtents.getX()); + break; + } + case 1: + { + shape = createConeShapeY(halfExtents.getX(), halfExtents.getY()); + break; + } + case 2: + { + shape = createConeShapeZ(halfExtents.getX(), halfExtents.getZ()); + break; + } + default: + { + printf("unknown Cone up axis\n"); + } + }; + + break; + } + case MULTI_SPHERE_SHAPE_PROXYTYPE: + { + btMultiSphereShapeData* mss = (btMultiSphereShapeData*)bsd; + int numSpheres = mss->m_localPositionArraySize; + + btAlignedObjectArray tmpPos; + btAlignedObjectArray radii; + radii.resize(numSpheres); + tmpPos.resize(numSpheres); + int i; + for (i = 0; i < numSpheres; i++) + { + tmpPos[i].deSerializeFloat(mss->m_localPositionArrayPtr[i].m_pos); + radii[i] = mss->m_localPositionArrayPtr[i].m_radius; + } + shape = createMultiSphereShape(&tmpPos[0], &radii[0], numSpheres); + break; + } + case CONVEX_HULL_SHAPE_PROXYTYPE: + { + // int sz = sizeof(btConvexHullShapeData); + // int sz2 = sizeof(btConvexInternalShapeData); + // int sz3 = sizeof(btCollisionShapeData); + btConvexHullShapeData* convexData = (btConvexHullShapeData*)bsd; + int numPoints = convexData->m_numUnscaledPoints; + + btAlignedObjectArray tmpPoints; + tmpPoints.resize(numPoints); + int i; + for (i = 0; i < numPoints; i++) + { +#ifdef BT_USE_DOUBLE_PRECISION + if (convexData->m_unscaledPointsDoublePtr) + tmpPoints[i].deSerialize(convexData->m_unscaledPointsDoublePtr[i]); + if (convexData->m_unscaledPointsFloatPtr) + tmpPoints[i].deSerializeFloat(convexData->m_unscaledPointsFloatPtr[i]); +#else + if (convexData->m_unscaledPointsFloatPtr) + tmpPoints[i].deSerialize(convexData->m_unscaledPointsFloatPtr[i]); + if (convexData->m_unscaledPointsDoublePtr) + tmpPoints[i].deSerializeDouble(convexData->m_unscaledPointsDoublePtr[i]); +#endif //BT_USE_DOUBLE_PRECISION + } + btConvexHullShape* hullShape = createConvexHullShape(); + for (i = 0; i < numPoints; i++) + { + hullShape->addPoint(tmpPoints[i]); + } + hullShape->setMargin(bsd->m_collisionMargin); + //hullShape->initializePolyhedralFeatures(); + shape = hullShape; + break; + } + default: + { + printf("error: cannot create shape type (%d)\n", shapeData->m_shapeType); + } + } + + if (shape) + { + shape->setMargin(bsd->m_collisionMargin); + + btVector3 localScaling; + localScaling.deSerializeFloat(bsd->m_localScaling); + shape->setLocalScaling(localScaling); + } + break; + } + case TRIANGLE_MESH_SHAPE_PROXYTYPE: + { + btTriangleMeshShapeData* trimesh = (btTriangleMeshShapeData*)shapeData; + btStridingMeshInterfaceData* interfaceData = createStridingMeshInterfaceData(&trimesh->m_meshInterface); + btTriangleIndexVertexArray* meshInterface = createMeshInterface(*interfaceData); + if (!meshInterface->getNumSubParts()) + { + return 0; + } + + btVector3 scaling; + scaling.deSerializeFloat(trimesh->m_meshInterface.m_scaling); + meshInterface->setScaling(scaling); + + btOptimizedBvh* bvh = 0; +#if 1 + if (trimesh->m_quantizedFloatBvh) + { + btOptimizedBvh** bvhPtr = m_bvhMap.find(trimesh->m_quantizedFloatBvh); + if (bvhPtr && *bvhPtr) + { + bvh = *bvhPtr; + } + else + { + bvh = createOptimizedBvh(); + bvh->deSerializeFloat(*trimesh->m_quantizedFloatBvh); + } + } + if (trimesh->m_quantizedDoubleBvh) + { + btOptimizedBvh** bvhPtr = m_bvhMap.find(trimesh->m_quantizedDoubleBvh); + if (bvhPtr && *bvhPtr) + { + bvh = *bvhPtr; + } + else + { + bvh = createOptimizedBvh(); + bvh->deSerializeDouble(*trimesh->m_quantizedDoubleBvh); + } + } +#endif + + btBvhTriangleMeshShape* trimeshShape = createBvhTriangleMeshShape(meshInterface, bvh); + trimeshShape->setMargin(trimesh->m_collisionMargin); + shape = trimeshShape; + + if (trimesh->m_triangleInfoMap) + { + btTriangleInfoMap* map = createTriangleInfoMap(); + map->deSerialize(*trimesh->m_triangleInfoMap); + trimeshShape->setTriangleInfoMap(map); + +#ifdef USE_INTERNAL_EDGE_UTILITY + gContactAddedCallback = btAdjustInternalEdgeContactsCallback; +#endif //USE_INTERNAL_EDGE_UTILITY + } + + //printf("trimesh->m_collisionMargin=%f\n",trimesh->m_collisionMargin); + break; + } + case COMPOUND_SHAPE_PROXYTYPE: + { + btCompoundShapeData* compoundData = (btCompoundShapeData*)shapeData; + btCompoundShape* compoundShape = createCompoundShape(); + + //btCompoundShapeChildData* childShapeDataArray = &compoundData->m_childShapePtr[0]; + + btAlignedObjectArray childShapes; + for (int i = 0; i < compoundData->m_numChildShapes; i++) + { + //btCompoundShapeChildData* ptr = &compoundData->m_childShapePtr[i]; + + btCollisionShapeData* cd = compoundData->m_childShapePtr[i].m_childShape; + + btCollisionShape* childShape = convertCollisionShape(cd); + if (childShape) + { + btTransform localTransform; + localTransform.deSerializeFloat(compoundData->m_childShapePtr[i].m_transform); + compoundShape->addChildShape(localTransform, childShape); + } + else + { +#ifdef _DEBUG + printf("error: couldn't create childShape for compoundShape\n"); +#endif + } + } + shape = compoundShape; + + break; + } + case SOFTBODY_SHAPE_PROXYTYPE: + { + return 0; + } + default: + { +#ifdef _DEBUG + printf("unsupported shape type (%d)\n", shapeData->m_shapeType); +#endif + } + } + + return shape; +} + +char* btCollisionWorldImporter::duplicateName(const char* name) +{ + if (name) + { + int l = (int)strlen(name); + char* newName = new char[l + 1]; + memcpy(newName, name, l); + newName[l] = 0; + m_allocatedNames.push_back(newName); + return newName; + } + return 0; +} + +btTriangleIndexVertexArray* btCollisionWorldImporter::createMeshInterface(btStridingMeshInterfaceData& meshData) +{ + btTriangleIndexVertexArray* meshInterface = createTriangleMeshContainer(); + + for (int i = 0; i < meshData.m_numMeshParts; i++) + { + btIndexedMesh meshPart; + meshPart.m_numTriangles = meshData.m_meshPartsPtr[i].m_numTriangles; + meshPart.m_numVertices = meshData.m_meshPartsPtr[i].m_numVertices; + + if (meshData.m_meshPartsPtr[i].m_indices32) + { + meshPart.m_indexType = PHY_INTEGER; + meshPart.m_triangleIndexStride = 3 * sizeof(int); + int* indexArray = (int*)btAlignedAlloc(sizeof(int) * 3 * meshPart.m_numTriangles, 16); + m_indexArrays.push_back(indexArray); + for (int j = 0; j < 3 * meshPart.m_numTriangles; j++) + { + indexArray[j] = meshData.m_meshPartsPtr[i].m_indices32[j].m_value; + } + meshPart.m_triangleIndexBase = (const unsigned char*)indexArray; + } + else + { + if (meshData.m_meshPartsPtr[i].m_3indices16) + { + meshPart.m_indexType = PHY_SHORT; + meshPart.m_triangleIndexStride = sizeof(short int) * 3; //sizeof(btShortIntIndexTripletData); + + short int* indexArray = (short int*)btAlignedAlloc(sizeof(short int) * 3 * meshPart.m_numTriangles, 16); + m_shortIndexArrays.push_back(indexArray); + + for (int j = 0; j < meshPart.m_numTriangles; j++) + { + indexArray[3 * j] = meshData.m_meshPartsPtr[i].m_3indices16[j].m_values[0]; + indexArray[3 * j + 1] = meshData.m_meshPartsPtr[i].m_3indices16[j].m_values[1]; + indexArray[3 * j + 2] = meshData.m_meshPartsPtr[i].m_3indices16[j].m_values[2]; + } + + meshPart.m_triangleIndexBase = (const unsigned char*)indexArray; + } + if (meshData.m_meshPartsPtr[i].m_indices16) + { + meshPart.m_indexType = PHY_SHORT; + meshPart.m_triangleIndexStride = 3 * sizeof(short int); + short int* indexArray = (short int*)btAlignedAlloc(sizeof(short int) * 3 * meshPart.m_numTriangles, 16); + m_shortIndexArrays.push_back(indexArray); + for (int j = 0; j < 3 * meshPart.m_numTriangles; j++) + { + indexArray[j] = meshData.m_meshPartsPtr[i].m_indices16[j].m_value; + } + + meshPart.m_triangleIndexBase = (const unsigned char*)indexArray; + } + + if (meshData.m_meshPartsPtr[i].m_3indices8) + { + meshPart.m_indexType = PHY_UCHAR; + meshPart.m_triangleIndexStride = sizeof(unsigned char) * 3; + + unsigned char* indexArray = (unsigned char*)btAlignedAlloc(sizeof(unsigned char) * 3 * meshPart.m_numTriangles, 16); + m_charIndexArrays.push_back(indexArray); + + for (int j = 0; j < meshPart.m_numTriangles; j++) + { + indexArray[3 * j] = meshData.m_meshPartsPtr[i].m_3indices8[j].m_values[0]; + indexArray[3 * j + 1] = meshData.m_meshPartsPtr[i].m_3indices8[j].m_values[1]; + indexArray[3 * j + 2] = meshData.m_meshPartsPtr[i].m_3indices8[j].m_values[2]; + } + + meshPart.m_triangleIndexBase = (const unsigned char*)indexArray; + } + } + + if (meshData.m_meshPartsPtr[i].m_vertices3f) + { + meshPart.m_vertexType = PHY_FLOAT; + meshPart.m_vertexStride = sizeof(btVector3FloatData); + btVector3FloatData* vertices = (btVector3FloatData*)btAlignedAlloc(sizeof(btVector3FloatData) * meshPart.m_numVertices, 16); + m_floatVertexArrays.push_back(vertices); + + for (int j = 0; j < meshPart.m_numVertices; j++) + { + vertices[j].m_floats[0] = meshData.m_meshPartsPtr[i].m_vertices3f[j].m_floats[0]; + vertices[j].m_floats[1] = meshData.m_meshPartsPtr[i].m_vertices3f[j].m_floats[1]; + vertices[j].m_floats[2] = meshData.m_meshPartsPtr[i].m_vertices3f[j].m_floats[2]; + vertices[j].m_floats[3] = meshData.m_meshPartsPtr[i].m_vertices3f[j].m_floats[3]; + } + meshPart.m_vertexBase = (const unsigned char*)vertices; + } + else + { + meshPart.m_vertexType = PHY_DOUBLE; + meshPart.m_vertexStride = sizeof(btVector3DoubleData); + + btVector3DoubleData* vertices = (btVector3DoubleData*)btAlignedAlloc(sizeof(btVector3DoubleData) * meshPart.m_numVertices, 16); + m_doubleVertexArrays.push_back(vertices); + + for (int j = 0; j < meshPart.m_numVertices; j++) + { + vertices[j].m_floats[0] = meshData.m_meshPartsPtr[i].m_vertices3d[j].m_floats[0]; + vertices[j].m_floats[1] = meshData.m_meshPartsPtr[i].m_vertices3d[j].m_floats[1]; + vertices[j].m_floats[2] = meshData.m_meshPartsPtr[i].m_vertices3d[j].m_floats[2]; + vertices[j].m_floats[3] = meshData.m_meshPartsPtr[i].m_vertices3d[j].m_floats[3]; + } + meshPart.m_vertexBase = (const unsigned char*)vertices; + } + + if (meshPart.m_triangleIndexBase && meshPart.m_vertexBase) + { + meshInterface->addIndexedMesh(meshPart, meshPart.m_indexType); + } + } + + return meshInterface; +} + +btStridingMeshInterfaceData* btCollisionWorldImporter::createStridingMeshInterfaceData(btStridingMeshInterfaceData* interfaceData) +{ + //create a new btStridingMeshInterfaceData that is an exact copy of shapedata and store it in the WorldImporter + btStridingMeshInterfaceData* newData = new btStridingMeshInterfaceData; + + newData->m_scaling = interfaceData->m_scaling; + newData->m_numMeshParts = interfaceData->m_numMeshParts; + newData->m_meshPartsPtr = new btMeshPartData[newData->m_numMeshParts]; + + for (int i = 0; i < newData->m_numMeshParts; i++) + { + btMeshPartData* curPart = &interfaceData->m_meshPartsPtr[i]; + btMeshPartData* curNewPart = &newData->m_meshPartsPtr[i]; + + curNewPart->m_numTriangles = curPart->m_numTriangles; + curNewPart->m_numVertices = curPart->m_numVertices; + + if (curPart->m_vertices3f) + { + curNewPart->m_vertices3f = new btVector3FloatData[curNewPart->m_numVertices]; + memcpy(curNewPart->m_vertices3f, curPart->m_vertices3f, sizeof(btVector3FloatData) * curNewPart->m_numVertices); + } + else + curNewPart->m_vertices3f = NULL; + + if (curPart->m_vertices3d) + { + curNewPart->m_vertices3d = new btVector3DoubleData[curNewPart->m_numVertices]; + memcpy(curNewPart->m_vertices3d, curPart->m_vertices3d, sizeof(btVector3DoubleData) * curNewPart->m_numVertices); + } + else + curNewPart->m_vertices3d = NULL; + + int numIndices = curNewPart->m_numTriangles * 3; + ///the m_3indices8 was not initialized in some Bullet versions, this can cause crashes at loading time + ///we catch it by only dealing with m_3indices8 if none of the other indices are initialized + bool uninitialized3indices8Workaround = false; + + if (curPart->m_indices32) + { + uninitialized3indices8Workaround = true; + curNewPart->m_indices32 = new btIntIndexData[numIndices]; + memcpy(curNewPart->m_indices32, curPart->m_indices32, sizeof(btIntIndexData) * numIndices); + } + else + curNewPart->m_indices32 = NULL; + + if (curPart->m_3indices16) + { + uninitialized3indices8Workaround = true; + curNewPart->m_3indices16 = new btShortIntIndexTripletData[curNewPart->m_numTriangles]; + memcpy(curNewPart->m_3indices16, curPart->m_3indices16, sizeof(btShortIntIndexTripletData) * curNewPart->m_numTriangles); + } + else + curNewPart->m_3indices16 = NULL; + + if (curPart->m_indices16) + { + uninitialized3indices8Workaround = true; + curNewPart->m_indices16 = new btShortIntIndexData[numIndices]; + memcpy(curNewPart->m_indices16, curPart->m_indices16, sizeof(btShortIntIndexData) * numIndices); + } + else + curNewPart->m_indices16 = NULL; + + if (!uninitialized3indices8Workaround && curPart->m_3indices8) + { + curNewPart->m_3indices8 = new btCharIndexTripletData[curNewPart->m_numTriangles]; + memcpy(curNewPart->m_3indices8, curPart->m_3indices8, sizeof(btCharIndexTripletData) * curNewPart->m_numTriangles); + } + else + curNewPart->m_3indices8 = NULL; + } + + m_allocatedbtStridingMeshInterfaceDatas.push_back(newData); + + return (newData); +} + +#ifdef USE_INTERNAL_EDGE_UTILITY +extern ContactAddedCallback gContactAddedCallback; + +static bool btAdjustInternalEdgeContactsCallback(btManifoldPoint& cp, const btCollisionObject* colObj0, int partId0, int index0, const btCollisionObject* colObj1, int partId1, int index1) +{ + btAdjustInternalEdgeContacts(cp, colObj1, colObj0, partId1, index1); + //btAdjustInternalEdgeContacts(cp,colObj1,colObj0, partId1,index1, BT_TRIANGLE_CONVEX_BACKFACE_MODE); + //btAdjustInternalEdgeContacts(cp,colObj1,colObj0, partId1,index1, BT_TRIANGLE_CONVEX_DOUBLE_SIDED+BT_TRIANGLE_CONCAVE_DOUBLE_SIDED); + return true; +} +#endif //USE_INTERNAL_EDGE_UTILITY + +/* +btRigidBody* btWorldImporter::createRigidBody(bool isDynamic, btScalar mass, const btTransform& startTransform,btCollisionShape* shape,const char* bodyName) +{ + btVector3 localInertia; + localInertia.setZero(); + + if (mass) + shape->calculateLocalInertia(mass,localInertia); + + btRigidBody* body = new btRigidBody(mass,0,shape,localInertia); + body->setWorldTransform(startTransform); + + if (m_dynamicsWorld) + m_dynamicsWorld->addRigidBody(body); + + if (bodyName) + { + char* newname = duplicateName(bodyName); + m_objectNameMap.insert(body,newname); + m_nameBodyMap.insert(newname,body); + } + m_allocatedRigidBodies.push_back(body); + return body; + +} +*/ + +btCollisionObject* btCollisionWorldImporter::getCollisionObjectByName(const char* name) +{ + btCollisionObject** bodyPtr = m_nameColObjMap.find(name); + if (bodyPtr && *bodyPtr) + { + return *bodyPtr; + } + return 0; +} + +btCollisionObject* btCollisionWorldImporter::createCollisionObject(const btTransform& startTransform, btCollisionShape* shape, const char* bodyName) +{ + btCollisionObject* colObj = new btCollisionObject(); + colObj->setWorldTransform(startTransform); + colObj->setCollisionShape(shape); + m_collisionWorld->addCollisionObject(colObj); //todo: flags etc + + if (bodyName) + { + char* newname = duplicateName(bodyName); + m_objectNameMap.insert(colObj, newname); + m_nameColObjMap.insert(newname, colObj); + } + m_allocatedCollisionObjects.push_back(colObj); + + return colObj; +} + +btCollisionShape* btCollisionWorldImporter::createPlaneShape(const btVector3& planeNormal, btScalar planeConstant) +{ + btStaticPlaneShape* shape = new btStaticPlaneShape(planeNormal, planeConstant); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} +btCollisionShape* btCollisionWorldImporter::createBoxShape(const btVector3& halfExtents) +{ + btBoxShape* shape = new btBoxShape(halfExtents); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} +btCollisionShape* btCollisionWorldImporter::createSphereShape(btScalar radius) +{ + btSphereShape* shape = new btSphereShape(radius); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btCollisionShape* btCollisionWorldImporter::createCapsuleShapeX(btScalar radius, btScalar height) +{ + btCapsuleShapeX* shape = new btCapsuleShapeX(radius, height); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btCollisionShape* btCollisionWorldImporter::createCapsuleShapeY(btScalar radius, btScalar height) +{ + btCapsuleShape* shape = new btCapsuleShape(radius, height); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btCollisionShape* btCollisionWorldImporter::createCapsuleShapeZ(btScalar radius, btScalar height) +{ + btCapsuleShapeZ* shape = new btCapsuleShapeZ(radius, height); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btCollisionShape* btCollisionWorldImporter::createCylinderShapeX(btScalar radius, btScalar height) +{ + btCylinderShapeX* shape = new btCylinderShapeX(btVector3(height, radius, radius)); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btCollisionShape* btCollisionWorldImporter::createCylinderShapeY(btScalar radius, btScalar height) +{ + btCylinderShape* shape = new btCylinderShape(btVector3(radius, height, radius)); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btCollisionShape* btCollisionWorldImporter::createCylinderShapeZ(btScalar radius, btScalar height) +{ + btCylinderShapeZ* shape = new btCylinderShapeZ(btVector3(radius, radius, height)); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btCollisionShape* btCollisionWorldImporter::createConeShapeX(btScalar radius, btScalar height) +{ + btConeShapeX* shape = new btConeShapeX(radius, height); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btCollisionShape* btCollisionWorldImporter::createConeShapeY(btScalar radius, btScalar height) +{ + btConeShape* shape = new btConeShape(radius, height); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btCollisionShape* btCollisionWorldImporter::createConeShapeZ(btScalar radius, btScalar height) +{ + btConeShapeZ* shape = new btConeShapeZ(radius, height); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btTriangleIndexVertexArray* btCollisionWorldImporter::createTriangleMeshContainer() +{ + btTriangleIndexVertexArray* in = new btTriangleIndexVertexArray(); + m_allocatedTriangleIndexArrays.push_back(in); + return in; +} + +btOptimizedBvh* btCollisionWorldImporter::createOptimizedBvh() +{ + btOptimizedBvh* bvh = new btOptimizedBvh(); + m_allocatedBvhs.push_back(bvh); + return bvh; +} + +btTriangleInfoMap* btCollisionWorldImporter::createTriangleInfoMap() +{ + btTriangleInfoMap* tim = new btTriangleInfoMap(); + m_allocatedTriangleInfoMaps.push_back(tim); + return tim; +} + +btBvhTriangleMeshShape* btCollisionWorldImporter::createBvhTriangleMeshShape(btStridingMeshInterface* trimesh, btOptimizedBvh* bvh) +{ + if (bvh) + { + btBvhTriangleMeshShape* bvhTriMesh = new btBvhTriangleMeshShape(trimesh, bvh->isQuantized(), false); + bvhTriMesh->setOptimizedBvh(bvh); + m_allocatedCollisionShapes.push_back(bvhTriMesh); + return bvhTriMesh; + } + + btBvhTriangleMeshShape* ts = new btBvhTriangleMeshShape(trimesh, true); + m_allocatedCollisionShapes.push_back(ts); + return ts; +} +btCollisionShape* btCollisionWorldImporter::createConvexTriangleMeshShape(btStridingMeshInterface* trimesh) +{ + return 0; +} +#ifdef SUPPORT_GIMPACT_SHAPE_IMPORT +btGImpactMeshShape* btCollisionWorldImporter::createGimpactShape(btStridingMeshInterface* trimesh) +{ + btGImpactMeshShape* shape = new btGImpactMeshShape(trimesh); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} +#endif //SUPPORT_GIMPACT_SHAPE_IMPORT + +btConvexHullShape* btCollisionWorldImporter::createConvexHullShape() +{ + btConvexHullShape* shape = new btConvexHullShape(); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btCompoundShape* btCollisionWorldImporter::createCompoundShape() +{ + btCompoundShape* shape = new btCompoundShape(); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btScaledBvhTriangleMeshShape* btCollisionWorldImporter::createScaledTrangleMeshShape(btBvhTriangleMeshShape* meshShape, const btVector3& localScaling) +{ + btScaledBvhTriangleMeshShape* shape = new btScaledBvhTriangleMeshShape(meshShape, localScaling); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +btMultiSphereShape* btCollisionWorldImporter::createMultiSphereShape(const btVector3* positions, const btScalar* radi, int numSpheres) +{ + btMultiSphereShape* shape = new btMultiSphereShape(positions, radi, numSpheres); + m_allocatedCollisionShapes.push_back(shape); + return shape; +} + +// query for data +int btCollisionWorldImporter::getNumCollisionShapes() const +{ + return m_allocatedCollisionShapes.size(); +} + +btCollisionShape* btCollisionWorldImporter::getCollisionShapeByIndex(int index) +{ + return m_allocatedCollisionShapes[index]; +} + +btCollisionShape* btCollisionWorldImporter::getCollisionShapeByName(const char* name) +{ + btCollisionShape** shapePtr = m_nameShapeMap.find(name); + if (shapePtr && *shapePtr) + { + return *shapePtr; + } + return 0; +} + +const char* btCollisionWorldImporter::getNameForPointer(const void* ptr) const +{ + const char* const* namePtr = m_objectNameMap.find(ptr); + if (namePtr && *namePtr) + return *namePtr; + return 0; +} + +int btCollisionWorldImporter::getNumRigidBodies() const +{ + return m_allocatedRigidBodies.size(); +} + +btCollisionObject* btCollisionWorldImporter::getRigidBodyByIndex(int index) const +{ + return m_allocatedRigidBodies[index]; +} + +int btCollisionWorldImporter::getNumBvhs() const +{ + return m_allocatedBvhs.size(); +} +btOptimizedBvh* btCollisionWorldImporter::getBvhByIndex(int index) const +{ + return m_allocatedBvhs[index]; +} + +int btCollisionWorldImporter::getNumTriangleInfoMaps() const +{ + return m_allocatedTriangleInfoMaps.size(); +} + +btTriangleInfoMap* btCollisionWorldImporter::getTriangleInfoMapByIndex(int index) const +{ + return m_allocatedTriangleInfoMaps[index]; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp.i new file mode 100644 index 00000000..25a77935 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionWorldImporter.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.h new file mode 100644 index 00000000..5e8bc953 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.h @@ -0,0 +1,169 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2014 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COLLISION_WORLD_IMPORTER_H +#define BT_COLLISION_WORLD_IMPORTER_H + +#include "LinearMath/btTransform.h" +#include "LinearMath/btVector3.h" +#include "LinearMath/btAlignedObjectArray.h" +#include "LinearMath/btHashMap.h" + +class btCollisionShape; +class btCollisionObject; +struct btBulletSerializedArrays; + +struct ConstraintInput; +class btCollisionWorld; +struct btCollisionShapeData; +class btTriangleIndexVertexArray; +class btStridingMeshInterface; +struct btStridingMeshInterfaceData; +class btGImpactMeshShape; +class btOptimizedBvh; +struct btTriangleInfoMap; +class btBvhTriangleMeshShape; +class btPoint2PointConstraint; +class btHingeConstraint; +class btConeTwistConstraint; +class btGeneric6DofConstraint; +class btGeneric6DofSpringConstraint; +class btSliderConstraint; +class btGearConstraint; +struct btContactSolverInfo; + +class btCollisionWorldImporter +{ +protected: + btCollisionWorld* m_collisionWorld; + + int m_verboseMode; + + btAlignedObjectArray m_allocatedCollisionShapes; + btAlignedObjectArray m_allocatedRigidBodies; + + btAlignedObjectArray m_allocatedBvhs; + btAlignedObjectArray m_allocatedTriangleInfoMaps; + btAlignedObjectArray m_allocatedTriangleIndexArrays; + btAlignedObjectArray m_allocatedbtStridingMeshInterfaceDatas; + btAlignedObjectArray m_allocatedCollisionObjects; + + btAlignedObjectArray m_allocatedNames; + + btAlignedObjectArray m_indexArrays; + btAlignedObjectArray m_shortIndexArrays; + btAlignedObjectArray m_charIndexArrays; + + btAlignedObjectArray m_floatVertexArrays; + btAlignedObjectArray m_doubleVertexArrays; + + btHashMap m_bvhMap; + btHashMap m_timMap; + + btHashMap m_nameShapeMap; + btHashMap m_nameColObjMap; + + btHashMap m_objectNameMap; + + btHashMap m_shapeMap; + btHashMap m_bodyMap; + + //methods + + char* duplicateName(const char* name); + + btCollisionShape* convertCollisionShape(btCollisionShapeData* shapeData); + +public: + btCollisionWorldImporter(btCollisionWorld* world); + + virtual ~btCollisionWorldImporter(); + + bool convertAllObjects(btBulletSerializedArrays* arrays); + + ///delete all memory collision shapes, rigid bodies, constraints etc. allocated during the load. + ///make sure you don't use the dynamics world containing objects after you call this method + virtual void deleteAllData(); + + void setVerboseMode(int verboseMode) + { + m_verboseMode = verboseMode; + } + + int getVerboseMode() const + { + return m_verboseMode; + } + + // query for data + int getNumCollisionShapes() const; + btCollisionShape* getCollisionShapeByIndex(int index); + int getNumRigidBodies() const; + btCollisionObject* getRigidBodyByIndex(int index) const; + + int getNumBvhs() const; + btOptimizedBvh* getBvhByIndex(int index) const; + int getNumTriangleInfoMaps() const; + btTriangleInfoMap* getTriangleInfoMapByIndex(int index) const; + + // queris involving named objects + btCollisionShape* getCollisionShapeByName(const char* name); + btCollisionObject* getCollisionObjectByName(const char* name); + + const char* getNameForPointer(const void* ptr) const; + + ///those virtuals are called by load and can be overridden by the user + + //bodies + + virtual btCollisionObject* createCollisionObject(const btTransform& startTransform, btCollisionShape* shape, const char* bodyName); + + ///shapes + + virtual btCollisionShape* createPlaneShape(const btVector3& planeNormal, btScalar planeConstant); + virtual btCollisionShape* createBoxShape(const btVector3& halfExtents); + virtual btCollisionShape* createSphereShape(btScalar radius); + virtual btCollisionShape* createCapsuleShapeX(btScalar radius, btScalar height); + virtual btCollisionShape* createCapsuleShapeY(btScalar radius, btScalar height); + virtual btCollisionShape* createCapsuleShapeZ(btScalar radius, btScalar height); + + virtual btCollisionShape* createCylinderShapeX(btScalar radius, btScalar height); + virtual btCollisionShape* createCylinderShapeY(btScalar radius, btScalar height); + virtual btCollisionShape* createCylinderShapeZ(btScalar radius, btScalar height); + virtual btCollisionShape* createConeShapeX(btScalar radius, btScalar height); + virtual btCollisionShape* createConeShapeY(btScalar radius, btScalar height); + virtual btCollisionShape* createConeShapeZ(btScalar radius, btScalar height); + virtual class btTriangleIndexVertexArray* createTriangleMeshContainer(); + virtual btBvhTriangleMeshShape* createBvhTriangleMeshShape(btStridingMeshInterface* trimesh, btOptimizedBvh* bvh); + virtual btCollisionShape* createConvexTriangleMeshShape(btStridingMeshInterface* trimesh); +#ifdef SUPPORT_GIMPACT_SHAPE_IMPORT + virtual btGImpactMeshShape* createGimpactShape(btStridingMeshInterface* trimesh); +#endif //SUPPORT_GIMPACT_SHAPE_IMPORT + virtual btStridingMeshInterfaceData* createStridingMeshInterfaceData(btStridingMeshInterfaceData* interfaceData); + + virtual class btConvexHullShape* createConvexHullShape(); + virtual class btCompoundShape* createCompoundShape(); + virtual class btScaledBvhTriangleMeshShape* createScaledTrangleMeshShape(btBvhTriangleMeshShape* meshShape, const btVector3& localScalingbtBvhTriangleMeshShape); + + virtual class btMultiSphereShape* createMultiSphereShape(const btVector3* positions, const btScalar* radi, int numSpheres); + + virtual btTriangleIndexVertexArray* createMeshInterface(btStridingMeshInterfaceData& meshData); + + ///acceleration and connectivity structures + virtual btOptimizedBvh* createOptimizedBvh(); + virtual btTriangleInfoMap* createTriangleInfoMap(); +}; + +#endif //BT_WORLD_IMPORTER_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.h.i new file mode 100644 index 00000000..89e92a92 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCollisionWorldImporter.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCollisionWorldImporter.h ---------------- + +%include "BulletCollision/CollisionDispatch/btCollisionWorldImporter.h" + +%{ +#include "BulletCollision/CollisionDispatch/btCollisionWorldImporter.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp new file mode 100644 index 00000000..6f7ea014 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp @@ -0,0 +1,390 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. + +*/ + +#include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionShapes/btCompoundShape.h" +#include "BulletCollision/BroadphaseCollision/btDbvt.h" +#include "LinearMath/btIDebugDraw.h" +#include "LinearMath/btAabbUtil2.h" +#include "btManifoldResult.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +btShapePairCallback gCompoundChildShapePairCallback = 0; + +btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped) + : btActivatingCollisionAlgorithm(ci, body0Wrap, body1Wrap), + m_isSwapped(isSwapped), + m_sharedManifold(ci.m_manifold) +{ + m_ownsManifold = false; + + const btCollisionObjectWrapper* colObjWrap = m_isSwapped ? body1Wrap : body0Wrap; + btAssert(colObjWrap->getCollisionShape()->isCompound()); + + const btCompoundShape* compoundShape = static_cast(colObjWrap->getCollisionShape()); + m_compoundShapeRevision = compoundShape->getUpdateRevision(); + + preallocateChildAlgorithms(body0Wrap, body1Wrap); +} + +void btCompoundCollisionAlgorithm::preallocateChildAlgorithms(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) +{ + const btCollisionObjectWrapper* colObjWrap = m_isSwapped ? body1Wrap : body0Wrap; + const btCollisionObjectWrapper* otherObjWrap = m_isSwapped ? body0Wrap : body1Wrap; + btAssert(colObjWrap->getCollisionShape()->isCompound()); + + const btCompoundShape* compoundShape = static_cast(colObjWrap->getCollisionShape()); + + int numChildren = compoundShape->getNumChildShapes(); + int i; + + m_childCollisionAlgorithms.resize(numChildren); + for (i = 0; i < numChildren; i++) + { + if (compoundShape->getDynamicAabbTree()) + { + m_childCollisionAlgorithms[i] = 0; + } + else + { + const btCollisionShape* childShape = compoundShape->getChildShape(i); + + btCollisionObjectWrapper childWrap(colObjWrap, childShape, colObjWrap->getCollisionObject(), colObjWrap->getWorldTransform(), -1, i); //wrong child trans, but unused (hopefully) + m_childCollisionAlgorithms[i] = m_dispatcher->findAlgorithm(&childWrap, otherObjWrap, m_sharedManifold, BT_CONTACT_POINT_ALGORITHMS); + + btAlignedObjectArray m_childCollisionAlgorithmsContact; + btAlignedObjectArray m_childCollisionAlgorithmsClosestPoints; + } + } +} + +void btCompoundCollisionAlgorithm::removeChildAlgorithms() +{ + int numChildren = m_childCollisionAlgorithms.size(); + int i; + for (i = 0; i < numChildren; i++) + { + if (m_childCollisionAlgorithms[i]) + { + m_childCollisionAlgorithms[i]->~btCollisionAlgorithm(); + m_dispatcher->freeCollisionAlgorithm(m_childCollisionAlgorithms[i]); + } + } +} + +btCompoundCollisionAlgorithm::~btCompoundCollisionAlgorithm() +{ + removeChildAlgorithms(); +} + +struct btCompoundLeafCallback : btDbvt::ICollide +{ +public: + const btCollisionObjectWrapper* m_compoundColObjWrap; + const btCollisionObjectWrapper* m_otherObjWrap; + btDispatcher* m_dispatcher; + const btDispatcherInfo& m_dispatchInfo; + btManifoldResult* m_resultOut; + btCollisionAlgorithm** m_childCollisionAlgorithms; + btPersistentManifold* m_sharedManifold; + + btCompoundLeafCallback(const btCollisionObjectWrapper* compoundObjWrap, const btCollisionObjectWrapper* otherObjWrap, btDispatcher* dispatcher, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut, btCollisionAlgorithm** childCollisionAlgorithms, btPersistentManifold* sharedManifold) + : m_compoundColObjWrap(compoundObjWrap), m_otherObjWrap(otherObjWrap), m_dispatcher(dispatcher), m_dispatchInfo(dispatchInfo), m_resultOut(resultOut), m_childCollisionAlgorithms(childCollisionAlgorithms), m_sharedManifold(sharedManifold) + { + } + + void ProcessChildShape(const btCollisionShape* childShape, int index) + { + btAssert(index >= 0); + const btCompoundShape* compoundShape = static_cast(m_compoundColObjWrap->getCollisionShape()); + btAssert(index < compoundShape->getNumChildShapes()); + + if (gCompoundChildShapePairCallback) + { + if (!gCompoundChildShapePairCallback(m_otherObjWrap->getCollisionShape(), childShape)) + return; + } + + //backup + btTransform orgTrans = m_compoundColObjWrap->getWorldTransform(); + + const btTransform& childTrans = compoundShape->getChildTransform(index); + btTransform newChildWorldTrans = orgTrans * childTrans; + + //perform an AABB check first + btVector3 aabbMin0, aabbMax0; + childShape->getAabb(newChildWorldTrans, aabbMin0, aabbMax0); + + btVector3 extendAabb(m_resultOut->m_closestPointDistanceThreshold, m_resultOut->m_closestPointDistanceThreshold, m_resultOut->m_closestPointDistanceThreshold); + aabbMin0 -= extendAabb; + aabbMax0 += extendAabb; + + btVector3 aabbMin1, aabbMax1; + m_otherObjWrap->getCollisionShape()->getAabb(m_otherObjWrap->getWorldTransform(), aabbMin1, aabbMax1); + + + if (TestAabbAgainstAabb2(aabbMin0, aabbMax0, aabbMin1, aabbMax1)) + { + btTransform preTransform = childTrans; + if (this->m_compoundColObjWrap->m_preTransform) + { + preTransform = preTransform *(*(this->m_compoundColObjWrap->m_preTransform)); + } + btCollisionObjectWrapper compoundWrap(this->m_compoundColObjWrap, childShape, m_compoundColObjWrap->getCollisionObject(), newChildWorldTrans, preTransform, -1, index); + + btCollisionAlgorithm* algo = 0; + bool allocatedAlgorithm = false; + + if (m_resultOut->m_closestPointDistanceThreshold > 0) + { + algo = m_dispatcher->findAlgorithm(&compoundWrap, m_otherObjWrap, 0, BT_CLOSEST_POINT_ALGORITHMS); + allocatedAlgorithm = true; + } + else + { + //the contactpoint is still projected back using the original inverted worldtrans + if (!m_childCollisionAlgorithms[index]) + { + m_childCollisionAlgorithms[index] = m_dispatcher->findAlgorithm(&compoundWrap, m_otherObjWrap, m_sharedManifold, BT_CONTACT_POINT_ALGORITHMS); + } + algo = m_childCollisionAlgorithms[index]; + } + + const btCollisionObjectWrapper* tmpWrap = 0; + + ///detect swapping case + if (m_resultOut->getBody0Internal() == m_compoundColObjWrap->getCollisionObject()) + { + tmpWrap = m_resultOut->getBody0Wrap(); + m_resultOut->setBody0Wrap(&compoundWrap); + m_resultOut->setShapeIdentifiersA(-1, index); + } + else + { + tmpWrap = m_resultOut->getBody1Wrap(); + m_resultOut->setBody1Wrap(&compoundWrap); + m_resultOut->setShapeIdentifiersB(-1, index); + } + + algo->processCollision(&compoundWrap, m_otherObjWrap, m_dispatchInfo, m_resultOut); + +#if 0 + if (m_dispatchInfo.m_debugDraw && (m_dispatchInfo.m_debugDraw->getDebugMode() & btIDebugDraw::DBG_DrawAabb)) + { + btVector3 worldAabbMin,worldAabbMax; + m_dispatchInfo.m_debugDraw->drawAabb(aabbMin0,aabbMax0,btVector3(1,1,1)); + m_dispatchInfo.m_debugDraw->drawAabb(aabbMin1,aabbMax1,btVector3(1,1,1)); + } +#endif + + if (m_resultOut->getBody0Internal() == m_compoundColObjWrap->getCollisionObject()) + { + m_resultOut->setBody0Wrap(tmpWrap); + } + else + { + m_resultOut->setBody1Wrap(tmpWrap); + } + if (allocatedAlgorithm) + { + algo->~btCollisionAlgorithm(); + m_dispatcher->freeCollisionAlgorithm(algo); + } + } + } + void Process(const btDbvtNode* leaf) + { + int index = leaf->dataAsInt; + + const btCompoundShape* compoundShape = static_cast(m_compoundColObjWrap->getCollisionShape()); + const btCollisionShape* childShape = compoundShape->getChildShape(index); + +#if 0 + if (m_dispatchInfo.m_debugDraw && (m_dispatchInfo.m_debugDraw->getDebugMode() & btIDebugDraw::DBG_DrawAabb)) + { + btVector3 worldAabbMin,worldAabbMax; + btTransform orgTrans = m_compoundColObjWrap->getWorldTransform(); + btTransformAabb(leaf->volume.Mins(),leaf->volume.Maxs(),0.,orgTrans,worldAabbMin,worldAabbMax); + m_dispatchInfo.m_debugDraw->drawAabb(worldAabbMin,worldAabbMax,btVector3(1,0,0)); + } +#endif + + ProcessChildShape(childShape, index); + } +}; + +void btCompoundCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + const btCollisionObjectWrapper* colObjWrap = m_isSwapped ? body1Wrap : body0Wrap; + const btCollisionObjectWrapper* otherObjWrap = m_isSwapped ? body0Wrap : body1Wrap; + + btAssert(colObjWrap->getCollisionShape()->isCompound()); + const btCompoundShape* compoundShape = static_cast(colObjWrap->getCollisionShape()); + + ///btCompoundShape might have changed: + ////make sure the internal child collision algorithm caches are still valid + if (compoundShape->getUpdateRevision() != m_compoundShapeRevision) + { + ///clear and update all + removeChildAlgorithms(); + + preallocateChildAlgorithms(body0Wrap, body1Wrap); + m_compoundShapeRevision = compoundShape->getUpdateRevision(); + } + + if (m_childCollisionAlgorithms.size() == 0) + return; + + const btDbvt* tree = compoundShape->getDynamicAabbTree(); + //use a dynamic aabb tree to cull potential child-overlaps + btCompoundLeafCallback callback(colObjWrap, otherObjWrap, m_dispatcher, dispatchInfo, resultOut, &m_childCollisionAlgorithms[0], m_sharedManifold); + + ///we need to refresh all contact manifolds + ///note that we should actually recursively traverse all children, btCompoundShape can nested more then 1 level deep + ///so we should add a 'refreshManifolds' in the btCollisionAlgorithm + { + int i; + manifoldArray.resize(0); + for (i = 0; i < m_childCollisionAlgorithms.size(); i++) + { + if (m_childCollisionAlgorithms[i]) + { + m_childCollisionAlgorithms[i]->getAllContactManifolds(manifoldArray); + for (int m = 0; m < manifoldArray.size(); m++) + { + if (manifoldArray[m]->getNumContacts()) + { + resultOut->setPersistentManifold(manifoldArray[m]); + resultOut->refreshContactPoints(); + resultOut->setPersistentManifold(0); //??necessary? + } + } + manifoldArray.resize(0); + } + } + } + + if (tree) + { + btVector3 localAabbMin, localAabbMax; + btTransform otherInCompoundSpace; + otherInCompoundSpace = colObjWrap->getWorldTransform().inverse() * otherObjWrap->getWorldTransform(); + otherObjWrap->getCollisionShape()->getAabb(otherInCompoundSpace, localAabbMin, localAabbMax); + btVector3 extraExtends(resultOut->m_closestPointDistanceThreshold, resultOut->m_closestPointDistanceThreshold, resultOut->m_closestPointDistanceThreshold); + localAabbMin -= extraExtends; + localAabbMax += extraExtends; + + const ATTRIBUTE_ALIGNED16(btDbvtVolume) bounds = btDbvtVolume::FromMM(localAabbMin, localAabbMax); + //process all children, that overlap with the given AABB bounds + tree->collideTVNoStackAlloc(tree->m_root, bounds, stack2, callback); + } + else + { + //iterate over all children, perform an AABB check inside ProcessChildShape + int numChildren = m_childCollisionAlgorithms.size(); + int i; + for (i = 0; i < numChildren; i++) + { + callback.ProcessChildShape(compoundShape->getChildShape(i), i); + } + } + + { + //iterate over all children, perform an AABB check inside ProcessChildShape + int numChildren = m_childCollisionAlgorithms.size(); + int i; + manifoldArray.resize(0); + const btCollisionShape* childShape = 0; + btTransform orgTrans; + + btTransform newChildWorldTrans; + btVector3 aabbMin0, aabbMax0, aabbMin1, aabbMax1; + + for (i = 0; i < numChildren; i++) + { + if (m_childCollisionAlgorithms[i]) + { + childShape = compoundShape->getChildShape(i); + //if not longer overlapping, remove the algorithm + orgTrans = colObjWrap->getWorldTransform(); + + const btTransform& childTrans = compoundShape->getChildTransform(i); + newChildWorldTrans = orgTrans * childTrans; + + //perform an AABB check first + childShape->getAabb(newChildWorldTrans, aabbMin0, aabbMax0); + otherObjWrap->getCollisionShape()->getAabb(otherObjWrap->getWorldTransform(), aabbMin1, aabbMax1); + + if (!TestAabbAgainstAabb2(aabbMin0, aabbMax0, aabbMin1, aabbMax1)) + { + m_childCollisionAlgorithms[i]->~btCollisionAlgorithm(); + m_dispatcher->freeCollisionAlgorithm(m_childCollisionAlgorithms[i]); + m_childCollisionAlgorithms[i] = 0; + } + } + } + } +} + +btScalar btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + btAssert(0); + //needs to be fixed, using btCollisionObjectWrapper and NOT modifying internal data structures + btCollisionObject* colObj = m_isSwapped ? body1 : body0; + btCollisionObject* otherObj = m_isSwapped ? body0 : body1; + + btAssert(colObj->getCollisionShape()->isCompound()); + + btCompoundShape* compoundShape = static_cast(colObj->getCollisionShape()); + + //We will use the OptimizedBVH, AABB tree to cull potential child-overlaps + //If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals + //given Proxy0 and Proxy1, if both have a tree, Tree0 and Tree1, this means: + //determine overlapping nodes of Proxy1 using Proxy0 AABB against Tree1 + //then use each overlapping node AABB against Tree0 + //and vise versa. + + btScalar hitFraction = btScalar(1.); + + int numChildren = m_childCollisionAlgorithms.size(); + int i; + btTransform orgTrans; + btScalar frac; + for (i = 0; i < numChildren; i++) + { + //btCollisionShape* childShape = compoundShape->getChildShape(i); + + //backup + orgTrans = colObj->getWorldTransform(); + + const btTransform& childTrans = compoundShape->getChildTransform(i); + //btTransform newChildWorldTrans = orgTrans*childTrans ; + colObj->setWorldTransform(orgTrans * childTrans); + + //btCollisionShape* tmpShape = colObj->getCollisionShape(); + //colObj->internalSetTemporaryCollisionShape( childShape ); + frac = m_childCollisionAlgorithms[i]->calculateTimeOfImpact(colObj, otherObj, dispatchInfo, resultOut); + if (frac < hitFraction) + { + hitFraction = frac; + } + //revert back + //colObj->internalSetTemporaryCollisionShape( tmpShape); + colObj->setWorldTransform(orgTrans); + } + return hitFraction; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..54eb47ee --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h new file mode 100644 index 00000000..1193bd4a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h @@ -0,0 +1,99 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. + +*/ + +#ifndef BT_COMPOUND_COLLISION_ALGORITHM_H +#define BT_COMPOUND_COLLISION_ALGORITHM_H + +#include "btActivatingCollisionAlgorithm.h" +#include "BulletCollision/BroadphaseCollision/btDispatcher.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" + +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +class btDispatcher; +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "btCollisionCreateFunc.h" +#include "LinearMath/btAlignedObjectArray.h" +#include "BulletCollision/BroadphaseCollision/btDbvt.h" +class btDispatcher; +class btCollisionObject; + +class btCollisionShape; +typedef bool (*btShapePairCallback)(const btCollisionShape* pShape0, const btCollisionShape* pShape1); +extern btShapePairCallback gCompoundChildShapePairCallback; + +/// btCompoundCollisionAlgorithm supports collision between CompoundCollisionShapes and other collision shapes +class btCompoundCollisionAlgorithm : public btActivatingCollisionAlgorithm +{ + btNodeStack stack2; + btManifoldArray manifoldArray; + +protected: + btAlignedObjectArray m_childCollisionAlgorithms; + bool m_isSwapped; + + class btPersistentManifold* m_sharedManifold; + bool m_ownsManifold; + + int m_compoundShapeRevision; //to keep track of changes, so that childAlgorithm array can be updated + + void removeChildAlgorithms(); + + void preallocateChildAlgorithms(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap); + +public: + btCompoundCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped); + + virtual ~btCompoundCollisionAlgorithm(); + + btCollisionAlgorithm* getChildAlgorithm(int n) const + { + return m_childCollisionAlgorithms[n]; + } + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual void getAllContactManifolds(btManifoldArray& manifoldArray) + { + int i; + for (i = 0; i < m_childCollisionAlgorithms.size(); i++) + { + if (m_childCollisionAlgorithms[i]) + m_childCollisionAlgorithms[i]->getAllContactManifolds(manifoldArray); + } + } + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btCompoundCollisionAlgorithm)); + return new (mem) btCompoundCollisionAlgorithm(ci, body0Wrap, body1Wrap, false); + } + }; + + struct SwappedCreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btCompoundCollisionAlgorithm)); + return new (mem) btCompoundCollisionAlgorithm(ci, body0Wrap, body1Wrap, true); + } + }; +}; + +#endif //BT_COMPOUND_COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h.i new file mode 100644 index 00000000..cadd989a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp new file mode 100644 index 00000000..197b2bdd --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp @@ -0,0 +1,413 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. + +*/ + +#include "btCompoundCompoundCollisionAlgorithm.h" +#include "LinearMath/btQuickprof.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionShapes/btCompoundShape.h" +#include "BulletCollision/BroadphaseCollision/btDbvt.h" +#include "LinearMath/btIDebugDraw.h" +#include "LinearMath/btAabbUtil2.h" +#include "BulletCollision/CollisionDispatch/btManifoldResult.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +//USE_LOCAL_STACK will avoid most (often all) dynamic memory allocations due to resizing in processCollision and MycollideTT +#define USE_LOCAL_STACK 1 + +btShapePairCallback gCompoundCompoundChildShapePairCallback = 0; + +btCompoundCompoundCollisionAlgorithm::btCompoundCompoundCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped) + : btCompoundCollisionAlgorithm(ci, body0Wrap, body1Wrap, isSwapped) +{ + void* ptr = btAlignedAlloc(sizeof(btHashedSimplePairCache), 16); + m_childCollisionAlgorithmCache = new (ptr) btHashedSimplePairCache(); + + const btCollisionObjectWrapper* col0ObjWrap = body0Wrap; + btAssert(col0ObjWrap->getCollisionShape()->isCompound()); + + const btCollisionObjectWrapper* col1ObjWrap = body1Wrap; + btAssert(col1ObjWrap->getCollisionShape()->isCompound()); + + const btCompoundShape* compoundShape0 = static_cast(col0ObjWrap->getCollisionShape()); + m_compoundShapeRevision0 = compoundShape0->getUpdateRevision(); + + const btCompoundShape* compoundShape1 = static_cast(col1ObjWrap->getCollisionShape()); + m_compoundShapeRevision1 = compoundShape1->getUpdateRevision(); +} + +btCompoundCompoundCollisionAlgorithm::~btCompoundCompoundCollisionAlgorithm() +{ + removeChildAlgorithms(); + m_childCollisionAlgorithmCache->~btHashedSimplePairCache(); + btAlignedFree(m_childCollisionAlgorithmCache); +} + +void btCompoundCompoundCollisionAlgorithm::getAllContactManifolds(btManifoldArray& manifoldArray) +{ + int i; + btSimplePairArray& pairs = m_childCollisionAlgorithmCache->getOverlappingPairArray(); + for (i = 0; i < pairs.size(); i++) + { + if (pairs[i].m_userPointer) + { + ((btCollisionAlgorithm*)pairs[i].m_userPointer)->getAllContactManifolds(manifoldArray); + } + } +} + +void btCompoundCompoundCollisionAlgorithm::removeChildAlgorithms() +{ + btSimplePairArray& pairs = m_childCollisionAlgorithmCache->getOverlappingPairArray(); + + int numChildren = pairs.size(); + int i; + for (i = 0; i < numChildren; i++) + { + if (pairs[i].m_userPointer) + { + btCollisionAlgorithm* algo = (btCollisionAlgorithm*)pairs[i].m_userPointer; + algo->~btCollisionAlgorithm(); + m_dispatcher->freeCollisionAlgorithm(algo); + } + } + m_childCollisionAlgorithmCache->removeAllPairs(); +} + +struct btCompoundCompoundLeafCallback : btDbvt::ICollide +{ + int m_numOverlapPairs; + + const btCollisionObjectWrapper* m_compound0ColObjWrap; + const btCollisionObjectWrapper* m_compound1ColObjWrap; + btDispatcher* m_dispatcher; + const btDispatcherInfo& m_dispatchInfo; + btManifoldResult* m_resultOut; + + class btHashedSimplePairCache* m_childCollisionAlgorithmCache; + + btPersistentManifold* m_sharedManifold; + + btCompoundCompoundLeafCallback(const btCollisionObjectWrapper* compound1ObjWrap, + const btCollisionObjectWrapper* compound0ObjWrap, + btDispatcher* dispatcher, + const btDispatcherInfo& dispatchInfo, + btManifoldResult* resultOut, + btHashedSimplePairCache* childAlgorithmsCache, + btPersistentManifold* sharedManifold) + : m_numOverlapPairs(0), m_compound0ColObjWrap(compound1ObjWrap), m_compound1ColObjWrap(compound0ObjWrap), m_dispatcher(dispatcher), m_dispatchInfo(dispatchInfo), m_resultOut(resultOut), m_childCollisionAlgorithmCache(childAlgorithmsCache), m_sharedManifold(sharedManifold) + { + } + + void Process(const btDbvtNode* leaf0, const btDbvtNode* leaf1) + { +//\1("btCompoundCompoundLeafCallback::Process"); + m_numOverlapPairs++; + + int childIndex0 = leaf0->dataAsInt; + int childIndex1 = leaf1->dataAsInt; + + btAssert(childIndex0 >= 0); + btAssert(childIndex1 >= 0); + + const btCompoundShape* compoundShape0 = static_cast(m_compound0ColObjWrap->getCollisionShape()); + btAssert(childIndex0 < compoundShape0->getNumChildShapes()); + + const btCompoundShape* compoundShape1 = static_cast(m_compound1ColObjWrap->getCollisionShape()); + btAssert(childIndex1 < compoundShape1->getNumChildShapes()); + + const btCollisionShape* childShape0 = compoundShape0->getChildShape(childIndex0); + const btCollisionShape* childShape1 = compoundShape1->getChildShape(childIndex1); + + //backup + btTransform orgTrans0 = m_compound0ColObjWrap->getWorldTransform(); + const btTransform& childTrans0 = compoundShape0->getChildTransform(childIndex0); + btTransform newChildWorldTrans0 = orgTrans0 * childTrans0; + + btTransform orgTrans1 = m_compound1ColObjWrap->getWorldTransform(); + const btTransform& childTrans1 = compoundShape1->getChildTransform(childIndex1); + btTransform newChildWorldTrans1 = orgTrans1 * childTrans1; + + //perform an AABB check first + btVector3 aabbMin0, aabbMax0, aabbMin1, aabbMax1; + childShape0->getAabb(newChildWorldTrans0, aabbMin0, aabbMax0); + childShape1->getAabb(newChildWorldTrans1, aabbMin1, aabbMax1); + + btVector3 thresholdVec(m_resultOut->m_closestPointDistanceThreshold, m_resultOut->m_closestPointDistanceThreshold, m_resultOut->m_closestPointDistanceThreshold); + + aabbMin0 -= thresholdVec; + aabbMax0 += thresholdVec; + + if (gCompoundCompoundChildShapePairCallback) + { + if (!gCompoundCompoundChildShapePairCallback(childShape0, childShape1)) + return; + } + + if (TestAabbAgainstAabb2(aabbMin0, aabbMax0, aabbMin1, aabbMax1)) + { + btCollisionObjectWrapper compoundWrap0(this->m_compound0ColObjWrap, childShape0, m_compound0ColObjWrap->getCollisionObject(), newChildWorldTrans0, -1, childIndex0); + btCollisionObjectWrapper compoundWrap1(this->m_compound1ColObjWrap, childShape1, m_compound1ColObjWrap->getCollisionObject(), newChildWorldTrans1, -1, childIndex1); + + btSimplePair* pair = m_childCollisionAlgorithmCache->findPair(childIndex0, childIndex1); + bool removePair = false; + btCollisionAlgorithm* colAlgo = 0; + if (m_resultOut->m_closestPointDistanceThreshold > 0) + { + colAlgo = m_dispatcher->findAlgorithm(&compoundWrap0, &compoundWrap1, 0, BT_CLOSEST_POINT_ALGORITHMS); + removePair = true; + } + else + { + if (pair) + { + colAlgo = (btCollisionAlgorithm*)pair->m_userPointer; + } + else + { + colAlgo = m_dispatcher->findAlgorithm(&compoundWrap0, &compoundWrap1, m_sharedManifold, BT_CONTACT_POINT_ALGORITHMS); + pair = m_childCollisionAlgorithmCache->addOverlappingPair(childIndex0, childIndex1); + btAssert(pair); + pair->m_userPointer = colAlgo; + } + } + + btAssert(colAlgo); + + const btCollisionObjectWrapper* tmpWrap0 = 0; + const btCollisionObjectWrapper* tmpWrap1 = 0; + + tmpWrap0 = m_resultOut->getBody0Wrap(); + tmpWrap1 = m_resultOut->getBody1Wrap(); + + m_resultOut->setBody0Wrap(&compoundWrap0); + m_resultOut->setBody1Wrap(&compoundWrap1); + + m_resultOut->setShapeIdentifiersA(-1, childIndex0); + m_resultOut->setShapeIdentifiersB(-1, childIndex1); + + colAlgo->processCollision(&compoundWrap0, &compoundWrap1, m_dispatchInfo, m_resultOut); + + m_resultOut->setBody0Wrap(tmpWrap0); + m_resultOut->setBody1Wrap(tmpWrap1); + + if (removePair) + { + colAlgo->~btCollisionAlgorithm(); + m_dispatcher->freeCollisionAlgorithm(colAlgo); + } + } + } +}; + +static DBVT_INLINE bool MyIntersect(const btDbvtAabbMm& a, + const btDbvtAabbMm& b, const btTransform& xform, btScalar distanceThreshold) +{ + btVector3 newmin, newmax; + btTransformAabb(b.Mins(), b.Maxs(), 0.f, xform, newmin, newmax); + newmin -= btVector3(distanceThreshold, distanceThreshold, distanceThreshold); + newmax += btVector3(distanceThreshold, distanceThreshold, distanceThreshold); + btDbvtAabbMm newb = btDbvtAabbMm::FromMM(newmin, newmax); + return Intersect(a, newb); +} + +static inline void MycollideTT(const btDbvtNode* root0, + const btDbvtNode* root1, + const btTransform& xform, + btCompoundCompoundLeafCallback* callback, btScalar distanceThreshold) +{ + if (root0 && root1) + { + int depth = 1; + int treshold = btDbvt::DOUBLE_STACKSIZE - 4; + btAlignedObjectArray stkStack; +#ifdef USE_LOCAL_STACK + ATTRIBUTE_ALIGNED16(btDbvt::sStkNN localStack[btDbvt::DOUBLE_STACKSIZE]); + stkStack.initializeFromBuffer(&localStack, btDbvt::DOUBLE_STACKSIZE, btDbvt::DOUBLE_STACKSIZE); +#else + stkStack.resize(btDbvt::DOUBLE_STACKSIZE); +#endif + stkStack[0] = btDbvt::sStkNN(root0, root1); + do + { + btDbvt::sStkNN p = stkStack[--depth]; + if (MyIntersect(p.a->volume, p.b->volume, xform, distanceThreshold)) + { + if (depth > treshold) + { + stkStack.resize(stkStack.size() * 2); + treshold = stkStack.size() - 4; + } + if (p.a->isinternal()) + { + if (p.b->isinternal()) + { + stkStack[depth++] = btDbvt::sStkNN(p.a->childs[0], p.b->childs[0]); + stkStack[depth++] = btDbvt::sStkNN(p.a->childs[1], p.b->childs[0]); + stkStack[depth++] = btDbvt::sStkNN(p.a->childs[0], p.b->childs[1]); + stkStack[depth++] = btDbvt::sStkNN(p.a->childs[1], p.b->childs[1]); + } + else + { + stkStack[depth++] = btDbvt::sStkNN(p.a->childs[0], p.b); + stkStack[depth++] = btDbvt::sStkNN(p.a->childs[1], p.b); + } + } + else + { + if (p.b->isinternal()) + { + stkStack[depth++] = btDbvt::sStkNN(p.a, p.b->childs[0]); + stkStack[depth++] = btDbvt::sStkNN(p.a, p.b->childs[1]); + } + else + { + callback->Process(p.a, p.b); + } + } + } + } while (depth); + } +} + +void btCompoundCompoundCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + const btCollisionObjectWrapper* col0ObjWrap = body0Wrap; + const btCollisionObjectWrapper* col1ObjWrap = body1Wrap; + + btAssert(col0ObjWrap->getCollisionShape()->isCompound()); + btAssert(col1ObjWrap->getCollisionShape()->isCompound()); + const btCompoundShape* compoundShape0 = static_cast(col0ObjWrap->getCollisionShape()); + const btCompoundShape* compoundShape1 = static_cast(col1ObjWrap->getCollisionShape()); + + const btDbvt* tree0 = compoundShape0->getDynamicAabbTree(); + const btDbvt* tree1 = compoundShape1->getDynamicAabbTree(); + if (!tree0 || !tree1) + { + return btCompoundCollisionAlgorithm::processCollision(body0Wrap, body1Wrap, dispatchInfo, resultOut); + } + ///btCompoundShape might have changed: + ////make sure the internal child collision algorithm caches are still valid + if ((compoundShape0->getUpdateRevision() != m_compoundShapeRevision0) || (compoundShape1->getUpdateRevision() != m_compoundShapeRevision1)) + { + ///clear all + removeChildAlgorithms(); + m_compoundShapeRevision0 = compoundShape0->getUpdateRevision(); + m_compoundShapeRevision1 = compoundShape1->getUpdateRevision(); + } + + ///we need to refresh all contact manifolds + ///note that we should actually recursively traverse all children, btCompoundShape can nested more then 1 level deep + ///so we should add a 'refreshManifolds' in the btCollisionAlgorithm + { + int i; + btManifoldArray manifoldArray; +#ifdef USE_LOCAL_STACK + btPersistentManifold localManifolds[4]; + manifoldArray.initializeFromBuffer(&localManifolds, 0, 4); +#endif + btSimplePairArray& pairs = m_childCollisionAlgorithmCache->getOverlappingPairArray(); + for (i = 0; i < pairs.size(); i++) + { + if (pairs[i].m_userPointer) + { + btCollisionAlgorithm* algo = (btCollisionAlgorithm*)pairs[i].m_userPointer; + algo->getAllContactManifolds(manifoldArray); + for (int m = 0; m < manifoldArray.size(); m++) + { + if (manifoldArray[m]->getNumContacts()) + { + resultOut->setPersistentManifold(manifoldArray[m]); + resultOut->refreshContactPoints(); + resultOut->setPersistentManifold(0); + } + } + manifoldArray.resize(0); + } + } + } + + btCompoundCompoundLeafCallback callback(col0ObjWrap, col1ObjWrap, this->m_dispatcher, dispatchInfo, resultOut, this->m_childCollisionAlgorithmCache, m_sharedManifold); + + const btTransform xform = col0ObjWrap->getWorldTransform().inverse() * col1ObjWrap->getWorldTransform(); + MycollideTT(tree0->m_root, tree1->m_root, xform, &callback, resultOut->m_closestPointDistanceThreshold); + + //printf("#compound-compound child/leaf overlap =%d \r",callback.m_numOverlapPairs); + + //remove non-overlapping child pairs + + { + btAssert(m_removePairs.size() == 0); + + //iterate over all children, perform an AABB check inside ProcessChildShape + btSimplePairArray& pairs = m_childCollisionAlgorithmCache->getOverlappingPairArray(); + + int i; + btManifoldArray manifoldArray; + + btVector3 aabbMin0, aabbMax0, aabbMin1, aabbMax1; + + for (i = 0; i < pairs.size(); i++) + { + if (pairs[i].m_userPointer) + { + btCollisionAlgorithm* algo = (btCollisionAlgorithm*)pairs[i].m_userPointer; + + { + const btCollisionShape* childShape0 = 0; + + btTransform newChildWorldTrans0; + childShape0 = compoundShape0->getChildShape(pairs[i].m_indexA); + const btTransform& childTrans0 = compoundShape0->getChildTransform(pairs[i].m_indexA); + newChildWorldTrans0 = col0ObjWrap->getWorldTransform() * childTrans0; + childShape0->getAabb(newChildWorldTrans0, aabbMin0, aabbMax0); + } + btVector3 thresholdVec(resultOut->m_closestPointDistanceThreshold, resultOut->m_closestPointDistanceThreshold, resultOut->m_closestPointDistanceThreshold); + aabbMin0 -= thresholdVec; + aabbMax0 += thresholdVec; + { + const btCollisionShape* childShape1 = 0; + btTransform newChildWorldTrans1; + + childShape1 = compoundShape1->getChildShape(pairs[i].m_indexB); + const btTransform& childTrans1 = compoundShape1->getChildTransform(pairs[i].m_indexB); + newChildWorldTrans1 = col1ObjWrap->getWorldTransform() * childTrans1; + childShape1->getAabb(newChildWorldTrans1, aabbMin1, aabbMax1); + } + + aabbMin1 -= thresholdVec; + aabbMax1 += thresholdVec; + + if (!TestAabbAgainstAabb2(aabbMin0, aabbMax0, aabbMin1, aabbMax1)) + { + algo->~btCollisionAlgorithm(); + m_dispatcher->freeCollisionAlgorithm(algo); + m_removePairs.push_back(btSimplePair(pairs[i].m_indexA, pairs[i].m_indexB)); + } + } + } + for (int i = 0; i < m_removePairs.size(); i++) + { + m_childCollisionAlgorithmCache->removeOverlappingPair(m_removePairs[i].m_indexA, m_removePairs[i].m_indexB); + } + m_removePairs.clear(); + } +} + +btScalar btCompoundCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + btAssert(0); + return 0.f; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..0d6a42d7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h new file mode 100644 index 00000000..a940d840 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h @@ -0,0 +1,82 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. + +*/ + +#ifndef BT_COMPOUND_COMPOUND_COLLISION_ALGORITHM_H +#define BT_COMPOUND_COMPOUND_COLLISION_ALGORITHM_H + +#include "btCompoundCollisionAlgorithm.h" + +#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +#include "BulletCollision/BroadphaseCollision/btDispatcher.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" + +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +class btDispatcher; +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +#include "LinearMath/btAlignedObjectArray.h" +#include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.h" +class btDispatcher; +class btCollisionObject; + +class btCollisionShape; + +extern btShapePairCallback gCompoundCompoundChildShapePairCallback; + +/// btCompoundCompoundCollisionAlgorithm supports collision between two btCompoundCollisionShape shapes +class btCompoundCompoundCollisionAlgorithm : public btCompoundCollisionAlgorithm +{ + class btHashedSimplePairCache* m_childCollisionAlgorithmCache; + btSimplePairArray m_removePairs; + + int m_compoundShapeRevision0; //to keep track of changes, so that childAlgorithm array can be updated + int m_compoundShapeRevision1; + + void removeChildAlgorithms(); + + // void preallocateChildAlgorithms(const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap); + +public: + btCompoundCompoundCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped); + + virtual ~btCompoundCompoundCollisionAlgorithm(); + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual void getAllContactManifolds(btManifoldArray& manifoldArray); + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btCompoundCompoundCollisionAlgorithm)); + return new (mem) btCompoundCompoundCollisionAlgorithm(ci, body0Wrap, body1Wrap, false); + } + }; + + struct SwappedCreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btCompoundCompoundCollisionAlgorithm)); + return new (mem) btCompoundCompoundCollisionAlgorithm(ci, body0Wrap, body1Wrap, true); + } + }; +}; + +#endif //BT_COMPOUND_COMPOUND_COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h.i new file mode 100644 index 00000000..d0a2cc87 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp new file mode 100644 index 00000000..f9dfc0a3 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp @@ -0,0 +1,211 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btConvex2dConvex2dAlgorithm.h" + +//#include +#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "BulletCollision/CollisionShapes/btCapsuleShape.h" + +#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/CollisionShapes/btBoxShape.h" +#include "BulletCollision/CollisionDispatch/btManifoldResult.h" + +#include "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h" +#include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h" +#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h" + +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" + +#include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h" + +#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +btConvex2dConvex2dAlgorithm::CreateFunc::CreateFunc(btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver) +{ + m_simplexSolver = simplexSolver; + m_pdSolver = pdSolver; +} + +btConvex2dConvex2dAlgorithm::CreateFunc::~CreateFunc() +{ +} + +btConvex2dConvex2dAlgorithm::btConvex2dConvex2dAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver, int /* numPerturbationIterations */, int /* minimumPointsPerturbationThreshold */) + : btActivatingCollisionAlgorithm(ci, body0Wrap, body1Wrap), + m_simplexSolver(simplexSolver), + m_pdSolver(pdSolver), + m_ownManifold(false), + m_manifoldPtr(mf), + m_lowLevelOfDetail(false) +{ + (void)body0Wrap; + (void)body1Wrap; +} + +btConvex2dConvex2dAlgorithm::~btConvex2dConvex2dAlgorithm() +{ + if (m_ownManifold) + { + if (m_manifoldPtr) + m_dispatcher->releaseManifold(m_manifoldPtr); + } +} + +void btConvex2dConvex2dAlgorithm ::setLowLevelOfDetail(bool useLowLevel) +{ + m_lowLevelOfDetail = useLowLevel; +} + +extern btScalar gContactBreakingThreshold; + +// +// Convex-Convex collision algorithm +// +void btConvex2dConvex2dAlgorithm ::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + if (!m_manifoldPtr) + { + //swapped? + m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject()); + m_ownManifold = true; + } + resultOut->setPersistentManifold(m_manifoldPtr); + + //comment-out next line to test multi-contact generation + //resultOut->getPersistentManifold()->clearManifold(); + + const btConvexShape* min0 = static_cast(body0Wrap->getCollisionShape()); + const btConvexShape* min1 = static_cast(body1Wrap->getCollisionShape()); + + btVector3 normalOnB; + btVector3 pointOnBWorld; + + { + btGjkPairDetector::ClosestPointInput input; + + btGjkPairDetector gjkPairDetector(min0, min1, m_simplexSolver, m_pdSolver); + //TODO: if (dispatchInfo.m_useContinuous) + gjkPairDetector.setMinkowskiA(min0); + gjkPairDetector.setMinkowskiB(min1); + + { + input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactBreakingThreshold(); + input.m_maximumDistanceSquared *= input.m_maximumDistanceSquared; + } + + input.m_transformA = body0Wrap->getWorldTransform(); + input.m_transformB = body1Wrap->getWorldTransform(); + + gjkPairDetector.getClosestPoints(input, *resultOut, dispatchInfo.m_debugDraw); + + btVector3 v0, v1; + btVector3 sepNormalWorldSpace; + } + + if (m_ownManifold) + { + resultOut->refreshContactPoints(); + } +} + +btScalar btConvex2dConvex2dAlgorithm::calculateTimeOfImpact(btCollisionObject* col0, btCollisionObject* col1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + (void)resultOut; + (void)dispatchInfo; + ///Rather then checking ALL pairs, only calculate TOI when motion exceeds threshold + + ///Linear motion for one of objects needs to exceed m_ccdSquareMotionThreshold + ///col0->m_worldTransform, + btScalar resultFraction = btScalar(1.); + + btScalar squareMot0 = (col0->getInterpolationWorldTransform().getOrigin() - col0->getWorldTransform().getOrigin()).length2(); + btScalar squareMot1 = (col1->getInterpolationWorldTransform().getOrigin() - col1->getWorldTransform().getOrigin()).length2(); + + if (squareMot0 < col0->getCcdSquareMotionThreshold() && + squareMot1 < col1->getCcdSquareMotionThreshold()) + return resultFraction; + + //An adhoc way of testing the Continuous Collision Detection algorithms + //One object is approximated as a sphere, to simplify things + //Starting in penetration should report no time of impact + //For proper CCD, better accuracy and handling of 'allowed' penetration should be added + //also the mainloop of the physics should have a kind of toi queue (something like Brian Mirtich's application of Timewarp for Rigidbodies) + + /// Convex0 against sphere for Convex1 + { + btConvexShape* convex0 = static_cast(col0->getCollisionShape()); + + btSphereShape sphere1(col1->getCcdSweptSphereRadius()); //todo: allow non-zero sphere sizes, for better approximation + btConvexCast::CastResult result; + btVoronoiSimplexSolver voronoiSimplex; + //SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex); + ///Simplification, one object is simplified as a sphere + btGjkConvexCast ccd1(convex0, &sphere1, &voronoiSimplex); + //ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0); + if (ccd1.calcTimeOfImpact(col0->getWorldTransform(), col0->getInterpolationWorldTransform(), + col1->getWorldTransform(), col1->getInterpolationWorldTransform(), result)) + { + //store result.m_fraction in both bodies + + if (col0->getHitFraction() > result.m_fraction) + col0->setHitFraction(result.m_fraction); + + if (col1->getHitFraction() > result.m_fraction) + col1->setHitFraction(result.m_fraction); + + if (resultFraction > result.m_fraction) + resultFraction = result.m_fraction; + } + } + + /// Sphere (for convex0) against Convex1 + { + btConvexShape* convex1 = static_cast(col1->getCollisionShape()); + + btSphereShape sphere0(col0->getCcdSweptSphereRadius()); //todo: allow non-zero sphere sizes, for better approximation + btConvexCast::CastResult result; + btVoronoiSimplexSolver voronoiSimplex; + //SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex); + ///Simplification, one object is simplified as a sphere + btGjkConvexCast ccd1(&sphere0, convex1, &voronoiSimplex); + //ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0); + if (ccd1.calcTimeOfImpact(col0->getWorldTransform(), col0->getInterpolationWorldTransform(), + col1->getWorldTransform(), col1->getInterpolationWorldTransform(), result)) + { + //store result.m_fraction in both bodies + + if (col0->getHitFraction() > result.m_fraction) + col0->setHitFraction(result.m_fraction); + + if (col1->getHitFraction() > result.m_fraction) + col1->setHitFraction(result.m_fraction); + + if (resultFraction > result.m_fraction) + resultFraction = result.m_fraction; + } + } + + return resultFraction; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp.i new file mode 100644 index 00000000..7d3c6cac --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h new file mode 100644 index 00000000..e6a2504a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h @@ -0,0 +1,83 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H +#define BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H + +#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" +#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUtil + +class btConvexPenetrationDepthSolver; + +///The convex2dConvex2dAlgorithm collision algorithm support 2d collision detection for btConvex2dShape +///Currently it requires the btMinkowskiPenetrationDepthSolver, it has support for 2d penetration depth computation +class btConvex2dConvex2dAlgorithm : public btActivatingCollisionAlgorithm +{ + btSimplexSolverInterface* m_simplexSolver; + btConvexPenetrationDepthSolver* m_pdSolver; + + bool m_ownManifold; + btPersistentManifold* m_manifoldPtr; + bool m_lowLevelOfDetail; + +public: + btConvex2dConvex2dAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold); + + virtual ~btConvex2dConvex2dAlgorithm(); + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual void getAllContactManifolds(btManifoldArray& manifoldArray) + { + ///should we use m_ownManifold to avoid adding duplicates? + if (m_manifoldPtr && m_ownManifold) + manifoldArray.push_back(m_manifoldPtr); + } + + void setLowLevelOfDetail(bool useLowLevel); + + const btPersistentManifold* getManifold() + { + return m_manifoldPtr; + } + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + btConvexPenetrationDepthSolver* m_pdSolver; + btSimplexSolverInterface* m_simplexSolver; + int m_numPerturbationIterations; + int m_minimumPointsPerturbationThreshold; + + CreateFunc(btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver); + + virtual ~CreateFunc(); + + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvex2dConvex2dAlgorithm)); + return new (mem) btConvex2dConvex2dAlgorithm(ci.m_manifold, ci, body0Wrap, body1Wrap, m_simplexSolver, m_pdSolver, m_numPerturbationIterations, m_minimumPointsPerturbationThreshold); + } + }; +}; + +#endif //BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h.i new file mode 100644 index 00000000..3fb3b7fc --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp new file mode 100644 index 00000000..1e74028e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp @@ -0,0 +1,416 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btConvexConcaveCollisionAlgorithm.h" +#include "LinearMath/btQuickprof.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionShapes/btMultiSphereShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/CollisionShapes/btConcaveShape.h" +#include "BulletCollision/CollisionDispatch/btManifoldResult.h" +#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h" +#include "BulletCollision/CollisionShapes/btTriangleShape.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" +#include "LinearMath/btIDebugDraw.h" +#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" +#include "BulletCollision/CollisionShapes/btSdfCollisionShape.h" + +btConvexConcaveCollisionAlgorithm::btConvexConcaveCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped) + : btActivatingCollisionAlgorithm(ci, body0Wrap, body1Wrap), + m_btConvexTriangleCallback(ci.m_dispatcher1, body0Wrap, body1Wrap, isSwapped), + m_isSwapped(isSwapped) +{ +} + +btConvexConcaveCollisionAlgorithm::~btConvexConcaveCollisionAlgorithm() +{ +} + +void btConvexConcaveCollisionAlgorithm::getAllContactManifolds(btManifoldArray& manifoldArray) +{ + if (m_btConvexTriangleCallback.m_manifoldPtr) + { + manifoldArray.push_back(m_btConvexTriangleCallback.m_manifoldPtr); + } +} + +btConvexTriangleCallback::btConvexTriangleCallback(btDispatcher* dispatcher, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped) : m_dispatcher(dispatcher), + m_dispatchInfoPtr(0) +{ + m_convexBodyWrap = isSwapped ? body1Wrap : body0Wrap; + m_triBodyWrap = isSwapped ? body0Wrap : body1Wrap; + + // + // create the manifold from the dispatcher 'manifold pool' + // + m_manifoldPtr = m_dispatcher->getNewManifold(m_convexBodyWrap->getCollisionObject(), m_triBodyWrap->getCollisionObject()); + + clearCache(); +} + +btConvexTriangleCallback::~btConvexTriangleCallback() +{ + clearCache(); + m_dispatcher->releaseManifold(m_manifoldPtr); +} + +void btConvexTriangleCallback::clearCache() +{ + m_dispatcher->clearManifold(m_manifoldPtr); +} + +void btConvexTriangleCallback::processTriangle(btVector3* triangle, int partId, int triangleIndex) +{ +//\1("btConvexTriangleCallback::processTriangle"); + + if (!TestTriangleAgainstAabb2(triangle, m_aabbMin, m_aabbMax)) + { + return; + } + + //just for debugging purposes + //printf("triangle %d",m_triangleCount++); + + btCollisionAlgorithmConstructionInfo ci; + ci.m_dispatcher1 = m_dispatcher; + +#if 0 + + ///debug drawing of the overlapping triangles + if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && (m_dispatchInfoPtr->m_debugDraw->getDebugMode() &btIDebugDraw::DBG_DrawWireframe )) + { + const btCollisionObject* ob = const_cast(m_triBodyWrap->getCollisionObject()); + btVector3 color(1,1,0); + btTransform& tr = ob->getWorldTransform(); + m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(triangle[1]),color); + m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(triangle[2]),color); + m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(triangle[0]),color); + } +#endif + + if (m_convexBodyWrap->getCollisionShape()->isConvex()) + { +#ifdef BT_ENABLE_CONVEX_CONCAVE_EARLY_OUT + //todo: check this issue https://github.com/bulletphysics/bullet3/issues/4263 + //an early out optimisation if the object is separated from the triangle + //projected on the triangle normal) + { + const btVector3 v0 = m_triBodyWrap->getWorldTransform()*triangle[0]; + const btVector3 v1 = m_triBodyWrap->getWorldTransform()*triangle[1]; + const btVector3 v2 = m_triBodyWrap->getWorldTransform()*triangle[2]; + + btVector3 triangle_normal_world = ( v1 - v0).cross(v2 - v0); + triangle_normal_world.normalize(); + + btConvexShape* convex = (btConvexShape*)m_convexBodyWrap->getCollisionShape(); + + btVector3 localPt = convex->localGetSupportingVertex(m_convexBodyWrap->getWorldTransform().getBasis().inverse()*triangle_normal_world); + btVector3 worldPt = m_convexBodyWrap->getWorldTransform()*localPt; + //now check if this is fully on one side of the triangle + btScalar proj_distPt = triangle_normal_world.dot(worldPt); + btScalar proj_distTr = triangle_normal_world.dot(v0); + btScalar contact_threshold = m_manifoldPtr->getContactBreakingThreshold()+ m_resultOut->m_closestPointDistanceThreshold; + btScalar dist = proj_distTr - proj_distPt; + if (dist > contact_threshold) + return; + + //also check the other side of the triangle + triangle_normal_world*=-1; + + localPt = convex->localGetSupportingVertex(m_convexBodyWrap->getWorldTransform().getBasis().inverse()*triangle_normal_world); + worldPt = m_convexBodyWrap->getWorldTransform()*localPt; + //now check if this is fully on one side of the triangle + proj_distPt = triangle_normal_world.dot(worldPt); + proj_distTr = triangle_normal_world.dot(v0); + + dist = proj_distTr - proj_distPt; + if (dist > contact_threshold) + return; + } +#endif //BT_ENABLE_CONVEX_CONCAVE_EARLY_OUT + + btTriangleShape tm(triangle[0], triangle[1], triangle[2]); + tm.setMargin(m_collisionMarginTriangle); + + btCollisionObjectWrapper triObWrap(m_triBodyWrap, &tm, m_triBodyWrap->getCollisionObject(), m_triBodyWrap->getWorldTransform(), partId, triangleIndex); //correct transform? + btCollisionAlgorithm* colAlgo = 0; + + if (m_resultOut->m_closestPointDistanceThreshold > 0) + { + colAlgo = ci.m_dispatcher1->findAlgorithm(m_convexBodyWrap, &triObWrap, 0, BT_CLOSEST_POINT_ALGORITHMS); + } + else + { + colAlgo = ci.m_dispatcher1->findAlgorithm(m_convexBodyWrap, &triObWrap, m_manifoldPtr, BT_CONTACT_POINT_ALGORITHMS); + } + const btCollisionObjectWrapper* tmpWrap = 0; + + if (m_resultOut->getBody0Internal() == m_triBodyWrap->getCollisionObject()) + { + tmpWrap = m_resultOut->getBody0Wrap(); + m_resultOut->setBody0Wrap(&triObWrap); + m_resultOut->setShapeIdentifiersA(partId, triangleIndex); + } + else + { + tmpWrap = m_resultOut->getBody1Wrap(); + m_resultOut->setBody1Wrap(&triObWrap); + m_resultOut->setShapeIdentifiersB(partId, triangleIndex); + } + + { +//\1("processCollision (GJK?)"); + colAlgo->processCollision(m_convexBodyWrap, &triObWrap, *m_dispatchInfoPtr, m_resultOut); + } + + if (m_resultOut->getBody0Internal() == m_triBodyWrap->getCollisionObject()) + { + m_resultOut->setBody0Wrap(tmpWrap); + } + else + { + m_resultOut->setBody1Wrap(tmpWrap); + } + + colAlgo->~btCollisionAlgorithm(); + ci.m_dispatcher1->freeCollisionAlgorithm(colAlgo); + } +} + +void btConvexTriangleCallback::setTimeStepAndCounters(btScalar collisionMarginTriangle, const btDispatcherInfo& dispatchInfo, const btCollisionObjectWrapper* convexBodyWrap, const btCollisionObjectWrapper* triBodyWrap, btManifoldResult* resultOut) +{ + m_convexBodyWrap = convexBodyWrap; + m_triBodyWrap = triBodyWrap; + + m_dispatchInfoPtr = &dispatchInfo; + m_collisionMarginTriangle = collisionMarginTriangle; + m_resultOut = resultOut; + + //recalc aabbs + btTransform convexInTriangleSpace; + convexInTriangleSpace = m_triBodyWrap->getWorldTransform().inverse() * m_convexBodyWrap->getWorldTransform(); + const btCollisionShape* convexShape = static_cast(m_convexBodyWrap->getCollisionShape()); + //CollisionShape* triangleShape = static_cast(triBody->m_collisionShape); + convexShape->getAabb(convexInTriangleSpace, m_aabbMin, m_aabbMax); + btScalar extraMargin = collisionMarginTriangle + resultOut->m_closestPointDistanceThreshold; + + btVector3 extra(extraMargin, extraMargin, extraMargin); + + m_aabbMax += extra; + m_aabbMin -= extra; +} + +void btConvexConcaveCollisionAlgorithm::clearCache() +{ + m_btConvexTriangleCallback.clearCache(); +} + +void btConvexConcaveCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ +//\1("btConvexConcaveCollisionAlgorithm::processCollision"); + + const btCollisionObjectWrapper* convexBodyWrap = m_isSwapped ? body1Wrap : body0Wrap; + const btCollisionObjectWrapper* triBodyWrap = m_isSwapped ? body0Wrap : body1Wrap; + + if (triBodyWrap->getCollisionShape()->isConcave()) + { + if (triBodyWrap->getCollisionShape()->getShapeType() == SDF_SHAPE_PROXYTYPE) + { + btSdfCollisionShape* sdfShape = (btSdfCollisionShape*)triBodyWrap->getCollisionShape(); + if (convexBodyWrap->getCollisionShape()->isConvex()) + { + btConvexShape* convex = (btConvexShape*)convexBodyWrap->getCollisionShape(); + btAlignedObjectArray queryVertices; + + if (convex->isPolyhedral()) + { + btPolyhedralConvexShape* poly = (btPolyhedralConvexShape*)convex; + for (int v = 0; v < poly->getNumVertices(); v++) + { + btVector3 vtx; + poly->getVertex(v, vtx); + queryVertices.push_back(vtx); + } + } + btScalar maxDist = SIMD_EPSILON; + + if (convex->getShapeType() == SPHERE_SHAPE_PROXYTYPE) + { + queryVertices.push_back(btVector3(0, 0, 0)); + btSphereShape* sphere = (btSphereShape*)convex; + maxDist = sphere->getRadius() + SIMD_EPSILON; + } + if (queryVertices.size()) + { + resultOut->setPersistentManifold(m_btConvexTriangleCallback.m_manifoldPtr); + //m_btConvexTriangleCallback.m_manifoldPtr->clearManifold(); + + btPolyhedralConvexShape* poly = (btPolyhedralConvexShape*)convex; + for (int v = 0; v < queryVertices.size(); v++) + { + const btVector3& vtx = queryVertices[v]; + btVector3 vtxWorldSpace = convexBodyWrap->getWorldTransform() * vtx; + btVector3 vtxInSdf = triBodyWrap->getWorldTransform().invXform(vtxWorldSpace); + + btVector3 normalLocal; + btScalar dist; + if (sdfShape->queryPoint(vtxInSdf, dist, normalLocal)) + { + if (dist <= maxDist) + { + normalLocal.safeNormalize(); + btVector3 normal = triBodyWrap->getWorldTransform().getBasis() * normalLocal; + + if (convex->getShapeType() == SPHERE_SHAPE_PROXYTYPE) + { + btSphereShape* sphere = (btSphereShape*)convex; + dist -= sphere->getRadius(); + vtxWorldSpace -= sphere->getRadius() * normal; + } + resultOut->addContactPoint(normal, vtxWorldSpace - normal * dist, dist); + } + } + } + resultOut->refreshContactPoints(); + } + } + } + else + { + const btConcaveShape* concaveShape = static_cast(triBodyWrap->getCollisionShape()); + + if (convexBodyWrap->getCollisionShape()->isConvex()) + { + btScalar collisionMarginTriangle = concaveShape->getMargin(); + + resultOut->setPersistentManifold(m_btConvexTriangleCallback.m_manifoldPtr); + m_btConvexTriangleCallback.setTimeStepAndCounters(collisionMarginTriangle, dispatchInfo, convexBodyWrap, triBodyWrap, resultOut); + + m_btConvexTriangleCallback.m_manifoldPtr->setBodies(convexBodyWrap->getCollisionObject(), triBodyWrap->getCollisionObject()); + + concaveShape->processAllTriangles(&m_btConvexTriangleCallback, m_btConvexTriangleCallback.getAabbMin(), m_btConvexTriangleCallback.getAabbMax()); + + resultOut->refreshContactPoints(); + + m_btConvexTriangleCallback.clearWrapperData(); + } + } + } +} + +btScalar btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + (void)resultOut; + (void)dispatchInfo; + btCollisionObject* convexbody = m_isSwapped ? body1 : body0; + btCollisionObject* triBody = m_isSwapped ? body0 : body1; + + //quick approximation using raycast, todo: hook up to the continuous collision detection (one of the btConvexCast) + + //only perform CCD above a certain threshold, this prevents blocking on the long run + //because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame... + btScalar squareMot0 = (convexbody->getInterpolationWorldTransform().getOrigin() - convexbody->getWorldTransform().getOrigin()).length2(); + if (squareMot0 < convexbody->getCcdSquareMotionThreshold()) + { + return btScalar(1.); + } + + //const btVector3& from = convexbody->m_worldTransform.getOrigin(); + //btVector3 to = convexbody->m_interpolationWorldTransform.getOrigin(); + //todo: only do if the motion exceeds the 'radius' + + btTransform triInv = triBody->getWorldTransform().inverse(); + btTransform convexFromLocal = triInv * convexbody->getWorldTransform(); + btTransform convexToLocal = triInv * convexbody->getInterpolationWorldTransform(); + + struct LocalTriangleSphereCastCallback : public btTriangleCallback + { + btTransform m_ccdSphereFromTrans; + btTransform m_ccdSphereToTrans; + btTransform m_meshTransform; + + btScalar m_ccdSphereRadius; + btScalar m_hitFraction; + + LocalTriangleSphereCastCallback(const btTransform& from, const btTransform& to, btScalar ccdSphereRadius, btScalar hitFraction) + : m_ccdSphereFromTrans(from), + m_ccdSphereToTrans(to), + m_ccdSphereRadius(ccdSphereRadius), + m_hitFraction(hitFraction) + { + } + + virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex) + { +//\1("processTriangle"); + (void)partId; + (void)triangleIndex; + //do a swept sphere for now + btTransform ident; + ident.setIdentity(); + btConvexCast::CastResult castResult; + castResult.m_fraction = m_hitFraction; + btSphereShape pointShape(m_ccdSphereRadius); + btTriangleShape triShape(triangle[0], triangle[1], triangle[2]); + btVoronoiSimplexSolver simplexSolver; + btSubsimplexConvexCast convexCaster(&pointShape, &triShape, &simplexSolver); + //GjkConvexCast convexCaster(&pointShape,convexShape,&simplexSolver); + //ContinuousConvexCollision convexCaster(&pointShape,convexShape,&simplexSolver,0); + //local space? + + if (convexCaster.calcTimeOfImpact(m_ccdSphereFromTrans, m_ccdSphereToTrans, + ident, ident, castResult)) + { + if (m_hitFraction > castResult.m_fraction) + m_hitFraction = castResult.m_fraction; + } + } + }; + + if (triBody->getCollisionShape()->isConcave()) + { + btVector3 rayAabbMin = convexFromLocal.getOrigin(); + rayAabbMin.setMin(convexToLocal.getOrigin()); + btVector3 rayAabbMax = convexFromLocal.getOrigin(); + rayAabbMax.setMax(convexToLocal.getOrigin()); + btScalar ccdRadius0 = convexbody->getCcdSweptSphereRadius(); + rayAabbMin -= btVector3(ccdRadius0, ccdRadius0, ccdRadius0); + rayAabbMax += btVector3(ccdRadius0, ccdRadius0, ccdRadius0); + + btScalar curHitFraction = btScalar(1.); //is this available? + LocalTriangleSphereCastCallback raycastCallback(convexFromLocal, convexToLocal, + convexbody->getCcdSweptSphereRadius(), curHitFraction); + + raycastCallback.m_hitFraction = convexbody->getHitFraction(); + + btCollisionObject* concavebody = triBody; + + btConcaveShape* triangleMesh = (btConcaveShape*)concavebody->getCollisionShape(); + + if (triangleMesh) + { + triangleMesh->processAllTriangles(&raycastCallback, rayAabbMin, rayAabbMax); + } + + if (raycastCallback.m_hitFraction < convexbody->getHitFraction()) + { + convexbody->setHitFraction(raycastCallback.m_hitFraction); + return raycastCallback.m_hitFraction; + } + } + + return btScalar(1.); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..ea441e0f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h new file mode 100644 index 00000000..8d86dafd --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h @@ -0,0 +1,117 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H +#define BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H + +#include "btActivatingCollisionAlgorithm.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 "btCollisionCreateFunc.h" + +///For each triangle in the concave mesh that overlaps with the AABB of a convex (m_convexProxy), processTriangle is called. +ATTRIBUTE_ALIGNED16(class) +btConvexTriangleCallback : public btTriangleCallback +{ + btVector3 m_aabbMin; + btVector3 m_aabbMax; + + const btCollisionObjectWrapper* m_convexBodyWrap; + const btCollisionObjectWrapper* m_triBodyWrap; + + btManifoldResult* m_resultOut; + btDispatcher* m_dispatcher; + const btDispatcherInfo* m_dispatchInfoPtr; + btScalar m_collisionMarginTriangle; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + int m_triangleCount; + + btPersistentManifold* m_manifoldPtr; + + btConvexTriangleCallback(btDispatcher * dispatcher, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped); + + void setTimeStepAndCounters(btScalar collisionMarginTriangle, const btDispatcherInfo& dispatchInfo, const btCollisionObjectWrapper* convexBodyWrap, const btCollisionObjectWrapper* triBodyWrap, btManifoldResult* resultOut); + + void clearWrapperData() + { + m_convexBodyWrap = 0; + m_triBodyWrap = 0; + } + virtual ~btConvexTriangleCallback(); + + 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; + } +}; + +/// btConvexConcaveCollisionAlgorithm supports collision between convex shapes and (concave) trianges meshes. +ATTRIBUTE_ALIGNED16(class) +btConvexConcaveCollisionAlgorithm : public btActivatingCollisionAlgorithm +{ + btConvexTriangleCallback m_btConvexTriangleCallback; + + bool m_isSwapped; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btConvexConcaveCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped); + + virtual ~btConvexConcaveCollisionAlgorithm(); + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + btScalar calculateTimeOfImpact(btCollisionObject * body0, btCollisionObject * body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual void getAllContactManifolds(btManifoldArray & manifoldArray); + + void clearCache(); + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConcaveCollisionAlgorithm)); + return new (mem) btConvexConcaveCollisionAlgorithm(ci, body0Wrap, body1Wrap, false); + } + }; + + struct SwappedCreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConcaveCollisionAlgorithm)); + return new (mem) btConvexConcaveCollisionAlgorithm(ci, body0Wrap, body1Wrap, true); + } + }; +}; + +#endif //BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h.i new file mode 100644 index 00000000..5fbda8fa --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp new file mode 100644 index 00000000..8031c950 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp @@ -0,0 +1,873 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///Specialized capsule-capsule collision algorithm has been added for Bullet 2.75 release to increase ragdoll performance +///If you experience problems with capsule-capsule collision, try to define BT_DISABLE_CAPSULE_CAPSULE_COLLIDER and report it in the Bullet forums +///with reproduction case +//#define BT_DISABLE_CAPSULE_CAPSULE_COLLIDER 1 +//#define ZERO_MARGIN + +#include "btConvexConvexAlgorithm.h" + +//#include +#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "BulletCollision/CollisionShapes/btCapsuleShape.h" +#include "BulletCollision/CollisionShapes/btTriangleShape.h" +#include "BulletCollision/CollisionShapes/btConvexPolyhedron.h" + +#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/CollisionShapes/btBoxShape.h" +#include "BulletCollision/CollisionDispatch/btManifoldResult.h" + +#include "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h" +#include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h" +#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h" + +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" + +#include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h" + +#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h" +#include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +/////////// + +static SIMD_FORCE_INLINE void segmentsClosestPoints( + btVector3& ptsVector, + btVector3& offsetA, + btVector3& offsetB, + btScalar& tA, btScalar& tB, + const btVector3& translation, + const btVector3& dirA, btScalar hlenA, + const btVector3& dirB, btScalar hlenB) +{ + // compute the parameters of the closest points on each line segment + + btScalar dirA_dot_dirB = btDot(dirA, dirB); + btScalar dirA_dot_trans = btDot(dirA, translation); + btScalar dirB_dot_trans = btDot(dirB, translation); + + btScalar denom = 1.0f - dirA_dot_dirB * dirA_dot_dirB; + + if (denom == 0.0f) + { + tA = 0.0f; + } + else + { + tA = (dirA_dot_trans - dirB_dot_trans * dirA_dot_dirB) / denom; + if (tA < -hlenA) + tA = -hlenA; + else if (tA > hlenA) + tA = hlenA; + } + + tB = tA * dirA_dot_dirB - dirB_dot_trans; + + if (tB < -hlenB) + { + tB = -hlenB; + tA = tB * dirA_dot_dirB + dirA_dot_trans; + + if (tA < -hlenA) + tA = -hlenA; + else if (tA > hlenA) + tA = hlenA; + } + else if (tB > hlenB) + { + tB = hlenB; + tA = tB * dirA_dot_dirB + dirA_dot_trans; + + if (tA < -hlenA) + tA = -hlenA; + else if (tA > hlenA) + tA = hlenA; + } + + // compute the closest points relative to segment centers. + + offsetA = dirA * tA; + offsetB = dirB * tB; + + ptsVector = translation - offsetA + offsetB; +} + +static SIMD_FORCE_INLINE btScalar capsuleCapsuleDistance( + btVector3& normalOnB, + btVector3& pointOnB, + btScalar capsuleLengthA, + btScalar capsuleRadiusA, + btScalar capsuleLengthB, + btScalar capsuleRadiusB, + int capsuleAxisA, + int capsuleAxisB, + const btTransform& transformA, + const btTransform& transformB, + btScalar distanceThreshold) +{ + btVector3 directionA = transformA.getBasis().getColumn(capsuleAxisA); + btVector3 translationA = transformA.getOrigin(); + btVector3 directionB = transformB.getBasis().getColumn(capsuleAxisB); + btVector3 translationB = transformB.getOrigin(); + + // translation between centers + + btVector3 translation = translationB - translationA; + + // compute the closest points of the capsule line segments + + btVector3 ptsVector; // the vector between the closest points + + btVector3 offsetA, offsetB; // offsets from segment centers to their closest points + btScalar tA, tB; // parameters on line segment + + segmentsClosestPoints(ptsVector, offsetA, offsetB, tA, tB, translation, + directionA, capsuleLengthA, directionB, capsuleLengthB); + + btScalar distance = ptsVector.length() - capsuleRadiusA - capsuleRadiusB; + + if (distance > distanceThreshold) + return distance; + + btScalar lenSqr = ptsVector.length2(); + if (lenSqr <= (SIMD_EPSILON * SIMD_EPSILON)) + { + //degenerate case where 2 capsules are likely at the same location: take a vector tangential to 'directionA' + btVector3 q; + btPlaneSpace1(directionA, normalOnB, q); + } + else + { + // compute the contact normal + normalOnB = ptsVector * -btRecipSqrt(lenSqr); + } + pointOnB = transformB.getOrigin() + offsetB + normalOnB * capsuleRadiusB; + + return distance; +} + +////////// + +btConvexConvexAlgorithm::CreateFunc::CreateFunc(btConvexPenetrationDepthSolver* pdSolver) +{ + m_numPerturbationIterations = 0; + m_minimumPointsPerturbationThreshold = 3; + m_pdSolver = pdSolver; +} + +btConvexConvexAlgorithm::CreateFunc::~CreateFunc() +{ +} + +btConvexConvexAlgorithm::btConvexConvexAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btConvexPenetrationDepthSolver* pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold) + : btActivatingCollisionAlgorithm(ci, body0Wrap, body1Wrap), + m_pdSolver(pdSolver), + m_ownManifold(false), + m_manifoldPtr(mf), + m_lowLevelOfDetail(false), +#ifdef USE_SEPDISTANCE_UTIL2 + m_sepDistance((static_cast(body0->getCollisionShape()))->getAngularMotionDisc(), + (static_cast(body1->getCollisionShape()))->getAngularMotionDisc()), +#endif + m_numPerturbationIterations(numPerturbationIterations), + m_minimumPointsPerturbationThreshold(minimumPointsPerturbationThreshold) +{ + (void)body0Wrap; + (void)body1Wrap; +} + +btConvexConvexAlgorithm::~btConvexConvexAlgorithm() +{ + if (m_ownManifold) + { + if (m_manifoldPtr) + m_dispatcher->releaseManifold(m_manifoldPtr); + } +} + +void btConvexConvexAlgorithm ::setLowLevelOfDetail(bool useLowLevel) +{ + m_lowLevelOfDetail = useLowLevel; +} + +struct btPerturbedContactResult : public btManifoldResult +{ + btManifoldResult* m_originalManifoldResult; + btTransform m_transformA; + btTransform m_transformB; + btTransform m_unPerturbedTransform; + bool m_perturbA; + btIDebugDraw* m_debugDrawer; + + btPerturbedContactResult(btManifoldResult* originalResult, const btTransform& transformA, const btTransform& transformB, const btTransform& unPerturbedTransform, bool perturbA, btIDebugDraw* debugDrawer) + : m_originalManifoldResult(originalResult), + m_transformA(transformA), + m_transformB(transformB), + m_unPerturbedTransform(unPerturbedTransform), + m_perturbA(perturbA), + m_debugDrawer(debugDrawer) + { + } + virtual ~btPerturbedContactResult() + { + } + + virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar orgDepth) + { + btVector3 endPt, startPt; + btScalar newDepth; + btVector3 newNormal; + + if (m_perturbA) + { + btVector3 endPtOrg = pointInWorld + normalOnBInWorld * orgDepth; + endPt = (m_unPerturbedTransform * m_transformA.inverse())(endPtOrg); + newDepth = (endPt - pointInWorld).dot(normalOnBInWorld); + startPt = endPt - normalOnBInWorld * newDepth; + } + else + { + endPt = pointInWorld + normalOnBInWorld * orgDepth; + startPt = (m_unPerturbedTransform * m_transformB.inverse())(pointInWorld); + newDepth = (endPt - startPt).dot(normalOnBInWorld); + } + +//#define DEBUG_CONTACTS 1 +#ifdef DEBUG_CONTACTS + m_debugDrawer->drawLine(startPt, endPt, btVector3(1, 0, 0)); + m_debugDrawer->drawSphere(startPt, 0.05, btVector3(0, 1, 0)); + m_debugDrawer->drawSphere(endPt, 0.05, btVector3(0, 0, 1)); +#endif //DEBUG_CONTACTS + + m_originalManifoldResult->addContactPoint(normalOnBInWorld, startPt, newDepth); + } +}; + +extern btScalar gContactBreakingThreshold; + +// +// Convex-Convex collision algorithm +// +void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + if (!m_manifoldPtr) + { + //swapped? + m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject()); + m_ownManifold = true; + } + resultOut->setPersistentManifold(m_manifoldPtr); + + //comment-out next line to test multi-contact generation + //resultOut->getPersistentManifold()->clearManifold(); + + const btConvexShape* min0 = static_cast(body0Wrap->getCollisionShape()); + const btConvexShape* min1 = static_cast(body1Wrap->getCollisionShape()); + + btVector3 normalOnB; + btVector3 pointOnBWorld; +#ifndef BT_DISABLE_CAPSULE_CAPSULE_COLLIDER + if ((min0->getShapeType() == CAPSULE_SHAPE_PROXYTYPE) && (min1->getShapeType() == CAPSULE_SHAPE_PROXYTYPE)) + { + //m_manifoldPtr->clearManifold(); + + btCapsuleShape* capsuleA = (btCapsuleShape*)min0; + btCapsuleShape* capsuleB = (btCapsuleShape*)min1; + + btScalar threshold = m_manifoldPtr->getContactBreakingThreshold()+ resultOut->m_closestPointDistanceThreshold; + + btScalar dist = capsuleCapsuleDistance(normalOnB, pointOnBWorld, capsuleA->getHalfHeight(), capsuleA->getRadius(), + capsuleB->getHalfHeight(), capsuleB->getRadius(), capsuleA->getUpAxis(), capsuleB->getUpAxis(), + body0Wrap->getWorldTransform(), body1Wrap->getWorldTransform(), threshold); + + if (dist < threshold) + { + btAssert(normalOnB.length2() >= (SIMD_EPSILON * SIMD_EPSILON)); + resultOut->addContactPoint(normalOnB, pointOnBWorld, dist); + } + resultOut->refreshContactPoints(); + return; + } + + if ((min0->getShapeType() == CAPSULE_SHAPE_PROXYTYPE) && (min1->getShapeType() == SPHERE_SHAPE_PROXYTYPE)) + { + //m_manifoldPtr->clearManifold(); + + btCapsuleShape* capsuleA = (btCapsuleShape*)min0; + btSphereShape* capsuleB = (btSphereShape*)min1; + + btScalar threshold = m_manifoldPtr->getContactBreakingThreshold()+ resultOut->m_closestPointDistanceThreshold; + + btScalar dist = capsuleCapsuleDistance(normalOnB, pointOnBWorld, capsuleA->getHalfHeight(), capsuleA->getRadius(), + 0., capsuleB->getRadius(), capsuleA->getUpAxis(), 1, + body0Wrap->getWorldTransform(), body1Wrap->getWorldTransform(), threshold); + + if (dist < threshold) + { + btAssert(normalOnB.length2() >= (SIMD_EPSILON * SIMD_EPSILON)); + resultOut->addContactPoint(normalOnB, pointOnBWorld, dist); + } + resultOut->refreshContactPoints(); + return; + } + + if ((min0->getShapeType() == SPHERE_SHAPE_PROXYTYPE) && (min1->getShapeType() == CAPSULE_SHAPE_PROXYTYPE)) + { + //m_manifoldPtr->clearManifold(); + + btSphereShape* capsuleA = (btSphereShape*)min0; + btCapsuleShape* capsuleB = (btCapsuleShape*)min1; + + btScalar threshold = m_manifoldPtr->getContactBreakingThreshold()+ resultOut->m_closestPointDistanceThreshold; + + btScalar dist = capsuleCapsuleDistance(normalOnB, pointOnBWorld, 0., capsuleA->getRadius(), + capsuleB->getHalfHeight(), capsuleB->getRadius(), 1, capsuleB->getUpAxis(), + body0Wrap->getWorldTransform(), body1Wrap->getWorldTransform(), threshold); + + if (dist < threshold) + { + btAssert(normalOnB.length2() >= (SIMD_EPSILON * SIMD_EPSILON)); + resultOut->addContactPoint(normalOnB, pointOnBWorld, dist); + } + resultOut->refreshContactPoints(); + return; + } +#endif //BT_DISABLE_CAPSULE_CAPSULE_COLLIDER + +#ifdef USE_SEPDISTANCE_UTIL2 + if (dispatchInfo.m_useConvexConservativeDistanceUtil) + { + m_sepDistance.updateSeparatingDistance(body0->getWorldTransform(), body1->getWorldTransform()); + } + + if (!dispatchInfo.m_useConvexConservativeDistanceUtil || m_sepDistance.getConservativeSeparatingDistance() <= 0.f) +#endif //USE_SEPDISTANCE_UTIL2 + + { + btGjkPairDetector::ClosestPointInput input; + btVoronoiSimplexSolver simplexSolver; + btGjkPairDetector gjkPairDetector(min0, min1, &simplexSolver, m_pdSolver); + //TODO: if (dispatchInfo.m_useContinuous) + gjkPairDetector.setMinkowskiA(min0); + gjkPairDetector.setMinkowskiB(min1); + +#ifdef USE_SEPDISTANCE_UTIL2 + if (dispatchInfo.m_useConvexConservativeDistanceUtil) + { + input.m_maximumDistanceSquared = BT_LARGE_FLOAT; + } + else +#endif //USE_SEPDISTANCE_UTIL2 + { + //if (dispatchInfo.m_convexMaxDistanceUseCPT) + //{ + // input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactProcessingThreshold(); + //} else + //{ + input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactBreakingThreshold() + resultOut->m_closestPointDistanceThreshold; + // } + + input.m_maximumDistanceSquared *= input.m_maximumDistanceSquared; + } + + input.m_transformA = body0Wrap->getWorldTransform(); + input.m_transformB = body1Wrap->getWorldTransform(); + +#ifdef USE_SEPDISTANCE_UTIL2 + btScalar sepDist = 0.f; + if (dispatchInfo.m_useConvexConservativeDistanceUtil) + { + sepDist = gjkPairDetector.getCachedSeparatingDistance(); + if (sepDist > SIMD_EPSILON) + { + sepDist += dispatchInfo.m_convexConservativeDistanceThreshold; + //now perturbe directions to get multiple contact points + } + } +#endif //USE_SEPDISTANCE_UTIL2 + + if (min0->isPolyhedral() && min1->isPolyhedral()) + { + struct btDummyResult : public btDiscreteCollisionDetectorInterface::Result + { + btVector3 m_normalOnBInWorld; + btVector3 m_pointInWorld; + btScalar m_depth; + bool m_hasContact; + + btDummyResult() + : m_hasContact(false) + { + } + + virtual void setShapeIdentifiersA(int partId0, int index0) {} + virtual void setShapeIdentifiersB(int partId1, int index1) {} + virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth) + { + m_hasContact = true; + m_normalOnBInWorld = normalOnBInWorld; + m_pointInWorld = pointInWorld; + m_depth = depth; + } + }; + + struct btWithoutMarginResult : public btDiscreteCollisionDetectorInterface::Result + { + btDiscreteCollisionDetectorInterface::Result* m_originalResult; + btVector3 m_reportedNormalOnWorld; + btScalar m_marginOnA; + btScalar m_marginOnB; + btScalar m_reportedDistance; + + bool m_foundResult; + btWithoutMarginResult(btDiscreteCollisionDetectorInterface::Result* result, btScalar marginOnA, btScalar marginOnB) + : m_originalResult(result), + m_marginOnA(marginOnA), + m_marginOnB(marginOnB), + m_foundResult(false) + { + } + + virtual void setShapeIdentifiersA(int partId0, int index0) {} + virtual void setShapeIdentifiersB(int partId1, int index1) {} + virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorldOrg, btScalar depthOrg) + { + m_reportedDistance = depthOrg; + m_reportedNormalOnWorld = normalOnBInWorld; + + btVector3 adjustedPointB = pointInWorldOrg - normalOnBInWorld * m_marginOnB; + m_reportedDistance = depthOrg + (m_marginOnA + m_marginOnB); + if (m_reportedDistance < 0.f) + { + m_foundResult = true; + } + m_originalResult->addContactPoint(normalOnBInWorld, adjustedPointB, m_reportedDistance); + } + }; + + btDummyResult dummy; + + ///btBoxShape is an exception: its vertices are created WITH margin so don't subtract it + + btScalar min0Margin = min0->getShapeType() == BOX_SHAPE_PROXYTYPE ? 0.f : min0->getMargin(); + btScalar min1Margin = min1->getShapeType() == BOX_SHAPE_PROXYTYPE ? 0.f : min1->getMargin(); + + btWithoutMarginResult withoutMargin(resultOut, min0Margin, min1Margin); + + btPolyhedralConvexShape* polyhedronA = (btPolyhedralConvexShape*)min0; + btPolyhedralConvexShape* polyhedronB = (btPolyhedralConvexShape*)min1; + if (polyhedronA->getConvexPolyhedron() && polyhedronB->getConvexPolyhedron()) + { + btScalar threshold = m_manifoldPtr->getContactBreakingThreshold()+ resultOut->m_closestPointDistanceThreshold; + + btScalar minDist = -1e30f; + btVector3 sepNormalWorldSpace; + bool foundSepAxis = true; + + if (dispatchInfo.m_enableSatConvex) + { + foundSepAxis = btPolyhedralContactClipping::findSeparatingAxis( + *polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(), + body0Wrap->getWorldTransform(), + body1Wrap->getWorldTransform(), + sepNormalWorldSpace, *resultOut); + } + else + { +#ifdef ZERO_MARGIN + gjkPairDetector.setIgnoreMargin(true); + gjkPairDetector.getClosestPoints(input, *resultOut, dispatchInfo.m_debugDraw); +#else + + gjkPairDetector.getClosestPoints(input, withoutMargin, dispatchInfo.m_debugDraw); + //gjkPairDetector.getClosestPoints(input,dummy,dispatchInfo.m_debugDraw); +#endif //ZERO_MARGIN + //btScalar l2 = gjkPairDetector.getCachedSeparatingAxis().length2(); + //if (l2>SIMD_EPSILON) + { + sepNormalWorldSpace = withoutMargin.m_reportedNormalOnWorld; //gjkPairDetector.getCachedSeparatingAxis()*(1.f/l2); + //minDist = -1e30f;//gjkPairDetector.getCachedSeparatingDistance(); + minDist = withoutMargin.m_reportedDistance; //gjkPairDetector.getCachedSeparatingDistance()+min0->getMargin()+min1->getMargin(); + +#ifdef ZERO_MARGIN + foundSepAxis = true; //gjkPairDetector.getCachedSeparatingDistance()<0.f; +#else + foundSepAxis = withoutMargin.m_foundResult && minDist < 0; //-(min0->getMargin()+min1->getMargin()); +#endif + } + } + if (foundSepAxis) + { + // printf("sepNormalWorldSpace=%f,%f,%f\n",sepNormalWorldSpace.getX(),sepNormalWorldSpace.getY(),sepNormalWorldSpace.getZ()); + + worldVertsB1.resize(0); + btPolyhedralContactClipping::clipHullAgainstHull(sepNormalWorldSpace, *polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(), + body0Wrap->getWorldTransform(), + body1Wrap->getWorldTransform(), minDist - threshold, threshold, worldVertsB1, worldVertsB2, + *resultOut); + } + if (m_ownManifold) + { + resultOut->refreshContactPoints(); + } + return; + } + else + { + //we can also deal with convex versus triangle (without connectivity data) + if (dispatchInfo.m_enableSatConvex && polyhedronA->getConvexPolyhedron() && polyhedronB->getShapeType() == TRIANGLE_SHAPE_PROXYTYPE) + { + btVertexArray worldSpaceVertices; + btTriangleShape* tri = (btTriangleShape*)polyhedronB; + worldSpaceVertices.push_back(body1Wrap->getWorldTransform() * tri->m_vertices1[0]); + worldSpaceVertices.push_back(body1Wrap->getWorldTransform() * tri->m_vertices1[1]); + worldSpaceVertices.push_back(body1Wrap->getWorldTransform() * tri->m_vertices1[2]); + + //tri->initializePolyhedralFeatures(); + + btScalar threshold = m_manifoldPtr->getContactBreakingThreshold()+ resultOut->m_closestPointDistanceThreshold; + + btVector3 sepNormalWorldSpace; + btScalar minDist = -1e30f; + btScalar maxDist = threshold; + + bool foundSepAxis = false; + bool useSatSepNormal = true; + + if (useSatSepNormal) + { +#if 0 + if (0) + { + //initializePolyhedralFeatures performs a convex hull computation, not needed for a single triangle + polyhedronB->initializePolyhedralFeatures(); + } else +#endif + { + btVector3 uniqueEdges[3] = {tri->m_vertices1[1] - tri->m_vertices1[0], + tri->m_vertices1[2] - tri->m_vertices1[1], + tri->m_vertices1[0] - tri->m_vertices1[2]}; + + uniqueEdges[0].normalize(); + uniqueEdges[1].normalize(); + uniqueEdges[2].normalize(); + + btConvexPolyhedron polyhedron; + polyhedron.m_vertices.push_back(tri->m_vertices1[2]); + polyhedron.m_vertices.push_back(tri->m_vertices1[0]); + polyhedron.m_vertices.push_back(tri->m_vertices1[1]); + + { + btFace combinedFaceA; + combinedFaceA.m_indices.push_back(0); + combinedFaceA.m_indices.push_back(1); + combinedFaceA.m_indices.push_back(2); + btVector3 faceNormal = uniqueEdges[0].cross(uniqueEdges[1]); + faceNormal.normalize(); + btScalar planeEq = 1e30f; + for (int v = 0; v < combinedFaceA.m_indices.size(); v++) + { + btScalar eq = tri->m_vertices1[combinedFaceA.m_indices[v]].dot(faceNormal); + if (planeEq > eq) + { + planeEq = eq; + } + } + combinedFaceA.m_plane[0] = faceNormal[0]; + combinedFaceA.m_plane[1] = faceNormal[1]; + combinedFaceA.m_plane[2] = faceNormal[2]; + combinedFaceA.m_plane[3] = -planeEq; + polyhedron.m_faces.push_back(combinedFaceA); + } + { + btFace combinedFaceB; + combinedFaceB.m_indices.push_back(0); + combinedFaceB.m_indices.push_back(2); + combinedFaceB.m_indices.push_back(1); + btVector3 faceNormal = -uniqueEdges[0].cross(uniqueEdges[1]); + faceNormal.normalize(); + btScalar planeEq = 1e30f; + for (int v = 0; v < combinedFaceB.m_indices.size(); v++) + { + btScalar eq = tri->m_vertices1[combinedFaceB.m_indices[v]].dot(faceNormal); + if (planeEq > eq) + { + planeEq = eq; + } + } + + combinedFaceB.m_plane[0] = faceNormal[0]; + combinedFaceB.m_plane[1] = faceNormal[1]; + combinedFaceB.m_plane[2] = faceNormal[2]; + combinedFaceB.m_plane[3] = -planeEq; + polyhedron.m_faces.push_back(combinedFaceB); + } + + polyhedron.m_uniqueEdges.push_back(uniqueEdges[0]); + polyhedron.m_uniqueEdges.push_back(uniqueEdges[1]); + polyhedron.m_uniqueEdges.push_back(uniqueEdges[2]); + polyhedron.initialize2(); + + polyhedronB->setPolyhedralFeatures(polyhedron); + } + + foundSepAxis = btPolyhedralContactClipping::findSeparatingAxis( + *polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(), + body0Wrap->getWorldTransform(), + body1Wrap->getWorldTransform(), + sepNormalWorldSpace, *resultOut); + // printf("sepNormalWorldSpace=%f,%f,%f\n",sepNormalWorldSpace.getX(),sepNormalWorldSpace.getY(),sepNormalWorldSpace.getZ()); + } + else + { +#ifdef ZERO_MARGIN + gjkPairDetector.setIgnoreMargin(true); + gjkPairDetector.getClosestPoints(input, *resultOut, dispatchInfo.m_debugDraw); +#else + gjkPairDetector.getClosestPoints(input, dummy, dispatchInfo.m_debugDraw); +#endif //ZERO_MARGIN + + if (dummy.m_hasContact && dummy.m_depth < 0) + { + if (foundSepAxis) + { + if (dummy.m_normalOnBInWorld.dot(sepNormalWorldSpace) < 0.99) + { + printf("?\n"); + } + } + else + { + printf("!\n"); + } + sepNormalWorldSpace.setValue(0, 0, 1); // = dummy.m_normalOnBInWorld; + //minDist = dummy.m_depth; + foundSepAxis = true; + } +#if 0 + btScalar l2 = gjkPairDetector.getCachedSeparatingAxis().length2(); + if (l2>SIMD_EPSILON) + { + sepNormalWorldSpace = gjkPairDetector.getCachedSeparatingAxis()*(1.f/l2); + //minDist = gjkPairDetector.getCachedSeparatingDistance(); + //maxDist = threshold; + minDist = gjkPairDetector.getCachedSeparatingDistance()-min0->getMargin()-min1->getMargin(); + foundSepAxis = true; + } +#endif + } + + if (foundSepAxis) + { + worldVertsB2.resize(0); + btPolyhedralContactClipping::clipFaceAgainstHull(sepNormalWorldSpace, *polyhedronA->getConvexPolyhedron(), + body0Wrap->getWorldTransform(), worldSpaceVertices, worldVertsB2, minDist - threshold, maxDist, *resultOut); + } + + if (m_ownManifold) + { + resultOut->refreshContactPoints(); + } + + return; + } + } + } + + gjkPairDetector.getClosestPoints(input, *resultOut, dispatchInfo.m_debugDraw); + + //now perform 'm_numPerturbationIterations' collision queries with the perturbated collision objects + + //perform perturbation when more then 'm_minimumPointsPerturbationThreshold' points + if (m_numPerturbationIterations && resultOut->getPersistentManifold()->getNumContacts() < m_minimumPointsPerturbationThreshold) + { + int i; + btVector3 v0, v1; + btVector3 sepNormalWorldSpace; + btScalar l2 = gjkPairDetector.getCachedSeparatingAxis().length2(); + + if (l2 > SIMD_EPSILON) + { + sepNormalWorldSpace = gjkPairDetector.getCachedSeparatingAxis() * (1.f / l2); + + btPlaneSpace1(sepNormalWorldSpace, v0, v1); + + bool perturbeA = true; + const btScalar angleLimit = 0.125f * SIMD_PI; + btScalar perturbeAngle; + btScalar radiusA = min0->getAngularMotionDisc(); + btScalar radiusB = min1->getAngularMotionDisc(); + if (radiusA < radiusB) + { + perturbeAngle = gContactBreakingThreshold / radiusA; + perturbeA = true; + } + else + { + perturbeAngle = gContactBreakingThreshold / radiusB; + perturbeA = false; + } + if (perturbeAngle > angleLimit) + perturbeAngle = angleLimit; + + btTransform unPerturbedTransform; + if (perturbeA) + { + unPerturbedTransform = input.m_transformA; + } + else + { + unPerturbedTransform = input.m_transformB; + } + + for (i = 0; i < m_numPerturbationIterations; i++) + { + if (v0.length2() > SIMD_EPSILON) + { + btQuaternion perturbeRot(v0, perturbeAngle); + btScalar iterationAngle = i * (SIMD_2_PI / btScalar(m_numPerturbationIterations)); + btQuaternion rotq(sepNormalWorldSpace, iterationAngle); + + if (perturbeA) + { + input.m_transformA.setBasis(btMatrix3x3(rotq.inverse() * perturbeRot * rotq) * body0Wrap->getWorldTransform().getBasis()); + input.m_transformB = body1Wrap->getWorldTransform(); +#ifdef DEBUG_CONTACTS + dispatchInfo.m_debugDraw->drawTransform(input.m_transformA, 10.0); +#endif //DEBUG_CONTACTS + } + else + { + input.m_transformA = body0Wrap->getWorldTransform(); + input.m_transformB.setBasis(btMatrix3x3(rotq.inverse() * perturbeRot * rotq) * body1Wrap->getWorldTransform().getBasis()); +#ifdef DEBUG_CONTACTS + dispatchInfo.m_debugDraw->drawTransform(input.m_transformB, 10.0); +#endif + } + + btPerturbedContactResult perturbedResultOut(resultOut, input.m_transformA, input.m_transformB, unPerturbedTransform, perturbeA, dispatchInfo.m_debugDraw); + gjkPairDetector.getClosestPoints(input, perturbedResultOut, dispatchInfo.m_debugDraw); + } + } + } + } + +#ifdef USE_SEPDISTANCE_UTIL2 + if (dispatchInfo.m_useConvexConservativeDistanceUtil && (sepDist > SIMD_EPSILON)) + { + m_sepDistance.initSeparatingDistance(gjkPairDetector.getCachedSeparatingAxis(), sepDist, body0->getWorldTransform(), body1->getWorldTransform()); + } +#endif //USE_SEPDISTANCE_UTIL2 + } + + if (m_ownManifold) + { + resultOut->refreshContactPoints(); + } +} + +bool disableCcd = false; +btScalar btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0, btCollisionObject* col1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + (void)resultOut; + (void)dispatchInfo; + ///Rather then checking ALL pairs, only calculate TOI when motion exceeds threshold + + ///Linear motion for one of objects needs to exceed m_ccdSquareMotionThreshold + ///col0->m_worldTransform, + btScalar resultFraction = btScalar(1.); + + btScalar squareMot0 = (col0->getInterpolationWorldTransform().getOrigin() - col0->getWorldTransform().getOrigin()).length2(); + btScalar squareMot1 = (col1->getInterpolationWorldTransform().getOrigin() - col1->getWorldTransform().getOrigin()).length2(); + + if (squareMot0 < col0->getCcdSquareMotionThreshold() && + squareMot1 < col1->getCcdSquareMotionThreshold()) + return resultFraction; + + if (disableCcd) + return btScalar(1.); + + //An adhoc way of testing the Continuous Collision Detection algorithms + //One object is approximated as a sphere, to simplify things + //Starting in penetration should report no time of impact + //For proper CCD, better accuracy and handling of 'allowed' penetration should be added + //also the mainloop of the physics should have a kind of toi queue (something like Brian Mirtich's application of Timewarp for Rigidbodies) + + /// Convex0 against sphere for Convex1 + { + btConvexShape* convex0 = static_cast(col0->getCollisionShape()); + + btSphereShape sphere1(col1->getCcdSweptSphereRadius()); //todo: allow non-zero sphere sizes, for better approximation + btConvexCast::CastResult result; + btVoronoiSimplexSolver voronoiSimplex; + //SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex); + ///Simplification, one object is simplified as a sphere + btGjkConvexCast ccd1(convex0, &sphere1, &voronoiSimplex); + //ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0); + if (ccd1.calcTimeOfImpact(col0->getWorldTransform(), col0->getInterpolationWorldTransform(), + col1->getWorldTransform(), col1->getInterpolationWorldTransform(), result)) + { + //store result.m_fraction in both bodies + + if (col0->getHitFraction() > result.m_fraction) + col0->setHitFraction(result.m_fraction); + + if (col1->getHitFraction() > result.m_fraction) + col1->setHitFraction(result.m_fraction); + + if (resultFraction > result.m_fraction) + resultFraction = result.m_fraction; + } + } + + /// Sphere (for convex0) against Convex1 + { + btConvexShape* convex1 = static_cast(col1->getCollisionShape()); + + btSphereShape sphere0(col0->getCcdSweptSphereRadius()); //todo: allow non-zero sphere sizes, for better approximation + btConvexCast::CastResult result; + btVoronoiSimplexSolver voronoiSimplex; + //SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex); + ///Simplification, one object is simplified as a sphere + btGjkConvexCast ccd1(&sphere0, convex1, &voronoiSimplex); + //ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0); + if (ccd1.calcTimeOfImpact(col0->getWorldTransform(), col0->getInterpolationWorldTransform(), + col1->getWorldTransform(), col1->getInterpolationWorldTransform(), result)) + { + //store result.m_fraction in both bodies + + if (col0->getHitFraction() > result.m_fraction) + col0->setHitFraction(result.m_fraction); + + if (col1->getHitFraction() > result.m_fraction) + col1->setHitFraction(result.m_fraction); + + if (resultFraction > result.m_fraction) + resultFraction = result.m_fraction; + } + } + + return resultFraction; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp.i new file mode 100644 index 00000000..d87a5313 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h new file mode 100644 index 00000000..9b761622 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h @@ -0,0 +1,101 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_CONVEX_ALGORITHM_H +#define BT_CONVEX_CONVEX_ALGORITHM_H + +#include "btActivatingCollisionAlgorithm.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" +#include "btCollisionCreateFunc.h" +#include "btCollisionDispatcher.h" +#include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUtil +#include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h" + +class btConvexPenetrationDepthSolver; + +///Enabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computation. However, when using large size ratios GJK can be imprecise +///so the distance is not conservative. In that case, enabling this USE_SEPDISTANCE_UTIL2 would result in failing/missing collisions. +///Either improve GJK for large size ratios (testing a 100 units versus a 0.1 unit object) or only enable the util +///for certain pairs that have a small size ratio + +//#define USE_SEPDISTANCE_UTIL2 1 + +///The convexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations between two convex objects. +///Multiple contact points are calculated by perturbing the orientation of the smallest object orthogonal to the separating normal. +///This idea was described by Gino van den Bergen in this forum topic http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=4&t=288&p=888#p888 +class btConvexConvexAlgorithm : public btActivatingCollisionAlgorithm +{ +#ifdef USE_SEPDISTANCE_UTIL2 + btConvexSeparatingDistanceUtil m_sepDistance; +#endif + btConvexPenetrationDepthSolver* m_pdSolver; + + btVertexArray worldVertsB1; + btVertexArray worldVertsB2; + + bool m_ownManifold; + btPersistentManifold* m_manifoldPtr; + bool m_lowLevelOfDetail; + + int m_numPerturbationIterations; + int m_minimumPointsPerturbationThreshold; + + ///cache separating vector to speedup collision detection + +public: + btConvexConvexAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btConvexPenetrationDepthSolver* pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold); + + virtual ~btConvexConvexAlgorithm(); + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual void getAllContactManifolds(btManifoldArray& manifoldArray) + { + ///should we use m_ownManifold to avoid adding duplicates? + if (m_manifoldPtr && m_ownManifold) + manifoldArray.push_back(m_manifoldPtr); + } + + void setLowLevelOfDetail(bool useLowLevel); + + const btPersistentManifold* getManifold() + { + return m_manifoldPtr; + } + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + btConvexPenetrationDepthSolver* m_pdSolver; + int m_numPerturbationIterations; + int m_minimumPointsPerturbationThreshold; + + CreateFunc(btConvexPenetrationDepthSolver* pdSolver); + + virtual ~CreateFunc(); + + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConvexAlgorithm)); + return new (mem) btConvexConvexAlgorithm(ci.m_manifold, ci, body0Wrap, body1Wrap, m_pdSolver, m_numPerturbationIterations, m_minimumPointsPerturbationThreshold); + } + }; +}; + +#endif //BT_CONVEX_CONVEX_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h.i new file mode 100644 index 00000000..0e6a19dc --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp new file mode 100644 index 00000000..d91d9c97 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp @@ -0,0 +1,172 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btConvexPlaneCollisionAlgorithm.h" + +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +//#include + +btConvexPlaneCollisionAlgorithm::btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* col0Wrap, const btCollisionObjectWrapper* col1Wrap, bool isSwapped, int numPerturbationIterations, int minimumPointsPerturbationThreshold) + : btCollisionAlgorithm(ci), + m_ownManifold(false), + m_manifoldPtr(mf), + m_isSwapped(isSwapped), + m_numPerturbationIterations(numPerturbationIterations), + m_minimumPointsPerturbationThreshold(minimumPointsPerturbationThreshold) +{ + const btCollisionObjectWrapper* convexObjWrap = m_isSwapped ? col1Wrap : col0Wrap; + const btCollisionObjectWrapper* planeObjWrap = m_isSwapped ? col0Wrap : col1Wrap; + + if (!m_manifoldPtr && m_dispatcher->needsCollision(convexObjWrap->getCollisionObject(), planeObjWrap->getCollisionObject())) + { + m_manifoldPtr = m_dispatcher->getNewManifold(convexObjWrap->getCollisionObject(), planeObjWrap->getCollisionObject()); + m_ownManifold = true; + } +} + +btConvexPlaneCollisionAlgorithm::~btConvexPlaneCollisionAlgorithm() +{ + if (m_ownManifold) + { + if (m_manifoldPtr) + m_dispatcher->releaseManifold(m_manifoldPtr); + } +} + +void btConvexPlaneCollisionAlgorithm::collideSingleContact(const btQuaternion& perturbeRot, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + const btCollisionObjectWrapper* convexObjWrap = m_isSwapped ? body1Wrap : body0Wrap; + const btCollisionObjectWrapper* planeObjWrap = m_isSwapped ? body0Wrap : body1Wrap; + + btConvexShape* convexShape = (btConvexShape*)convexObjWrap->getCollisionShape(); + btStaticPlaneShape* planeShape = (btStaticPlaneShape*)planeObjWrap->getCollisionShape(); + + bool hasCollision = false; + const btVector3& planeNormal = planeShape->getPlaneNormal(); + const btScalar& planeConstant = planeShape->getPlaneConstant(); + + btTransform convexWorldTransform = convexObjWrap->getWorldTransform(); + btTransform convexInPlaneTrans; + convexInPlaneTrans = planeObjWrap->getWorldTransform().inverse() * convexWorldTransform; + //now perturbe the convex-world transform + convexWorldTransform.getBasis() *= btMatrix3x3(perturbeRot); + btTransform planeInConvex; + planeInConvex = convexWorldTransform.inverse() * planeObjWrap->getWorldTransform(); + + btVector3 vtx = convexShape->localGetSupportingVertex(planeInConvex.getBasis() * -planeNormal); + + btVector3 vtxInPlane = convexInPlaneTrans(vtx); + btScalar distance = (planeNormal.dot(vtxInPlane) - planeConstant); + + btVector3 vtxInPlaneProjected = vtxInPlane - distance * planeNormal; + btVector3 vtxInPlaneWorld = planeObjWrap->getWorldTransform() * vtxInPlaneProjected; + + hasCollision = distance < m_manifoldPtr->getContactBreakingThreshold(); + resultOut->setPersistentManifold(m_manifoldPtr); + if (hasCollision) + { + /// report a contact. internally this will be kept persistent, and contact reduction is done + btVector3 normalOnSurfaceB = planeObjWrap->getWorldTransform().getBasis() * planeNormal; + btVector3 pOnB = vtxInPlaneWorld; + resultOut->addContactPoint(normalOnSurfaceB, pOnB, distance); + } +} + +void btConvexPlaneCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + (void)dispatchInfo; + if (!m_manifoldPtr) + return; + + const btCollisionObjectWrapper* convexObjWrap = m_isSwapped ? body1Wrap : body0Wrap; + const btCollisionObjectWrapper* planeObjWrap = m_isSwapped ? body0Wrap : body1Wrap; + + btConvexShape* convexShape = (btConvexShape*)convexObjWrap->getCollisionShape(); + btStaticPlaneShape* planeShape = (btStaticPlaneShape*)planeObjWrap->getCollisionShape(); + + bool hasCollision = false; + const btVector3& planeNormal = planeShape->getPlaneNormal(); + const btScalar& planeConstant = planeShape->getPlaneConstant(); + btTransform planeInConvex; + planeInConvex = convexObjWrap->getWorldTransform().inverse() * planeObjWrap->getWorldTransform(); + btTransform convexInPlaneTrans; + convexInPlaneTrans = planeObjWrap->getWorldTransform().inverse() * convexObjWrap->getWorldTransform(); + + btVector3 vtx = convexShape->localGetSupportingVertex(planeInConvex.getBasis() * -planeNormal); + btVector3 vtxInPlane = convexInPlaneTrans(vtx); + btScalar distance = (planeNormal.dot(vtxInPlane) - planeConstant); + + btVector3 vtxInPlaneProjected = vtxInPlane - distance * planeNormal; + btVector3 vtxInPlaneWorld = planeObjWrap->getWorldTransform() * vtxInPlaneProjected; + + hasCollision = distance < m_manifoldPtr->getContactBreakingThreshold()+ resultOut->m_closestPointDistanceThreshold; + resultOut->setPersistentManifold(m_manifoldPtr); + if (hasCollision) + { + /// report a contact. internally this will be kept persistent, and contact reduction is done + btVector3 normalOnSurfaceB = planeObjWrap->getWorldTransform().getBasis() * planeNormal; + btVector3 pOnB = vtxInPlaneWorld; + resultOut->addContactPoint(normalOnSurfaceB, pOnB, distance); + } + + //the perturbation algorithm doesn't work well with implicit surfaces such as spheres, cylinder and cones: + //they keep on rolling forever because of the additional off-center contact points + //so only enable the feature for polyhedral shapes (btBoxShape, btConvexHullShape etc) + if (convexShape->isPolyhedral() && resultOut->getPersistentManifold()->getNumContacts() < m_minimumPointsPerturbationThreshold) + { + btVector3 v0, v1; + btPlaneSpace1(planeNormal, v0, v1); + //now perform 'm_numPerturbationIterations' collision queries with the perturbated collision objects + + const btScalar angleLimit = 0.125f * SIMD_PI; + btScalar perturbeAngle; + btScalar radius = convexShape->getAngularMotionDisc(); + perturbeAngle = gContactBreakingThreshold / radius; + if (perturbeAngle > angleLimit) + perturbeAngle = angleLimit; + + btQuaternion perturbeRot(v0, perturbeAngle); + for (int i = 0; i < m_numPerturbationIterations; i++) + { + btScalar iterationAngle = i * (SIMD_2_PI / btScalar(m_numPerturbationIterations)); + btQuaternion rotq(planeNormal, iterationAngle); + collideSingleContact(rotq.inverse() * perturbeRot * rotq, body0Wrap, body1Wrap, dispatchInfo, resultOut); + } + } + + if (m_ownManifold) + { + if (m_manifoldPtr->getNumContacts()) + { + resultOut->refreshContactPoints(); + } + } +} + +btScalar btConvexPlaneCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0, btCollisionObject* col1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + (void)resultOut; + (void)dispatchInfo; + (void)col0; + (void)col1; + + //not yet + return btScalar(1.); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..b96c4dea --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h new file mode 100644 index 00000000..63402d9a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h @@ -0,0 +1,82 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_PLANE_COLLISION_ALGORITHM_H +#define BT_CONVEX_PLANE_COLLISION_ALGORITHM_H + +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +class btPersistentManifold; +#include "btCollisionDispatcher.h" + +#include "LinearMath/btVector3.h" + +/// btSphereBoxCollisionAlgorithm provides sphere-box collision detection. +/// Other features are frame-coherency (persistent data) and collision response. +class btConvexPlaneCollisionAlgorithm : public btCollisionAlgorithm +{ + bool m_ownManifold; + btPersistentManifold* m_manifoldPtr; + bool m_isSwapped; + int m_numPerturbationIterations; + int m_minimumPointsPerturbationThreshold; + +public: + btConvexPlaneCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped, int numPerturbationIterations, int minimumPointsPerturbationThreshold); + + virtual ~btConvexPlaneCollisionAlgorithm(); + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + void collideSingleContact(const btQuaternion& perturbeRot, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, 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); + } + } + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + int m_numPerturbationIterations; + int m_minimumPointsPerturbationThreshold; + + CreateFunc() + : m_numPerturbationIterations(1), + m_minimumPointsPerturbationThreshold(0) + { + } + + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexPlaneCollisionAlgorithm)); + if (!m_swapped) + { + return new (mem) btConvexPlaneCollisionAlgorithm(0, ci, body0Wrap, body1Wrap, false, m_numPerturbationIterations, m_minimumPointsPerturbationThreshold); + } + else + { + return new (mem) btConvexPlaneCollisionAlgorithm(0, ci, body0Wrap, body1Wrap, true, m_numPerturbationIterations, m_minimumPointsPerturbationThreshold); + } + } + }; +}; + +#endif //BT_CONVEX_PLANE_COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h.i new file mode 100644 index 00000000..a6cd19f1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp new file mode 100644 index 00000000..f6e6343b --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp @@ -0,0 +1,362 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btDefaultCollisionConfiguration.h" + +#include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h" + +#include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h" +#ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM +#include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h" +#endif //USE_BUGGY_SPHERE_BOX_ALGORITHM +#include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h" +#include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h" +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" + +#include "LinearMath/btPoolAllocator.h" + +btDefaultCollisionConfiguration::btDefaultCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo) +//btDefaultCollisionConfiguration::btDefaultCollisionConfiguration(btStackAlloc* stackAlloc,btPoolAllocator* persistentManifoldPool,btPoolAllocator* collisionAlgorithmPool) +{ + void* mem = NULL; + if (constructionInfo.m_useEpaPenetrationAlgorithm) + { + mem = btAlignedAlloc(sizeof(btGjkEpaPenetrationDepthSolver), 16); + m_pdSolver = new (mem) btGjkEpaPenetrationDepthSolver; + } + else + { + mem = btAlignedAlloc(sizeof(btMinkowskiPenetrationDepthSolver), 16); + m_pdSolver = new (mem) btMinkowskiPenetrationDepthSolver; + } + + //default CreationFunctions, filling the m_doubleDispatch table + mem = btAlignedAlloc(sizeof(btConvexConvexAlgorithm::CreateFunc), 16); + m_convexConvexCreateFunc = new (mem) btConvexConvexAlgorithm::CreateFunc(m_pdSolver); + mem = btAlignedAlloc(sizeof(btConvexConcaveCollisionAlgorithm::CreateFunc), 16); + m_convexConcaveCreateFunc = new (mem) btConvexConcaveCollisionAlgorithm::CreateFunc; + mem = btAlignedAlloc(sizeof(btConvexConcaveCollisionAlgorithm::CreateFunc), 16); + m_swappedConvexConcaveCreateFunc = new (mem) btConvexConcaveCollisionAlgorithm::SwappedCreateFunc; + mem = btAlignedAlloc(sizeof(btCompoundCollisionAlgorithm::CreateFunc), 16); + m_compoundCreateFunc = new (mem) btCompoundCollisionAlgorithm::CreateFunc; + + mem = btAlignedAlloc(sizeof(btCompoundCompoundCollisionAlgorithm::CreateFunc), 16); + m_compoundCompoundCreateFunc = new (mem) btCompoundCompoundCollisionAlgorithm::CreateFunc; + + mem = btAlignedAlloc(sizeof(btCompoundCollisionAlgorithm::SwappedCreateFunc), 16); + m_swappedCompoundCreateFunc = new (mem) btCompoundCollisionAlgorithm::SwappedCreateFunc; + mem = btAlignedAlloc(sizeof(btEmptyAlgorithm::CreateFunc), 16); + m_emptyCreateFunc = new (mem) btEmptyAlgorithm::CreateFunc; + + mem = btAlignedAlloc(sizeof(btSphereSphereCollisionAlgorithm::CreateFunc), 16); + m_sphereSphereCF = new (mem) btSphereSphereCollisionAlgorithm::CreateFunc; +#ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM + mem = btAlignedAlloc(sizeof(btSphereBoxCollisionAlgorithm::CreateFunc), 16); + m_sphereBoxCF = new (mem) btSphereBoxCollisionAlgorithm::CreateFunc; + mem = btAlignedAlloc(sizeof(btSphereBoxCollisionAlgorithm::CreateFunc), 16); + m_boxSphereCF = new (mem) btSphereBoxCollisionAlgorithm::CreateFunc; + m_boxSphereCF->m_swapped = true; +#endif //USE_BUGGY_SPHERE_BOX_ALGORITHM + + mem = btAlignedAlloc(sizeof(btSphereTriangleCollisionAlgorithm::CreateFunc), 16); + m_sphereTriangleCF = new (mem) btSphereTriangleCollisionAlgorithm::CreateFunc; + mem = btAlignedAlloc(sizeof(btSphereTriangleCollisionAlgorithm::CreateFunc), 16); + m_triangleSphereCF = new (mem) btSphereTriangleCollisionAlgorithm::CreateFunc; + m_triangleSphereCF->m_swapped = true; + + mem = btAlignedAlloc(sizeof(btBoxBoxCollisionAlgorithm::CreateFunc), 16); + m_boxBoxCF = new (mem) btBoxBoxCollisionAlgorithm::CreateFunc; + + //convex versus plane + mem = btAlignedAlloc(sizeof(btConvexPlaneCollisionAlgorithm::CreateFunc), 16); + m_convexPlaneCF = new (mem) btConvexPlaneCollisionAlgorithm::CreateFunc; + mem = btAlignedAlloc(sizeof(btConvexPlaneCollisionAlgorithm::CreateFunc), 16); + m_planeConvexCF = new (mem) btConvexPlaneCollisionAlgorithm::CreateFunc; + m_planeConvexCF->m_swapped = true; + + ///calculate maximum element size, big enough to fit any collision algorithm in the memory pool + int maxSize = sizeof(btConvexConvexAlgorithm); + int maxSize2 = sizeof(btConvexConcaveCollisionAlgorithm); + int maxSize3 = sizeof(btCompoundCollisionAlgorithm); + int maxSize4 = sizeof(btCompoundCompoundCollisionAlgorithm); + + int collisionAlgorithmMaxElementSize = btMax(maxSize, constructionInfo.m_customCollisionAlgorithmMaxElementSize); + collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize, maxSize2); + collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize, maxSize3); + collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize, maxSize4); + + if (constructionInfo.m_persistentManifoldPool) + { + m_ownsPersistentManifoldPool = false; + m_persistentManifoldPool = constructionInfo.m_persistentManifoldPool; + } + else + { + m_ownsPersistentManifoldPool = true; + void* mem = btAlignedAlloc(sizeof(btPoolAllocator), 16); + m_persistentManifoldPool = new (mem) btPoolAllocator(sizeof(btPersistentManifold), constructionInfo.m_defaultMaxPersistentManifoldPoolSize); + } + + collisionAlgorithmMaxElementSize = (collisionAlgorithmMaxElementSize + 16) & 0xffffffffffff0; + if (constructionInfo.m_collisionAlgorithmPool) + { + m_ownsCollisionAlgorithmPool = false; + m_collisionAlgorithmPool = constructionInfo.m_collisionAlgorithmPool; + } + else + { + m_ownsCollisionAlgorithmPool = true; + void* mem = btAlignedAlloc(sizeof(btPoolAllocator), 16); + m_collisionAlgorithmPool = new (mem) btPoolAllocator(collisionAlgorithmMaxElementSize, constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize); + } +} + +btDefaultCollisionConfiguration::~btDefaultCollisionConfiguration() +{ + if (m_ownsCollisionAlgorithmPool) + { + m_collisionAlgorithmPool->~btPoolAllocator(); + btAlignedFree(m_collisionAlgorithmPool); + } + if (m_ownsPersistentManifoldPool) + { + m_persistentManifoldPool->~btPoolAllocator(); + btAlignedFree(m_persistentManifoldPool); + } + + m_convexConvexCreateFunc->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_convexConvexCreateFunc); + + m_convexConcaveCreateFunc->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_convexConcaveCreateFunc); + m_swappedConvexConcaveCreateFunc->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_swappedConvexConcaveCreateFunc); + + m_compoundCreateFunc->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_compoundCreateFunc); + + m_compoundCompoundCreateFunc->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_compoundCompoundCreateFunc); + + m_swappedCompoundCreateFunc->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_swappedCompoundCreateFunc); + + m_emptyCreateFunc->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_emptyCreateFunc); + + m_sphereSphereCF->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_sphereSphereCF); + +#ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM + m_sphereBoxCF->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_sphereBoxCF); + m_boxSphereCF->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_boxSphereCF); +#endif //USE_BUGGY_SPHERE_BOX_ALGORITHM + + m_sphereTriangleCF->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_sphereTriangleCF); + m_triangleSphereCF->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_triangleSphereCF); + m_boxBoxCF->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_boxBoxCF); + + m_convexPlaneCF->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_convexPlaneCF); + m_planeConvexCF->~btCollisionAlgorithmCreateFunc(); + btAlignedFree(m_planeConvexCF); + + m_pdSolver->~btConvexPenetrationDepthSolver(); + + btAlignedFree(m_pdSolver); +} + +btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1) +{ + if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1 == SPHERE_SHAPE_PROXYTYPE)) + { + return m_sphereSphereCF; + } +#ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM + if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1 == BOX_SHAPE_PROXYTYPE)) + { + return m_sphereBoxCF; + } + + if ((proxyType0 == BOX_SHAPE_PROXYTYPE) && (proxyType1 == SPHERE_SHAPE_PROXYTYPE)) + { + return m_boxSphereCF; + } +#endif //USE_BUGGY_SPHERE_BOX_ALGORITHM + + if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1 == TRIANGLE_SHAPE_PROXYTYPE)) + { + return m_sphereTriangleCF; + } + + if ((proxyType0 == TRIANGLE_SHAPE_PROXYTYPE) && (proxyType1 == SPHERE_SHAPE_PROXYTYPE)) + { + return m_triangleSphereCF; + } + + if (btBroadphaseProxy::isConvex(proxyType0) && (proxyType1 == STATIC_PLANE_PROXYTYPE)) + { + return m_convexPlaneCF; + } + + if (btBroadphaseProxy::isConvex(proxyType1) && (proxyType0 == STATIC_PLANE_PROXYTYPE)) + { + return m_planeConvexCF; + } + + if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConvex(proxyType1)) + { + return m_convexConvexCreateFunc; + } + + if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConcave(proxyType1)) + { + return m_convexConcaveCreateFunc; + } + + if (btBroadphaseProxy::isConvex(proxyType1) && btBroadphaseProxy::isConcave(proxyType0)) + { + return m_swappedConvexConcaveCreateFunc; + } + + if (btBroadphaseProxy::isCompound(proxyType0) && btBroadphaseProxy::isCompound(proxyType1)) + { + return m_compoundCompoundCreateFunc; + } + + if (btBroadphaseProxy::isCompound(proxyType0)) + { + return m_compoundCreateFunc; + } + else + { + if (btBroadphaseProxy::isCompound(proxyType1)) + { + return m_swappedCompoundCreateFunc; + } + } + + //failed to find an algorithm + return m_emptyCreateFunc; +} + +btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1) +{ + if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1 == SPHERE_SHAPE_PROXYTYPE)) + { + return m_sphereSphereCF; + } +#ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM + if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1 == BOX_SHAPE_PROXYTYPE)) + { + return m_sphereBoxCF; + } + + if ((proxyType0 == BOX_SHAPE_PROXYTYPE) && (proxyType1 == SPHERE_SHAPE_PROXYTYPE)) + { + return m_boxSphereCF; + } +#endif //USE_BUGGY_SPHERE_BOX_ALGORITHM + + if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1 == TRIANGLE_SHAPE_PROXYTYPE)) + { + return m_sphereTriangleCF; + } + + if ((proxyType0 == TRIANGLE_SHAPE_PROXYTYPE) && (proxyType1 == SPHERE_SHAPE_PROXYTYPE)) + { + return m_triangleSphereCF; + } + + if ((proxyType0 == BOX_SHAPE_PROXYTYPE) && (proxyType1 == BOX_SHAPE_PROXYTYPE)) + { + return m_boxBoxCF; + } + + if (btBroadphaseProxy::isConvex(proxyType0) && (proxyType1 == STATIC_PLANE_PROXYTYPE)) + { + return m_convexPlaneCF; + } + + if (btBroadphaseProxy::isConvex(proxyType1) && (proxyType0 == STATIC_PLANE_PROXYTYPE)) + { + return m_planeConvexCF; + } + + if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConvex(proxyType1)) + { + return m_convexConvexCreateFunc; + } + + if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConcave(proxyType1)) + { + return m_convexConcaveCreateFunc; + } + + if (btBroadphaseProxy::isConvex(proxyType1) && btBroadphaseProxy::isConcave(proxyType0)) + { + return m_swappedConvexConcaveCreateFunc; + } + + if (btBroadphaseProxy::isCompound(proxyType0) && btBroadphaseProxy::isCompound(proxyType1)) + { + return m_compoundCompoundCreateFunc; + } + + if (btBroadphaseProxy::isCompound(proxyType0)) + { + return m_compoundCreateFunc; + } + else + { + if (btBroadphaseProxy::isCompound(proxyType1)) + { + return m_swappedCompoundCreateFunc; + } + } + + //failed to find an algorithm + return m_emptyCreateFunc; +} + +void btDefaultCollisionConfiguration::setConvexConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold) +{ + btConvexConvexAlgorithm::CreateFunc* convexConvex = (btConvexConvexAlgorithm::CreateFunc*)m_convexConvexCreateFunc; + convexConvex->m_numPerturbationIterations = numPerturbationIterations; + convexConvex->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold; +} + +void btDefaultCollisionConfiguration::setPlaneConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold) +{ + btConvexPlaneCollisionAlgorithm::CreateFunc* cpCF = (btConvexPlaneCollisionAlgorithm::CreateFunc*)m_convexPlaneCF; + cpCF->m_numPerturbationIterations = numPerturbationIterations; + cpCF->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold; + + btConvexPlaneCollisionAlgorithm::CreateFunc* pcCF = (btConvexPlaneCollisionAlgorithm::CreateFunc*)m_planeConvexCF; + pcCF->m_numPerturbationIterations = numPerturbationIterations; + pcCF->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp.i new file mode 100644 index 00000000..1bc1f48d --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h new file mode 100644 index 00000000..adab540c --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h @@ -0,0 +1,111 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_DEFAULT_COLLISION_CONFIGURATION +#define BT_DEFAULT_COLLISION_CONFIGURATION + +#include "btCollisionConfiguration.h" +class btVoronoiSimplexSolver; +class btConvexPenetrationDepthSolver; + +struct btDefaultCollisionConstructionInfo +{ + btPoolAllocator* m_persistentManifoldPool; + btPoolAllocator* m_collisionAlgorithmPool; + int m_defaultMaxPersistentManifoldPoolSize; + int m_defaultMaxCollisionAlgorithmPoolSize; + int m_customCollisionAlgorithmMaxElementSize; + int m_useEpaPenetrationAlgorithm; + + btDefaultCollisionConstructionInfo() + : m_persistentManifoldPool(0), + m_collisionAlgorithmPool(0), + m_defaultMaxPersistentManifoldPoolSize(4096), + m_defaultMaxCollisionAlgorithmPoolSize(4096), + m_customCollisionAlgorithmMaxElementSize(0), + m_useEpaPenetrationAlgorithm(true) + { + } +}; + +///btCollisionConfiguration allows to configure Bullet collision detection +///stack allocator, pool memory allocators +///@todo: describe the meaning +class btDefaultCollisionConfiguration : public btCollisionConfiguration +{ +protected: + int m_persistentManifoldPoolSize; + + btPoolAllocator* m_persistentManifoldPool; + bool m_ownsPersistentManifoldPool; + + btPoolAllocator* m_collisionAlgorithmPool; + bool m_ownsCollisionAlgorithmPool; + + //default penetration depth solver + btConvexPenetrationDepthSolver* m_pdSolver; + + //default CreationFunctions, filling the m_doubleDispatch table + btCollisionAlgorithmCreateFunc* m_convexConvexCreateFunc; + btCollisionAlgorithmCreateFunc* m_convexConcaveCreateFunc; + btCollisionAlgorithmCreateFunc* m_swappedConvexConcaveCreateFunc; + btCollisionAlgorithmCreateFunc* m_compoundCreateFunc; + btCollisionAlgorithmCreateFunc* m_compoundCompoundCreateFunc; + + btCollisionAlgorithmCreateFunc* m_swappedCompoundCreateFunc; + btCollisionAlgorithmCreateFunc* m_emptyCreateFunc; + btCollisionAlgorithmCreateFunc* m_sphereSphereCF; + btCollisionAlgorithmCreateFunc* m_sphereBoxCF; + btCollisionAlgorithmCreateFunc* m_boxSphereCF; + + btCollisionAlgorithmCreateFunc* m_boxBoxCF; + btCollisionAlgorithmCreateFunc* m_sphereTriangleCF; + btCollisionAlgorithmCreateFunc* m_triangleSphereCF; + btCollisionAlgorithmCreateFunc* m_planeConvexCF; + btCollisionAlgorithmCreateFunc* m_convexPlaneCF; + +public: + btDefaultCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo = btDefaultCollisionConstructionInfo()); + + virtual ~btDefaultCollisionConfiguration(); + + ///memory pools + virtual btPoolAllocator* getPersistentManifoldPool() + { + return m_persistentManifoldPool; + } + + virtual btPoolAllocator* getCollisionAlgorithmPool() + { + return m_collisionAlgorithmPool; + } + + virtual btCollisionAlgorithmCreateFunc* getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1); + + virtual btCollisionAlgorithmCreateFunc* getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1); + + ///Use this method to allow to generate multiple contact points between at once, between two objects using the generic convex-convex algorithm. + ///By default, this feature is disabled for best performance. + ///@param numPerturbationIterations controls the number of collision queries. Set it to zero to disable the feature. + ///@param minimumPointsPerturbationThreshold is the minimum number of points in the contact cache, above which the feature is disabled + ///3 is a good value for both params, if you want to enable the feature. This is because the default contact cache contains a maximum of 4 points, and one collision query at the unperturbed orientation is performed first. + ///See Bullet/Demos/CollisionDemo for an example how this feature gathers multiple points. + ///@todo we could add a per-object setting of those parameters, for level-of-detail collision detection. + void setConvexConvexMultipointIterations(int numPerturbationIterations = 3, int minimumPointsPerturbationThreshold = 3); + + void setPlaneConvexMultipointIterations(int numPerturbationIterations = 3, int minimumPointsPerturbationThreshold = 3); +}; + +#endif //BT_DEFAULT_COLLISION_CONFIGURATION diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h.i new file mode 100644 index 00000000..83880dbc --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h ---------------- + +%include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h" + +%{ +#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp new file mode 100644 index 00000000..6c71dc5e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp @@ -0,0 +1,30 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btEmptyCollisionAlgorithm.h" + +btEmptyAlgorithm::btEmptyAlgorithm(const btCollisionAlgorithmConstructionInfo& ci) + : btCollisionAlgorithm(ci) +{ +} + +void btEmptyAlgorithm::processCollision(const btCollisionObjectWrapper*, const btCollisionObjectWrapper*, const btDispatcherInfo&, btManifoldResult*) +{ +} + +btScalar btEmptyAlgorithm::calculateTimeOfImpact(btCollisionObject*, btCollisionObject*, const btDispatcherInfo&, btManifoldResult*) +{ + return btScalar(1.); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..9598d73c --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h new file mode 100644 index 00000000..fef2f275 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h @@ -0,0 +1,52 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_EMPTY_ALGORITH +#define BT_EMPTY_ALGORITH +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +#include "btCollisionCreateFunc.h" +#include "btCollisionDispatcher.h" + +#define ATTRIBUTE_ALIGNED(a) + +///EmptyAlgorithm is a stub for unsupported collision pairs. +///The dispatcher can dispatch a persistent btEmptyAlgorithm to avoid a search every frame. +class btEmptyAlgorithm : public btCollisionAlgorithm +{ +public: + btEmptyAlgorithm(const btCollisionAlgorithmConstructionInfo& ci); + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual btScalar calculateTimeOfImpact(btCollisionObject* body0, btCollisionObject* body1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut); + + virtual void getAllContactManifolds(btManifoldArray& manifoldArray) + { + } + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + (void)body0Wrap; + (void)body1Wrap; + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btEmptyAlgorithm)); + return new (mem) btEmptyAlgorithm(ci); + } + }; + +} ATTRIBUTE_ALIGNED(16); + +#endif //BT_EMPTY_ALGORITH diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h.i new file mode 100644 index 00000000..6e525c2f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.cpp new file mode 100644 index 00000000..00f16fd0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.cpp @@ -0,0 +1,166 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btGhostObject.h" +#include "btCollisionWorld.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "LinearMath/btAabbUtil2.h" + +btGhostObject::btGhostObject() +{ + m_internalType = CO_GHOST_OBJECT; +} + +btGhostObject::~btGhostObject() +{ + ///btGhostObject should have been removed from the world, so no overlapping objects + btAssert(!m_overlappingObjects.size()); +} + +void btGhostObject::addOverlappingObjectInternal(btBroadphaseProxy* otherProxy, btBroadphaseProxy* thisProxy) +{ + btCollisionObject* otherObject = (btCollisionObject*)otherProxy->m_clientObject; + btAssert(otherObject); + ///if this linearSearch becomes too slow (too many overlapping objects) we should add a more appropriate data structure + int index = m_overlappingObjects.findLinearSearch(otherObject); + if (index == m_overlappingObjects.size()) + { + //not found + m_overlappingObjects.push_back(otherObject); + } +} + +void btGhostObject::removeOverlappingObjectInternal(btBroadphaseProxy* otherProxy, btDispatcher* dispatcher, btBroadphaseProxy* thisProxy) +{ + btCollisionObject* otherObject = (btCollisionObject*)otherProxy->m_clientObject; + btAssert(otherObject); + int index = m_overlappingObjects.findLinearSearch(otherObject); + if (index < m_overlappingObjects.size()) + { + m_overlappingObjects[index] = m_overlappingObjects[m_overlappingObjects.size() - 1]; + m_overlappingObjects.pop_back(); + } +} + +btPairCachingGhostObject::btPairCachingGhostObject() +{ + m_hashPairCache = new (btAlignedAlloc(sizeof(btHashedOverlappingPairCache), 16)) btHashedOverlappingPairCache(); +} + +btPairCachingGhostObject::~btPairCachingGhostObject() +{ + m_hashPairCache->~btHashedOverlappingPairCache(); + btAlignedFree(m_hashPairCache); +} + +void btPairCachingGhostObject::addOverlappingObjectInternal(btBroadphaseProxy* otherProxy, btBroadphaseProxy* thisProxy) +{ + btBroadphaseProxy* actualThisProxy = thisProxy ? thisProxy : getBroadphaseHandle(); + btAssert(actualThisProxy); + + btCollisionObject* otherObject = (btCollisionObject*)otherProxy->m_clientObject; + btAssert(otherObject); + int index = m_overlappingObjects.findLinearSearch(otherObject); + if (index == m_overlappingObjects.size()) + { + m_overlappingObjects.push_back(otherObject); + m_hashPairCache->addOverlappingPair(actualThisProxy, otherProxy); + } +} + +void btPairCachingGhostObject::removeOverlappingObjectInternal(btBroadphaseProxy* otherProxy, btDispatcher* dispatcher, btBroadphaseProxy* thisProxy1) +{ + btCollisionObject* otherObject = (btCollisionObject*)otherProxy->m_clientObject; + btBroadphaseProxy* actualThisProxy = thisProxy1 ? thisProxy1 : getBroadphaseHandle(); + btAssert(actualThisProxy); + + btAssert(otherObject); + int index = m_overlappingObjects.findLinearSearch(otherObject); + if (index < m_overlappingObjects.size()) + { + m_overlappingObjects[index] = m_overlappingObjects[m_overlappingObjects.size() - 1]; + m_overlappingObjects.pop_back(); + m_hashPairCache->removeOverlappingPair(actualThisProxy, otherProxy, dispatcher); + } +} + +void btGhostObject::convexSweepTest(const btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, btCollisionWorld::ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration) const +{ + btTransform convexFromTrans, convexToTrans; + convexFromTrans = convexFromWorld; + convexToTrans = convexToWorld; + btVector3 castShapeAabbMin, castShapeAabbMax; + /* Compute AABB that encompasses angular movement */ + { + btVector3 linVel, angVel; + btTransformUtil::calculateVelocity(convexFromTrans, convexToTrans, 1.0, linVel, angVel); + btTransform R; + R.setIdentity(); + R.setRotation(convexFromTrans.getRotation()); + castShape->calculateTemporalAabb(R, linVel, angVel, 1.0, castShapeAabbMin, castShapeAabbMax); + } + + /// go over all objects, and if the ray intersects their aabb + cast shape aabb, + // do a ray-shape query using convexCaster (CCD) + int i; + for (i = 0; i < m_overlappingObjects.size(); i++) + { + btCollisionObject* collisionObject = m_overlappingObjects[i]; + //only perform raycast if filterMask matches + if (resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) + { + //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject(); + btVector3 collisionObjectAabbMin, collisionObjectAabbMax; + collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(), collisionObjectAabbMin, collisionObjectAabbMax); + AabbExpand(collisionObjectAabbMin, collisionObjectAabbMax, castShapeAabbMin, castShapeAabbMax); + btScalar hitLambda = btScalar(1.); //could use resultCallback.m_closestHitFraction, but needs testing + btVector3 hitNormal; + if (btRayAabb(convexFromWorld.getOrigin(), convexToWorld.getOrigin(), collisionObjectAabbMin, collisionObjectAabbMax, hitLambda, hitNormal)) + { + btCollisionWorld::objectQuerySingle(castShape, convexFromTrans, convexToTrans, + collisionObject, + collisionObject->getCollisionShape(), + collisionObject->getWorldTransform(), + resultCallback, + allowedCcdPenetration); + } + } + } +} + +void btGhostObject::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, btCollisionWorld::RayResultCallback& resultCallback) const +{ + btTransform rayFromTrans; + rayFromTrans.setIdentity(); + rayFromTrans.setOrigin(rayFromWorld); + btTransform rayToTrans; + rayToTrans.setIdentity(); + rayToTrans.setOrigin(rayToWorld); + + int i; + for (i = 0; i < m_overlappingObjects.size(); i++) + { + btCollisionObject* collisionObject = m_overlappingObjects[i]; + //only perform raycast if filterMask matches + if (resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) + { + btCollisionWorld::rayTestSingle(rayFromTrans, rayToTrans, + collisionObject, + collisionObject->getCollisionShape(), + collisionObject->getWorldTransform(), + resultCallback); + } + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.cpp.i new file mode 100644 index 00000000..5c988df7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btGhostObject.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btGhostObject.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btGhostObject.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.h new file mode 100644 index 00000000..aa7f48d5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.h @@ -0,0 +1,162 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_GHOST_OBJECT_H +#define BT_GHOST_OBJECT_H + +#include "btCollisionObject.h" +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h" +#include "LinearMath/btAlignedAllocator.h" +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" +#include "btCollisionWorld.h" + +class btConvexShape; + +class btDispatcher; + +///The btGhostObject can keep track of all objects that are overlapping +///By default, this overlap is based on the AABB +///This is useful for creating a character controller, collision sensors/triggers, explosions etc. +///We plan on adding rayTest and other queries for the btGhostObject +ATTRIBUTE_ALIGNED16(class) +btGhostObject : public btCollisionObject +{ +protected: + btAlignedObjectArray m_overlappingObjects; + +public: + btGhostObject(); + + virtual ~btGhostObject(); + + void convexSweepTest(const class btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, btCollisionWorld::ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration = 0.f) const; + + void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, btCollisionWorld::RayResultCallback& resultCallback) const; + + ///this method is mainly for expert/internal use only. + virtual void addOverlappingObjectInternal(btBroadphaseProxy * otherProxy, btBroadphaseProxy* thisProxy = 0); + ///this method is mainly for expert/internal use only. + virtual void removeOverlappingObjectInternal(btBroadphaseProxy * otherProxy, btDispatcher * dispatcher, btBroadphaseProxy* thisProxy = 0); + + int getNumOverlappingObjects() const + { + return m_overlappingObjects.size(); + } + + btCollisionObject* getOverlappingObject(int index) + { + return m_overlappingObjects[index]; + } + + const btCollisionObject* getOverlappingObject(int index) const + { + return m_overlappingObjects[index]; + } + + btAlignedObjectArray& getOverlappingPairs() + { + return m_overlappingObjects; + } + + const btAlignedObjectArray getOverlappingPairs() const + { + return m_overlappingObjects; + } + + // + // internal cast + // + + static const btGhostObject* upcast(const btCollisionObject* colObj) + { + if (colObj->getInternalType() == CO_GHOST_OBJECT) + return (const btGhostObject*)colObj; + return 0; + } + static btGhostObject* upcast(btCollisionObject * colObj) + { + if (colObj->getInternalType() == CO_GHOST_OBJECT) + return (btGhostObject*)colObj; + return 0; + } +}; + +class btPairCachingGhostObject : public btGhostObject +{ + btHashedOverlappingPairCache* m_hashPairCache; + +public: + btPairCachingGhostObject(); + + virtual ~btPairCachingGhostObject(); + + ///this method is mainly for expert/internal use only. + virtual void addOverlappingObjectInternal(btBroadphaseProxy* otherProxy, btBroadphaseProxy* thisProxy = 0); + + virtual void removeOverlappingObjectInternal(btBroadphaseProxy* otherProxy, btDispatcher* dispatcher, btBroadphaseProxy* thisProxy = 0); + + btHashedOverlappingPairCache* getOverlappingPairCache() + { + return m_hashPairCache; + } +}; + +///The btGhostPairCallback interfaces and forwards adding and removal of overlapping pairs from the btBroadphaseInterface to btGhostObject. +class btGhostPairCallback : public btOverlappingPairCallback +{ +public: + btGhostPairCallback() + { + } + + virtual ~btGhostPairCallback() + { + } + + virtual btBroadphasePair* addOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) + { + btCollisionObject* colObj0 = (btCollisionObject*)proxy0->m_clientObject; + btCollisionObject* colObj1 = (btCollisionObject*)proxy1->m_clientObject; + btGhostObject* ghost0 = btGhostObject::upcast(colObj0); + btGhostObject* ghost1 = btGhostObject::upcast(colObj1); + if (ghost0) + ghost0->addOverlappingObjectInternal(proxy1, proxy0); + if (ghost1) + ghost1->addOverlappingObjectInternal(proxy0, proxy1); + return 0; + } + + virtual void* removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher) + { + btCollisionObject* colObj0 = (btCollisionObject*)proxy0->m_clientObject; + btCollisionObject* colObj1 = (btCollisionObject*)proxy1->m_clientObject; + btGhostObject* ghost0 = btGhostObject::upcast(colObj0); + btGhostObject* ghost1 = btGhostObject::upcast(colObj1); + if (ghost0) + ghost0->removeOverlappingObjectInternal(proxy1, dispatcher, proxy0); + if (ghost1) + ghost1->removeOverlappingObjectInternal(proxy0, dispatcher, proxy1); + return 0; + } + + virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy* /*proxy0*/, btDispatcher* /*dispatcher*/) + { + btAssert(0); + //need to keep track of all ghost objects and call them here + //m_hashPairCache->removeOverlappingPairsContainingProxy(proxy0,dispatcher); + } +}; + +#endif diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.h.i new file mode 100644 index 00000000..061c4f22 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btGhostObject.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btGhostObject.h ---------------- + +%include "BulletCollision/CollisionDispatch/btGhostObject.h" + +%{ +#include "BulletCollision/CollisionDispatch/btGhostObject.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp new file mode 100644 index 00000000..18d7dfd9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp @@ -0,0 +1,244 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btHashedSimplePairCache.h" + +#include + +#ifdef BT_DEBUG_COLLISION_PAIRS +int gOverlappingSimplePairs = 0; +int gRemoveSimplePairs = 0; +int gAddedSimplePairs = 0; +int gFindSimplePairs = 0; +#endif //BT_DEBUG_COLLISION_PAIRS + +btHashedSimplePairCache::btHashedSimplePairCache() +{ + int initialAllocatedSize = 2; + m_overlappingPairArray.reserve(initialAllocatedSize); + growTables(); +} + +btHashedSimplePairCache::~btHashedSimplePairCache() +{ +} + +void btHashedSimplePairCache::removeAllPairs() +{ + m_overlappingPairArray.clear(); + m_hashTable.clear(); + m_next.clear(); + + int initialAllocatedSize = 2; + m_overlappingPairArray.reserve(initialAllocatedSize); + growTables(); +} + +btSimplePair* btHashedSimplePairCache::findPair(int indexA, int indexB) +{ +#ifdef BT_DEBUG_COLLISION_PAIRS + gFindSimplePairs++; +#endif + + /*if (indexA > indexB) + btSwap(indexA, indexB);*/ + + int hash = static_cast(getHash(static_cast(indexA), static_cast(indexB)) & (m_overlappingPairArray.capacity() - 1)); + + if (hash >= m_hashTable.size()) + { + return NULL; + } + + int index = m_hashTable[hash]; + while (index != BT_SIMPLE_NULL_PAIR && equalsPair(m_overlappingPairArray[index], indexA, indexB) == false) + { + index = m_next[index]; + } + + if (index == BT_SIMPLE_NULL_PAIR) + { + return NULL; + } + + btAssert(index < m_overlappingPairArray.size()); + + return &m_overlappingPairArray[index]; +} + +//#include + +void btHashedSimplePairCache::growTables() +{ + int newCapacity = m_overlappingPairArray.capacity(); + + if (m_hashTable.size() < newCapacity) + { + //grow hashtable and next table + int curHashtableSize = m_hashTable.size(); + + m_hashTable.resize(newCapacity); + m_next.resize(newCapacity); + + int i; + + for (i = 0; i < newCapacity; ++i) + { + m_hashTable[i] = BT_SIMPLE_NULL_PAIR; + } + for (i = 0; i < newCapacity; ++i) + { + m_next[i] = BT_SIMPLE_NULL_PAIR; + } + + for (i = 0; i < curHashtableSize; i++) + { + const btSimplePair& pair = m_overlappingPairArray[i]; + int indexA = pair.m_indexA; + int indexB = pair.m_indexB; + + int hashValue = static_cast(getHash(static_cast(indexA), static_cast(indexB)) & (m_overlappingPairArray.capacity() - 1)); // New hash value with new mask + m_next[i] = m_hashTable[hashValue]; + m_hashTable[hashValue] = i; + } + } +} + +btSimplePair* btHashedSimplePairCache::internalAddPair(int indexA, int indexB) +{ + int hash = static_cast(getHash(static_cast(indexA), static_cast(indexB)) & (m_overlappingPairArray.capacity() - 1)); // New hash value with new mask + + btSimplePair* pair = internalFindPair(indexA, indexB, hash); + if (pair != NULL) + { + return pair; + } + + int count = m_overlappingPairArray.size(); + int oldCapacity = m_overlappingPairArray.capacity(); + void* mem = &m_overlappingPairArray.expandNonInitializing(); + + int newCapacity = m_overlappingPairArray.capacity(); + + if (oldCapacity < newCapacity) + { + growTables(); + //hash with new capacity + hash = static_cast(getHash(static_cast(indexA), static_cast(indexB)) & (m_overlappingPairArray.capacity() - 1)); + } + + pair = new (mem) btSimplePair(indexA, indexB); + + pair->m_userPointer = 0; + + m_next[count] = m_hashTable[hash]; + m_hashTable[hash] = count; + + return pair; +} + +void* btHashedSimplePairCache::removeOverlappingPair(int indexA, int indexB) +{ +#ifdef BT_DEBUG_COLLISION_PAIRS + gRemoveSimplePairs++; +#endif + + /*if (indexA > indexB) + btSwap(indexA, indexB);*/ + + int hash = static_cast(getHash(static_cast(indexA), static_cast(indexB)) & (m_overlappingPairArray.capacity() - 1)); + + btSimplePair* pair = internalFindPair(indexA, indexB, hash); + if (pair == NULL) + { + return 0; + } + + void* userData = pair->m_userPointer; + + int pairIndex = int(pair - &m_overlappingPairArray[0]); + btAssert(pairIndex < m_overlappingPairArray.size()); + + // Remove the pair from the hash table. + int index = m_hashTable[hash]; + btAssert(index != BT_SIMPLE_NULL_PAIR); + + int previous = BT_SIMPLE_NULL_PAIR; + while (index != pairIndex) + { + previous = index; + index = m_next[index]; + } + + if (previous != BT_SIMPLE_NULL_PAIR) + { + btAssert(m_next[previous] == pairIndex); + m_next[previous] = m_next[pairIndex]; + } + else + { + m_hashTable[hash] = m_next[pairIndex]; + } + + // We now move the last pair into spot of the + // pair being removed. We need to fix the hash + // table indices to support the move. + + int lastPairIndex = m_overlappingPairArray.size() - 1; + + // If the removed pair is the last pair, we are done. + if (lastPairIndex == pairIndex) + { + m_overlappingPairArray.pop_back(); + return userData; + } + + // Remove the last pair from the hash table. + const btSimplePair* last = &m_overlappingPairArray[lastPairIndex]; + /* missing swap here too, Nat. */ + int lastHash = static_cast(getHash(static_cast(last->m_indexA), static_cast(last->m_indexB)) & (m_overlappingPairArray.capacity() - 1)); + + index = m_hashTable[lastHash]; + btAssert(index != BT_SIMPLE_NULL_PAIR); + + previous = BT_SIMPLE_NULL_PAIR; + while (index != lastPairIndex) + { + previous = index; + index = m_next[index]; + } + + if (previous != BT_SIMPLE_NULL_PAIR) + { + btAssert(m_next[previous] == lastPairIndex); + m_next[previous] = m_next[lastPairIndex]; + } + else + { + m_hashTable[lastHash] = m_next[lastPairIndex]; + } + + // Copy the last pair into the remove pair's spot. + m_overlappingPairArray[pairIndex] = m_overlappingPairArray[lastPairIndex]; + + // Insert the last pair into the hash table + m_next[pairIndex] = m_hashTable[lastHash]; + m_hashTable[lastHash] = pairIndex; + + m_overlappingPairArray.pop_back(); + + return userData; +} +//#include diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp.i new file mode 100644 index 00000000..6723edf0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.h new file mode 100644 index 00000000..e6acbb8e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.h @@ -0,0 +1,149 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_HASHED_SIMPLE_PAIR_CACHE_H +#define BT_HASHED_SIMPLE_PAIR_CACHE_H + +#include "LinearMath/btAlignedObjectArray.h" + +const int BT_SIMPLE_NULL_PAIR = 0xffffffff; + +struct btSimplePair +{ + btSimplePair(int indexA, int indexB) + : m_indexA(indexA), + m_indexB(indexB), + m_userPointer(0) + { + } + + int m_indexA; + int m_indexB; + union { + void* m_userPointer; + int m_userValue; + }; +}; + +typedef btAlignedObjectArray btSimplePairArray; + +#ifdef BT_DEBUG_COLLISION_PAIRS +extern int gOverlappingSimplePairs; +extern int gRemoveSimplePairs; +extern int gAddedSimplePairs; +extern int gFindSimplePairs; +#endif //BT_DEBUG_COLLISION_PAIRS + +class btHashedSimplePairCache +{ + btSimplePairArray m_overlappingPairArray; + +protected: + btAlignedObjectArray m_hashTable; + btAlignedObjectArray m_next; + +public: + btHashedSimplePairCache(); + virtual ~btHashedSimplePairCache(); + + void removeAllPairs(); + + virtual void* removeOverlappingPair(int indexA, int indexB); + + // Add a pair and return the new pair. If the pair already exists, + // no new pair is created and the old one is returned. + virtual btSimplePair* addOverlappingPair(int indexA, int indexB) + { +#ifdef BT_DEBUG_COLLISION_PAIRS + gAddedSimplePairs++; +#endif + + return internalAddPair(indexA, indexB); + } + + virtual btSimplePair* getOverlappingPairArrayPtr() + { + return &m_overlappingPairArray[0]; + } + + const btSimplePair* getOverlappingPairArrayPtr() const + { + return &m_overlappingPairArray[0]; + } + + btSimplePairArray& getOverlappingPairArray() + { + return m_overlappingPairArray; + } + + const btSimplePairArray& getOverlappingPairArray() const + { + return m_overlappingPairArray; + } + + btSimplePair* findPair(int indexA, int indexB); + + int GetCount() const { return m_overlappingPairArray.size(); } + + int getNumOverlappingPairs() const + { + return m_overlappingPairArray.size(); + } + +private: + btSimplePair* internalAddPair(int indexA, int indexB); + + void growTables(); + + SIMD_FORCE_INLINE bool equalsPair(const btSimplePair& pair, int indexA, int indexB) + { + return pair.m_indexA == indexA && pair.m_indexB == indexB; + } + + SIMD_FORCE_INLINE unsigned int getHash(unsigned int indexA, unsigned int indexB) + { + unsigned int key = indexA | (indexB << 16); + // Thomas Wang's hash + + key += ~(key << 15); + key ^= (key >> 10); + key += (key << 3); + key ^= (key >> 6); + key += ~(key << 11); + key ^= (key >> 16); + return key; + } + + SIMD_FORCE_INLINE btSimplePair* internalFindPair(int proxyIdA, int proxyIdB, int hash) + { + int index = m_hashTable[hash]; + + while (index != BT_SIMPLE_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyIdA, proxyIdB) == false) + { + index = m_next[index]; + } + + if (index == BT_SIMPLE_NULL_PAIR) + { + return NULL; + } + + btAssert(index < m_overlappingPairArray.size()); + + return &m_overlappingPairArray[index]; + } +}; + +#endif //BT_HASHED_SIMPLE_PAIR_CACHE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.h.i new file mode 100644 index 00000000..6a24bc96 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btHashedSimplePairCache.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btHashedSimplePairCache.h ---------------- + +%include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.h" + +%{ +#include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp new file mode 100644 index 00000000..a71700f5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp @@ -0,0 +1,900 @@ +#include "btInternalEdgeUtility.h" + +#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" +#include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h" + +#include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h" +#include "BulletCollision/CollisionShapes/btTriangleShape.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" +#include "LinearMath/btIDebugDraw.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +//#define DEBUG_INTERNAL_EDGE + +#ifdef DEBUG_INTERNAL_EDGE +#include +#endif //DEBUG_INTERNAL_EDGE + +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW +static btIDebugDraw* gDebugDrawer = 0; + +void btSetDebugDrawer(btIDebugDraw* debugDrawer) +{ + gDebugDrawer = debugDrawer; +} + +static void btDebugDrawLine(const btVector3& from, const btVector3& to, const btVector3& color) +{ + if (gDebugDrawer) + gDebugDrawer->drawLine(from, to, color); +} +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + +static int btGetHash(int partId, int triangleIndex) +{ + int hash = (partId << (31 - MAX_NUM_PARTS_IN_BITS)) | triangleIndex; + return hash; +} + +static btScalar btGetAngle(const btVector3& edgeA, const btVector3& normalA, const btVector3& normalB) +{ + const btVector3 refAxis0 = edgeA; + const btVector3 refAxis1 = normalA; + const btVector3 swingAxis = normalB; + btScalar angle = btAtan2(swingAxis.dot(refAxis0), swingAxis.dot(refAxis1)); + return angle; +} + +struct btConnectivityProcessor : public btTriangleCallback +{ + int m_partIdA; + int m_triangleIndexA; + btVector3* m_triangleVerticesA; + btTriangleInfoMap* m_triangleInfoMap; + + virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex) + { + //skip self-collisions + if ((m_partIdA == partId) && (m_triangleIndexA == triangleIndex)) + return; + + //skip duplicates (disabled for now) + //if ((m_partIdA <= partId) && (m_triangleIndexA <= triangleIndex)) + // return; + + //search for shared vertices and edges + int numshared = 0; + int sharedVertsA[3] = {-1, -1, -1}; + int sharedVertsB[3] = {-1, -1, -1}; + + ///skip degenerate triangles + btScalar crossBSqr = ((triangle[1] - triangle[0]).cross(triangle[2] - triangle[0])).length2(); + if (crossBSqr < m_triangleInfoMap->m_equalVertexThreshold) + return; + + btScalar crossASqr = ((m_triangleVerticesA[1] - m_triangleVerticesA[0]).cross(m_triangleVerticesA[2] - m_triangleVerticesA[0])).length2(); + ///skip degenerate triangles + if (crossASqr < m_triangleInfoMap->m_equalVertexThreshold) + return; + +#if 0 + printf("triangle A[0] = (%f,%f,%f)\ntriangle A[1] = (%f,%f,%f)\ntriangle A[2] = (%f,%f,%f)\n", + m_triangleVerticesA[0].getX(),m_triangleVerticesA[0].getY(),m_triangleVerticesA[0].getZ(), + m_triangleVerticesA[1].getX(),m_triangleVerticesA[1].getY(),m_triangleVerticesA[1].getZ(), + m_triangleVerticesA[2].getX(),m_triangleVerticesA[2].getY(),m_triangleVerticesA[2].getZ()); + + printf("partId=%d, triangleIndex=%d\n",partId,triangleIndex); + printf("triangle B[0] = (%f,%f,%f)\ntriangle B[1] = (%f,%f,%f)\ntriangle B[2] = (%f,%f,%f)\n", + triangle[0].getX(),triangle[0].getY(),triangle[0].getZ(), + triangle[1].getX(),triangle[1].getY(),triangle[1].getZ(), + triangle[2].getX(),triangle[2].getY(),triangle[2].getZ()); +#endif + + for (int i = 0; i < 3; i++) + { + for (int j = 0; j < 3; j++) + { + if ((m_triangleVerticesA[i] - triangle[j]).length2() < m_triangleInfoMap->m_equalVertexThreshold) + { + sharedVertsA[numshared] = i; + sharedVertsB[numshared] = j; + numshared++; + ///degenerate case + if (numshared >= 3) + return; + } + } + ///degenerate case + if (numshared >= 3) + return; + } + switch (numshared) + { + case 0: + { + break; + } + case 1: + { + //shared vertex + break; + } + case 2: + { + //shared edge + //we need to make sure the edge is in the order V2V0 and not V0V2 so that the signs are correct + if (sharedVertsA[0] == 0 && sharedVertsA[1] == 2) + { + sharedVertsA[0] = 2; + sharedVertsA[1] = 0; + int tmp = sharedVertsB[1]; + sharedVertsB[1] = sharedVertsB[0]; + sharedVertsB[0] = tmp; + } + + int hash = btGetHash(m_partIdA, m_triangleIndexA); + + btTriangleInfo* info = m_triangleInfoMap->find(hash); + if (!info) + { + btTriangleInfo tmp; + m_triangleInfoMap->insert(hash, tmp); + info = m_triangleInfoMap->find(hash); + } + + int sumvertsA = sharedVertsA[0] + sharedVertsA[1]; + int otherIndexA = 3 - sumvertsA; + + btVector3 edge(m_triangleVerticesA[sharedVertsA[1]] - m_triangleVerticesA[sharedVertsA[0]]); + + btTriangleShape tA(m_triangleVerticesA[0], m_triangleVerticesA[1], m_triangleVerticesA[2]); + int otherIndexB = 3 - (sharedVertsB[0] + sharedVertsB[1]); + + btTriangleShape tB(triangle[sharedVertsB[1]], triangle[sharedVertsB[0]], triangle[otherIndexB]); + //btTriangleShape tB(triangle[0],triangle[1],triangle[2]); + + btVector3 normalA; + btVector3 normalB; + tA.calcNormal(normalA); + tB.calcNormal(normalB); + edge.normalize(); + btVector3 edgeCrossA = edge.cross(normalA).normalize(); + + { + btVector3 tmp = m_triangleVerticesA[otherIndexA] - m_triangleVerticesA[sharedVertsA[0]]; + if (edgeCrossA.dot(tmp) < 0) + { + edgeCrossA *= -1; + } + } + + btVector3 edgeCrossB = edge.cross(normalB).normalize(); + + { + btVector3 tmp = triangle[otherIndexB] - triangle[sharedVertsB[0]]; + if (edgeCrossB.dot(tmp) < 0) + { + edgeCrossB *= -1; + } + } + + btScalar angle2 = 0; + btScalar ang4 = 0.f; + + btVector3 calculatedEdge = edgeCrossA.cross(edgeCrossB); + btScalar len2 = calculatedEdge.length2(); + + btScalar correctedAngle(0); + //btVector3 calculatedNormalB = normalA; + bool isConvex = false; + + if (len2 < m_triangleInfoMap->m_planarEpsilon) + { + angle2 = 0.f; + ang4 = 0.f; + } + else + { + calculatedEdge.normalize(); + btVector3 calculatedNormalA = calculatedEdge.cross(edgeCrossA); + calculatedNormalA.normalize(); + angle2 = btGetAngle(calculatedNormalA, edgeCrossA, edgeCrossB); + ang4 = SIMD_PI - angle2; + btScalar dotA = normalA.dot(edgeCrossB); + ///@todo: check if we need some epsilon, due to floating point imprecision + isConvex = (dotA < 0.); + + correctedAngle = isConvex ? ang4 : -ang4; + } + + //alternatively use + //btVector3 calculatedNormalB2 = quatRotate(orn,normalA); + + switch (sumvertsA) + { + case 1: + { + btVector3 edge = m_triangleVerticesA[0] - m_triangleVerticesA[1]; + btQuaternion orn(edge, -correctedAngle); + btVector3 computedNormalB = quatRotate(orn, normalA); + btScalar bla = computedNormalB.dot(normalB); + if (bla < 0) + { + computedNormalB *= -1; + info->m_flags |= TRI_INFO_V0V1_SWAP_NORMALB; + } +#ifdef DEBUG_INTERNAL_EDGE + if ((computedNormalB - normalB).length() > 0.0001) + { + printf("warning: normals not identical\n"); + } +#endif //DEBUG_INTERNAL_EDGE + + info->m_edgeV0V1Angle = -correctedAngle; + + if (isConvex) + info->m_flags |= TRI_INFO_V0V1_CONVEX; + break; + } + case 2: + { + btVector3 edge = m_triangleVerticesA[2] - m_triangleVerticesA[0]; + btQuaternion orn(edge, -correctedAngle); + btVector3 computedNormalB = quatRotate(orn, normalA); + if (computedNormalB.dot(normalB) < 0) + { + computedNormalB *= -1; + info->m_flags |= TRI_INFO_V2V0_SWAP_NORMALB; + } + +#ifdef DEBUG_INTERNAL_EDGE + if ((computedNormalB - normalB).length() > 0.0001) + { + printf("warning: normals not identical\n"); + } +#endif //DEBUG_INTERNAL_EDGE + info->m_edgeV2V0Angle = -correctedAngle; + if (isConvex) + info->m_flags |= TRI_INFO_V2V0_CONVEX; + break; + } + case 3: + { + btVector3 edge = m_triangleVerticesA[1] - m_triangleVerticesA[2]; + btQuaternion orn(edge, -correctedAngle); + btVector3 computedNormalB = quatRotate(orn, normalA); + if (computedNormalB.dot(normalB) < 0) + { + info->m_flags |= TRI_INFO_V1V2_SWAP_NORMALB; + computedNormalB *= -1; + } +#ifdef DEBUG_INTERNAL_EDGE + if ((computedNormalB - normalB).length() > 0.0001) + { + printf("warning: normals not identical\n"); + } +#endif //DEBUG_INTERNAL_EDGE + info->m_edgeV1V2Angle = -correctedAngle; + + if (isConvex) + info->m_flags |= TRI_INFO_V1V2_CONVEX; + break; + } + } + + break; + } + default: + { + // printf("warning: duplicate triangle\n"); + } + } + } +}; + + +struct b3ProcessAllTrianglesHeightfield: public btTriangleCallback +{ + btHeightfieldTerrainShape* m_heightfieldShape; + btTriangleInfoMap* m_triangleInfoMap; + + + b3ProcessAllTrianglesHeightfield(btHeightfieldTerrainShape* heightFieldShape, btTriangleInfoMap* triangleInfoMap) + :m_heightfieldShape(heightFieldShape), + m_triangleInfoMap(triangleInfoMap) + { + } + virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex) + { + btConnectivityProcessor connectivityProcessor; + connectivityProcessor.m_partIdA = partId; + connectivityProcessor.m_triangleIndexA = triangleIndex; + connectivityProcessor.m_triangleVerticesA = triangle; + connectivityProcessor.m_triangleInfoMap = m_triangleInfoMap; + btVector3 aabbMin, aabbMax; + aabbMin.setValue(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + aabbMax.setValue(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + aabbMin.setMin(triangle[0]); + aabbMax.setMax(triangle[0]); + aabbMin.setMin(triangle[1]); + aabbMax.setMax(triangle[1]); + aabbMin.setMin(triangle[2]); + aabbMax.setMax(triangle[2]); + + m_heightfieldShape->processAllTriangles(&connectivityProcessor, aabbMin, aabbMax); + } +}; +///////////////////////////////////////////////////////// +///////////////////////////////////////////////////////// + +void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape* trimeshShape, btTriangleInfoMap* triangleInfoMap) +{ + //the user pointer shouldn't already be used for other purposes, we intend to store connectivity info there! + if (trimeshShape->getTriangleInfoMap()) + return; + + trimeshShape->setTriangleInfoMap(triangleInfoMap); + + btStridingMeshInterface* meshInterface = trimeshShape->getMeshInterface(); + const btVector3& meshScaling = meshInterface->getScaling(); + + for (int partId = 0; partId < meshInterface->getNumSubParts(); partId++) + { + const unsigned char* vertexbase = 0; + int numverts = 0; + PHY_ScalarType type = PHY_INTEGER; + int stride = 0; + const unsigned char* indexbase = 0; + int indexstride = 0; + int numfaces = 0; + PHY_ScalarType indicestype = PHY_INTEGER; + //PHY_ScalarType indexType=0; + + btVector3 triangleVerts[3]; + meshInterface->getLockedReadOnlyVertexIndexBase(&vertexbase, numverts, type, stride, &indexbase, indexstride, numfaces, indicestype, partId); + btVector3 aabbMin, aabbMax; + + for (int triangleIndex = 0; triangleIndex < numfaces; triangleIndex++) + { + unsigned int* gfxbase = (unsigned int*)(indexbase + triangleIndex * indexstride); + + for (int j = 2; j >= 0; j--) + { + int graphicsindex; + switch (indicestype) { + case PHY_INTEGER: graphicsindex = gfxbase[j]; break; + case PHY_SHORT: graphicsindex = ((unsigned short*)gfxbase)[j]; break; + case PHY_UCHAR: graphicsindex = ((unsigned char*)gfxbase)[j]; break; + default: btAssert(0); + } + if (type == PHY_FLOAT) + { + float* graphicsbase = (float*)(vertexbase + graphicsindex * stride); + triangleVerts[j] = btVector3( + graphicsbase[0] * meshScaling.getX(), + graphicsbase[1] * meshScaling.getY(), + graphicsbase[2] * meshScaling.getZ()); + } + else + { + double* graphicsbase = (double*)(vertexbase + graphicsindex * stride); + triangleVerts[j] = btVector3(btScalar(graphicsbase[0] * meshScaling.getX()), btScalar(graphicsbase[1] * meshScaling.getY()), btScalar(graphicsbase[2] * meshScaling.getZ())); + } + } + aabbMin.setValue(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + aabbMax.setValue(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + aabbMin.setMin(triangleVerts[0]); + aabbMax.setMax(triangleVerts[0]); + aabbMin.setMin(triangleVerts[1]); + aabbMax.setMax(triangleVerts[1]); + aabbMin.setMin(triangleVerts[2]); + aabbMax.setMax(triangleVerts[2]); + + btConnectivityProcessor connectivityProcessor; + connectivityProcessor.m_partIdA = partId; + connectivityProcessor.m_triangleIndexA = triangleIndex; + connectivityProcessor.m_triangleVerticesA = &triangleVerts[0]; + connectivityProcessor.m_triangleInfoMap = triangleInfoMap; + + trimeshShape->processAllTriangles(&connectivityProcessor, aabbMin, aabbMax); + } + } +} + + +void btGenerateInternalEdgeInfo(btHeightfieldTerrainShape* heightfieldShape, btTriangleInfoMap* triangleInfoMap) +{ + + //the user pointer shouldn't already be used for other purposes, we intend to store connectivity info there! + if (heightfieldShape->getTriangleInfoMap()) + return; + + heightfieldShape->setTriangleInfoMap(triangleInfoMap); + + //get all the triangles of the heightfield + + btVector3 aabbMin, aabbMax; + + aabbMax.setValue(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + aabbMin.setValue(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + + b3ProcessAllTrianglesHeightfield processHeightfield(heightfieldShape, triangleInfoMap); + heightfieldShape->processAllTriangles(&processHeightfield, aabbMin, aabbMax); + +} + +// Given a point and a line segment (defined by two points), compute the closest point +// in the line. Cap the point at the endpoints of the line segment. +void btNearestPointInLineSegment(const btVector3& point, const btVector3& line0, const btVector3& line1, btVector3& nearestPoint) +{ + btVector3 lineDelta = line1 - line0; + + // Handle degenerate lines + if (lineDelta.fuzzyZero()) + { + nearestPoint = line0; + } + else + { + btScalar delta = (point - line0).dot(lineDelta) / (lineDelta).dot(lineDelta); + + // Clamp the point to conform to the segment's endpoints + if (delta < 0) + delta = 0; + else if (delta > 1) + delta = 1; + + nearestPoint = line0 + lineDelta * delta; + } +} + +bool btClampNormal(const btVector3& edge, const btVector3& tri_normal_org, const btVector3& localContactNormalOnB, btScalar correctedEdgeAngle, btVector3& clampedLocalNormal) +{ + btVector3 tri_normal = tri_normal_org; + //we only have a local triangle normal, not a local contact normal -> only normal in world space... + //either compute the current angle all in local space, or all in world space + + btVector3 edgeCross = edge.cross(tri_normal).normalize(); + btScalar curAngle = btGetAngle(edgeCross, tri_normal, localContactNormalOnB); + + if (correctedEdgeAngle < 0) + { + if (curAngle < correctedEdgeAngle) + { + btScalar diffAngle = correctedEdgeAngle - curAngle; + btQuaternion rotation(edge, diffAngle); + clampedLocalNormal = btMatrix3x3(rotation) * localContactNormalOnB; + return true; + } + } + + if (correctedEdgeAngle >= 0) + { + if (curAngle > correctedEdgeAngle) + { + btScalar diffAngle = correctedEdgeAngle - curAngle; + btQuaternion rotation(edge, diffAngle); + clampedLocalNormal = btMatrix3x3(rotation) * localContactNormalOnB; + return true; + } + } + return false; +} + +/// Changes a btManifoldPoint collision normal to the normal from the mesh. +void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap, const btCollisionObjectWrapper* colObj1Wrap, int partId0, int index0, int normalAdjustFlags) +{ + //btAssert(colObj0->getCollisionShape()->getShapeType() == TRIANGLE_SHAPE_PROXYTYPE); + if (colObj0Wrap->getCollisionShape()->getShapeType() != TRIANGLE_SHAPE_PROXYTYPE) + return; + + + btTriangleInfoMap* triangleInfoMapPtr = 0; + + if (colObj0Wrap->getCollisionObject()->getCollisionShape()->getShapeType() == TERRAIN_SHAPE_PROXYTYPE) + { + btHeightfieldTerrainShape* heightfield = (btHeightfieldTerrainShape*)colObj0Wrap->getCollisionObject()->getCollisionShape(); + triangleInfoMapPtr = heightfield->getTriangleInfoMap(); + +//#define USE_HEIGHTFIELD_TRIANGLES +#ifdef USE_HEIGHTFIELD_TRIANGLES + btVector3 newNormal = btVector3(0, 0, 1); + + const btTriangleShape* tri_shape = static_cast(colObj0Wrap->getCollisionShape()); + btVector3 tri_normal; + tri_shape->calcNormal(tri_normal); + newNormal = tri_normal; + // cp.m_distance1 = cp.m_distance1 * newNormal.dot(cp.m_normalWorldOnB); + cp.m_normalWorldOnB = newNormal; + // Reproject collision point along normal. (what about cp.m_distance1?) + cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1; + cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB); + return; +#endif + } + + + btBvhTriangleMeshShape* trimesh = 0; + + if (colObj0Wrap->getCollisionObject()->getCollisionShape()->getShapeType() == SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE) + { + trimesh = ((btScaledBvhTriangleMeshShape*)colObj0Wrap->getCollisionObject()->getCollisionShape())->getChildShape(); + } + else + { + if (colObj0Wrap->getCollisionObject()->getCollisionShape()->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE) + { + trimesh = (btBvhTriangleMeshShape*)colObj0Wrap->getCollisionObject()->getCollisionShape(); + } + } + if (trimesh) + { + triangleInfoMapPtr = (btTriangleInfoMap*)trimesh->getTriangleInfoMap(); + } + + + if (!triangleInfoMapPtr) + return; + + int hash = btGetHash(partId0, index0); + + btTriangleInfo* info = triangleInfoMapPtr->find(hash); + if (!info) + return; + + btScalar frontFacing = (normalAdjustFlags & BT_TRIANGLE_CONVEX_BACKFACE_MODE) == 0 ? 1.f : -1.f; + + const btTriangleShape* tri_shape = static_cast(colObj0Wrap->getCollisionShape()); + btVector3 v0, v1, v2; + tri_shape->getVertex(0, v0); + tri_shape->getVertex(1, v1); + tri_shape->getVertex(2, v2); + + //btVector3 center = (v0+v1+v2)*btScalar(1./3.); + + btVector3 red(1, 0, 0), green(0, 1, 0), blue(0, 0, 1), white(1, 1, 1), black(0, 0, 0); + btVector3 tri_normal; + tri_shape->calcNormal(tri_normal); + + //btScalar dot = tri_normal.dot(cp.m_normalWorldOnB); + btVector3 nearest; + btNearestPointInLineSegment(cp.m_localPointB, v0, v1, nearest); + + btVector3 contact = cp.m_localPointB; +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + const btTransform& tr = colObj0->getWorldTransform(); + btDebugDrawLine(tr * nearest, tr * cp.m_localPointB, red); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + + bool isNearEdge = false; + + int numConcaveEdgeHits = 0; + int numConvexEdgeHits = 0; + + btVector3 localContactNormalOnB = colObj0Wrap->getWorldTransform().getBasis().transpose() * cp.m_normalWorldOnB; + localContactNormalOnB.normalize(); //is this necessary? + + // Get closest edge + int bestedge = -1; + btScalar disttobestedge = BT_LARGE_FLOAT; + // + // Edge 0 -> 1 + if (btFabs(info->m_edgeV0V1Angle) < triangleInfoMapPtr->m_maxEdgeAngleThreshold) + { + btVector3 nearest; + btNearestPointInLineSegment(cp.m_localPointB, v0, v1, nearest); + btScalar len = (contact - nearest).length(); + // + if (len < disttobestedge) + { + bestedge = 0; + disttobestedge = len; + } + } + // Edge 1 -> 2 + if (btFabs(info->m_edgeV1V2Angle) < triangleInfoMapPtr->m_maxEdgeAngleThreshold) + { + btVector3 nearest; + btNearestPointInLineSegment(cp.m_localPointB, v1, v2, nearest); + btScalar len = (contact - nearest).length(); + // + if (len < disttobestedge) + { + bestedge = 1; + disttobestedge = len; + } + } + // Edge 2 -> 0 + if (btFabs(info->m_edgeV2V0Angle) < triangleInfoMapPtr->m_maxEdgeAngleThreshold) + { + btVector3 nearest; + btNearestPointInLineSegment(cp.m_localPointB, v2, v0, nearest); + btScalar len = (contact - nearest).length(); + // + if (len < disttobestedge) + { + bestedge = 2; + disttobestedge = len; + } + } + +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btVector3 upfix = tri_normal * btVector3(0.1f, 0.1f, 0.1f); + btDebugDrawLine(tr * v0 + upfix, tr * v1 + upfix, red); +#endif + if (btFabs(info->m_edgeV0V1Angle) < triangleInfoMapPtr->m_maxEdgeAngleThreshold) + { +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * contact, tr * (contact + cp.m_normalWorldOnB * 10), black); +#endif + btScalar len = (contact - nearest).length(); + if (len < triangleInfoMapPtr->m_edgeDistanceThreshold) + if (bestedge == 0) + { + btVector3 edge(v0 - v1); + isNearEdge = true; + + if (info->m_edgeV0V1Angle == btScalar(0)) + { + numConcaveEdgeHits++; + } + else + { + bool isEdgeConvex = (info->m_flags & TRI_INFO_V0V1_CONVEX); + btScalar swapFactor = isEdgeConvex ? btScalar(1) : btScalar(-1); +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * nearest, tr * (nearest + swapFactor * tri_normal * 10), white); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + + btVector3 nA = swapFactor * tri_normal; + + btQuaternion orn(edge, info->m_edgeV0V1Angle); + btVector3 computedNormalB = quatRotate(orn, tri_normal); + if (info->m_flags & TRI_INFO_V0V1_SWAP_NORMALB) + computedNormalB *= -1; + btVector3 nB = swapFactor * computedNormalB; + + btScalar NdotA = localContactNormalOnB.dot(nA); + btScalar NdotB = localContactNormalOnB.dot(nB); + bool backFacingNormal = (NdotA < triangleInfoMapPtr->m_convexEpsilon) && (NdotB < triangleInfoMapPtr->m_convexEpsilon); + +#ifdef DEBUG_INTERNAL_EDGE + { + btDebugDrawLine(cp.getPositionWorldOnB(), cp.getPositionWorldOnB() + tr.getBasis() * (nB * 20), red); + } +#endif //DEBUG_INTERNAL_EDGE + + if (backFacingNormal) + { + numConcaveEdgeHits++; + } + else + { + numConvexEdgeHits++; + btVector3 clampedLocalNormal; + bool isClamped = btClampNormal(edge, swapFactor * tri_normal, localContactNormalOnB, info->m_edgeV0V1Angle, clampedLocalNormal); + if (isClamped) + { + if (((normalAdjustFlags & BT_TRIANGLE_CONVEX_DOUBLE_SIDED) != 0) || (clampedLocalNormal.dot(frontFacing * tri_normal) > 0)) + { + btVector3 newNormal = colObj0Wrap->getWorldTransform().getBasis() * clampedLocalNormal; + // cp.m_distance1 = cp.m_distance1 * newNormal.dot(cp.m_normalWorldOnB); + cp.m_normalWorldOnB = newNormal; + // Reproject collision point along normal. (what about cp.m_distance1?) + cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1; + cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB); + } + } + } + } + } + } + + btNearestPointInLineSegment(contact, v1, v2, nearest); +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * nearest, tr * cp.m_localPointB, green); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * v1 + upfix, tr * v2 + upfix, green); +#endif + + if (btFabs(info->m_edgeV1V2Angle) < triangleInfoMapPtr->m_maxEdgeAngleThreshold) + { +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * contact, tr * (contact + cp.m_normalWorldOnB * 10), black); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + + btScalar len = (contact - nearest).length(); + if (len < triangleInfoMapPtr->m_edgeDistanceThreshold) + if (bestedge == 1) + { + isNearEdge = true; +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * nearest, tr * (nearest + tri_normal * 10), white); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + + btVector3 edge(v1 - v2); + + isNearEdge = true; + + if (info->m_edgeV1V2Angle == btScalar(0)) + { + numConcaveEdgeHits++; + } + else + { + bool isEdgeConvex = (info->m_flags & TRI_INFO_V1V2_CONVEX) != 0; + btScalar swapFactor = isEdgeConvex ? btScalar(1) : btScalar(-1); +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * nearest, tr * (nearest + swapFactor * tri_normal * 10), white); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + + btVector3 nA = swapFactor * tri_normal; + + btQuaternion orn(edge, info->m_edgeV1V2Angle); + btVector3 computedNormalB = quatRotate(orn, tri_normal); + if (info->m_flags & TRI_INFO_V1V2_SWAP_NORMALB) + computedNormalB *= -1; + btVector3 nB = swapFactor * computedNormalB; + +#ifdef DEBUG_INTERNAL_EDGE + { + btDebugDrawLine(cp.getPositionWorldOnB(), cp.getPositionWorldOnB() + tr.getBasis() * (nB * 20), red); + } +#endif //DEBUG_INTERNAL_EDGE + + btScalar NdotA = localContactNormalOnB.dot(nA); + btScalar NdotB = localContactNormalOnB.dot(nB); + bool backFacingNormal = (NdotA < triangleInfoMapPtr->m_convexEpsilon) && (NdotB < triangleInfoMapPtr->m_convexEpsilon); + + if (backFacingNormal) + { + numConcaveEdgeHits++; + } + else + { + numConvexEdgeHits++; + btVector3 localContactNormalOnB = colObj0Wrap->getWorldTransform().getBasis().transpose() * cp.m_normalWorldOnB; + btVector3 clampedLocalNormal; + bool isClamped = btClampNormal(edge, swapFactor * tri_normal, localContactNormalOnB, info->m_edgeV1V2Angle, clampedLocalNormal); + if (isClamped) + { + if (((normalAdjustFlags & BT_TRIANGLE_CONVEX_DOUBLE_SIDED) != 0) || (clampedLocalNormal.dot(frontFacing * tri_normal) > 0)) + { + btVector3 newNormal = colObj0Wrap->getWorldTransform().getBasis() * clampedLocalNormal; + // cp.m_distance1 = cp.m_distance1 * newNormal.dot(cp.m_normalWorldOnB); + cp.m_normalWorldOnB = newNormal; + // Reproject collision point along normal. + cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1; + cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB); + } + } + } + } + } + } + + btNearestPointInLineSegment(contact, v2, v0, nearest); +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * nearest, tr * cp.m_localPointB, blue); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * v2 + upfix, tr * v0 + upfix, blue); +#endif + + if (btFabs(info->m_edgeV2V0Angle) < triangleInfoMapPtr->m_maxEdgeAngleThreshold) + { +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * contact, tr * (contact + cp.m_normalWorldOnB * 10), black); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + + btScalar len = (contact - nearest).length(); + if (len < triangleInfoMapPtr->m_edgeDistanceThreshold) + if (bestedge == 2) + { + isNearEdge = true; +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * nearest, tr * (nearest + tri_normal * 10), white); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + + btVector3 edge(v2 - v0); + + if (info->m_edgeV2V0Angle == btScalar(0)) + { + numConcaveEdgeHits++; + } + else + { + bool isEdgeConvex = (info->m_flags & TRI_INFO_V2V0_CONVEX) != 0; + btScalar swapFactor = isEdgeConvex ? btScalar(1) : btScalar(-1); +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW + btDebugDrawLine(tr * nearest, tr * (nearest + swapFactor * tri_normal * 10), white); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + + btVector3 nA = swapFactor * tri_normal; + btQuaternion orn(edge, info->m_edgeV2V0Angle); + btVector3 computedNormalB = quatRotate(orn, tri_normal); + if (info->m_flags & TRI_INFO_V2V0_SWAP_NORMALB) + computedNormalB *= -1; + btVector3 nB = swapFactor * computedNormalB; + +#ifdef DEBUG_INTERNAL_EDGE + { + btDebugDrawLine(cp.getPositionWorldOnB(), cp.getPositionWorldOnB() + tr.getBasis() * (nB * 20), red); + } +#endif //DEBUG_INTERNAL_EDGE + + btScalar NdotA = localContactNormalOnB.dot(nA); + btScalar NdotB = localContactNormalOnB.dot(nB); + bool backFacingNormal = (NdotA < triangleInfoMapPtr->m_convexEpsilon) && (NdotB < triangleInfoMapPtr->m_convexEpsilon); + + if (backFacingNormal) + { + numConcaveEdgeHits++; + } + else + { + numConvexEdgeHits++; + // printf("hitting convex edge\n"); + + btVector3 localContactNormalOnB = colObj0Wrap->getWorldTransform().getBasis().transpose() * cp.m_normalWorldOnB; + btVector3 clampedLocalNormal; + bool isClamped = btClampNormal(edge, swapFactor * tri_normal, localContactNormalOnB, info->m_edgeV2V0Angle, clampedLocalNormal); + if (isClamped) + { + if (((normalAdjustFlags & BT_TRIANGLE_CONVEX_DOUBLE_SIDED) != 0) || (clampedLocalNormal.dot(frontFacing * tri_normal) > 0)) + { + btVector3 newNormal = colObj0Wrap->getWorldTransform().getBasis() * clampedLocalNormal; + // cp.m_distance1 = cp.m_distance1 * newNormal.dot(cp.m_normalWorldOnB); + cp.m_normalWorldOnB = newNormal; + // Reproject collision point along normal. + cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1; + cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB); + } + } + } + } + } + } + +#ifdef DEBUG_INTERNAL_EDGE + { + btVector3 color(0, 1, 1); + btDebugDrawLine(cp.getPositionWorldOnB(), cp.getPositionWorldOnB() + cp.m_normalWorldOnB * 10, color); + } +#endif //DEBUG_INTERNAL_EDGE + + if (isNearEdge) + { + if (numConcaveEdgeHits > 0) + { + if ((normalAdjustFlags & BT_TRIANGLE_CONCAVE_DOUBLE_SIDED) != 0) + { + //fix tri_normal so it pointing the same direction as the current local contact normal + if (tri_normal.dot(localContactNormalOnB) < 0) + { + tri_normal *= -1; + } + cp.m_normalWorldOnB = colObj0Wrap->getWorldTransform().getBasis() * tri_normal; + } + else + { + btVector3 newNormal = tri_normal * frontFacing; + //if the tri_normal is pointing opposite direction as the current local contact normal, skip it + btScalar d = newNormal.dot(localContactNormalOnB); + if (d < 0) + { + return; + } + //modify the normal to be the triangle normal (or backfacing normal) + cp.m_normalWorldOnB = colObj0Wrap->getWorldTransform().getBasis() * newNormal; + } + + // Reproject collision point along normal. + cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1; + cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB); + } + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp.i new file mode 100644 index 00000000..1124f264 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.h new file mode 100644 index 00000000..cc6d11c2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.h @@ -0,0 +1,44 @@ + +#ifndef BT_INTERNAL_EDGE_UTILITY_H +#define BT_INTERNAL_EDGE_UTILITY_H + +#include "LinearMath/btHashMap.h" +#include "LinearMath/btVector3.h" + +#include "BulletCollision/CollisionShapes/btTriangleInfoMap.h" + +///The btInternalEdgeUtility helps to avoid or reduce artifacts due to wrong collision normals caused by internal edges. +///See also http://code.google.com/p/bullet/issues/detail?id=27 + +class btBvhTriangleMeshShape; +class btCollisionObject; +struct btCollisionObjectWrapper; +class btManifoldPoint; +class btIDebugDraw; +class btHeightfieldTerrainShape; + +enum btInternalEdgeAdjustFlags +{ + BT_TRIANGLE_CONVEX_BACKFACE_MODE = 1, + BT_TRIANGLE_CONCAVE_DOUBLE_SIDED = 2, //double sided options are experimental, single sided is recommended + BT_TRIANGLE_CONVEX_DOUBLE_SIDED = 4 +}; + +///Call btGenerateInternalEdgeInfo to create triangle info, store in the shape 'userInfo' +void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape* trimeshShape, btTriangleInfoMap* triangleInfoMap); + +void btGenerateInternalEdgeInfo(btHeightfieldTerrainShape* trimeshShape, btTriangleInfoMap* triangleInfoMap); + +///Call the btFixMeshNormal to adjust the collision normal, using the triangle info map (generated using btGenerateInternalEdgeInfo) +///If this info map is missing, or the triangle is not store in this map, nothing will be done +void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWrapper* trimeshColObj0Wrap, const btCollisionObjectWrapper* otherColObj1Wrap, int partId0, int index0, int normalAdjustFlags = 0); + +///Enable the BT_INTERNAL_EDGE_DEBUG_DRAW define and call btSetDebugDrawer, to get visual info to see if the internal edge utility works properly. +///If the utility doesn't work properly, you might have to adjust the threshold values in btTriangleInfoMap +//#define BT_INTERNAL_EDGE_DEBUG_DRAW + +#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW +void btSetDebugDrawer(btIDebugDraw* debugDrawer); +#endif //BT_INTERNAL_EDGE_DEBUG_DRAW + +#endif //BT_INTERNAL_EDGE_UTILITY_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.h.i new file mode 100644 index 00000000..a1e42535 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btInternalEdgeUtility.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btInternalEdgeUtility.h ---------------- + +%include "BulletCollision/CollisionDispatch/btInternalEdgeUtility.h" + +%{ +#include "BulletCollision/CollisionDispatch/btInternalEdgeUtility.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.cpp new file mode 100644 index 00000000..64a0f84f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.cpp @@ -0,0 +1,201 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btManifoldResult.h" +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +///This is to allow MaterialCombiner/Custom Friction/Restitution values +ContactAddedCallback gContactAddedCallback = 0; + +CalculateCombinedCallback gCalculateCombinedRestitutionCallback = &btManifoldResult::calculateCombinedRestitution; +CalculateCombinedCallback gCalculateCombinedFrictionCallback = &btManifoldResult::calculateCombinedFriction; +CalculateCombinedCallback gCalculateCombinedRollingFrictionCallback = &btManifoldResult::calculateCombinedRollingFriction; +CalculateCombinedCallback gCalculateCombinedSpinningFrictionCallback = &btManifoldResult::calculateCombinedSpinningFriction; +CalculateCombinedCallback gCalculateCombinedContactDampingCallback = &btManifoldResult::calculateCombinedContactDamping; +CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback = &btManifoldResult::calculateCombinedContactStiffness; + +btScalar btManifoldResult::calculateCombinedRollingFriction(const btCollisionObject* body0, const btCollisionObject* body1) +{ + btScalar friction = body0->getRollingFriction() * body1->getFriction() + body1->getRollingFriction() * body0->getFriction(); + + const btScalar MAX_FRICTION = btScalar(10.); + if (friction < -MAX_FRICTION) + friction = -MAX_FRICTION; + if (friction > MAX_FRICTION) + friction = MAX_FRICTION; + return friction; +} + +btScalar btManifoldResult::calculateCombinedSpinningFriction(const btCollisionObject* body0, const btCollisionObject* body1) +{ + btScalar friction = body0->getSpinningFriction() * body1->getFriction() + body1->getSpinningFriction() * body0->getFriction(); + + const btScalar MAX_FRICTION = btScalar(10.); + if (friction < -MAX_FRICTION) + friction = -MAX_FRICTION; + if (friction > MAX_FRICTION) + friction = MAX_FRICTION; + return friction; +} + +///User can override this material combiner by implementing gContactAddedCallback and setting body0->m_collisionFlags |= btCollisionObject::customMaterialCallback; +btScalar btManifoldResult::calculateCombinedFriction(const btCollisionObject* body0, const btCollisionObject* body1) +{ + btScalar friction = body0->getFriction() * body1->getFriction(); + + const btScalar MAX_FRICTION = btScalar(10.); + if (friction < -MAX_FRICTION) + friction = -MAX_FRICTION; + if (friction > MAX_FRICTION) + friction = MAX_FRICTION; + return friction; +} + +btScalar btManifoldResult::calculateCombinedRestitution(const btCollisionObject* body0, const btCollisionObject* body1) +{ + return body0->getRestitution() * body1->getRestitution(); +} + +btScalar btManifoldResult::calculateCombinedContactDamping(const btCollisionObject* body0, const btCollisionObject* body1) +{ + return body0->getContactDamping() + body1->getContactDamping(); +} + +btScalar btManifoldResult::calculateCombinedContactStiffness(const btCollisionObject* body0, const btCollisionObject* body1) +{ + btScalar s0 = body0->getContactStiffness(); + btScalar s1 = body1->getContactStiffness(); + + btScalar tmp0 = btScalar(1) / s0; + btScalar tmp1 = btScalar(1) / s1; + btScalar combinedStiffness = btScalar(1) / (tmp0 + tmp1); + return combinedStiffness; +} + +btManifoldResult::btManifoldResult(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + : m_manifoldPtr(0), + m_body0Wrap(body0Wrap), + m_body1Wrap(body1Wrap) + , + m_partId0(-1), + m_partId1(-1), + m_index0(-1), + m_index1(-1) + , + m_closestPointDistanceThreshold(0) +{ +} + +void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth) +{ + btAssert(m_manifoldPtr); + //order in manifold needs to match + + if (depth > m_manifoldPtr->getContactBreakingThreshold()) + // if (depth > m_manifoldPtr->getContactProcessingThreshold()) + return; + + bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject(); + bool isNewCollision = m_manifoldPtr->getNumContacts() == 0; + + btVector3 pointA = pointInWorld + normalOnBInWorld * depth; + + btVector3 localA; + btVector3 localB; + + if (isSwapped) + { + localA = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointA); + localB = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld); + } + else + { + localA = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointA); + localB = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld); + } + + btManifoldPoint newPt(localA, localB, normalOnBInWorld, depth); + newPt.m_positionWorldOnA = pointA; + newPt.m_positionWorldOnB = pointInWorld; + + int insertIndex = m_manifoldPtr->getCacheEntry(newPt); + + newPt.m_combinedFriction = gCalculateCombinedFrictionCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject()); + newPt.m_combinedRestitution = gCalculateCombinedRestitutionCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject()); + newPt.m_combinedRollingFriction = gCalculateCombinedRollingFrictionCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject()); + newPt.m_combinedSpinningFriction = gCalculateCombinedSpinningFrictionCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject()); + + if ((m_body0Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_HAS_CONTACT_STIFFNESS_DAMPING) || + (m_body1Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_HAS_CONTACT_STIFFNESS_DAMPING)) + { + newPt.m_combinedContactDamping1 = gCalculateCombinedContactDampingCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject()); + newPt.m_combinedContactStiffness1 = gCalculateCombinedContactStiffnessCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject()); + newPt.m_contactPointFlags |= BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING; + } + + if ((m_body0Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_HAS_FRICTION_ANCHOR) || + (m_body1Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_HAS_FRICTION_ANCHOR)) + { + newPt.m_contactPointFlags |= BT_CONTACT_FLAG_FRICTION_ANCHOR; + } + + btPlaneSpace1(newPt.m_normalWorldOnB, newPt.m_lateralFrictionDir1, newPt.m_lateralFrictionDir2); + + //BP mod, store contact triangles. + if (isSwapped) + { + newPt.m_partId0 = m_partId1; + newPt.m_partId1 = m_partId0; + newPt.m_index0 = m_index1; + newPt.m_index1 = m_index0; + } + else + { + newPt.m_partId0 = m_partId0; + newPt.m_partId1 = m_partId1; + newPt.m_index0 = m_index0; + newPt.m_index1 = m_index1; + } + //printf("depth=%f\n",depth); + ///@todo, check this for any side effects + if (insertIndex >= 0) + { + //const btManifoldPoint& oldPoint = m_manifoldPtr->getContactPoint(insertIndex); + m_manifoldPtr->replaceContactPoint(newPt, insertIndex); + } + else + { + insertIndex = m_manifoldPtr->addManifoldPoint(newPt); + } + + //User can override friction and/or restitution + if (gContactAddedCallback && + //and if either of the two bodies requires custom material + ((m_body0Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) || + (m_body1Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK))) + { + //experimental feature info, for per-triangle material etc. + const btCollisionObjectWrapper* obj0Wrap = isSwapped ? m_body1Wrap : m_body0Wrap; + const btCollisionObjectWrapper* obj1Wrap = isSwapped ? m_body0Wrap : m_body1Wrap; + (*gContactAddedCallback)(m_manifoldPtr->getContactPoint(insertIndex), obj0Wrap, newPt.m_partId0, newPt.m_index0, obj1Wrap, newPt.m_partId1, newPt.m_index1); + } + + if (gContactStartedCallback && isNewCollision) + { + gContactStartedCallback(m_manifoldPtr); + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.cpp.i new file mode 100644 index 00000000..76af94da --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btManifoldResult.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btManifoldResult.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btManifoldResult.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.h new file mode 100644 index 00000000..1a8f46f2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.h @@ -0,0 +1,163 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_MANIFOLD_RESULT_H +#define BT_MANIFOLD_RESULT_H + +class btCollisionObject; +struct btCollisionObjectWrapper; + +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +class btManifoldPoint; + +#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" + +#include "LinearMath/btTransform.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" + +typedef bool (*ContactAddedCallback)(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap, int partId0, int index0, const btCollisionObjectWrapper* colObj1Wrap, int partId1, int index1); +extern ContactAddedCallback gContactAddedCallback; + +//#define DEBUG_PART_INDEX 1 + +/// These callbacks are used to customize the algorith that combine restitution, friction, damping, Stiffness +typedef btScalar (*CalculateCombinedCallback)(const btCollisionObject* body0, const btCollisionObject* body1); + +extern CalculateCombinedCallback gCalculateCombinedRestitutionCallback; +extern CalculateCombinedCallback gCalculateCombinedFrictionCallback; +extern CalculateCombinedCallback gCalculateCombinedRollingFrictionCallback; +extern CalculateCombinedCallback gCalculateCombinedSpinningFrictionCallback; +extern CalculateCombinedCallback gCalculateCombinedContactDampingCallback; +extern CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback; + +///btManifoldResult is a helper class to manage contact results. +class btManifoldResult : public btDiscreteCollisionDetectorInterface::Result +{ +protected: + btPersistentManifold* m_manifoldPtr; + + const btCollisionObjectWrapper* m_body0Wrap; + const btCollisionObjectWrapper* m_body1Wrap; + int m_partId0; + int m_partId1; + int m_index0; + int m_index1; + +public: + btManifoldResult() + : +#ifdef DEBUG_PART_INDEX + + m_partId0(-1), + m_partId1(-1), + m_index0(-1), + m_index1(-1) +#endif //DEBUG_PART_INDEX + m_closestPointDistanceThreshold(0) + { + } + + btManifoldResult(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap); + + virtual ~btManifoldResult(){}; + + void setPersistentManifold(btPersistentManifold* manifoldPtr) + { + m_manifoldPtr = manifoldPtr; + } + + const btPersistentManifold* getPersistentManifold() const + { + return m_manifoldPtr; + } + btPersistentManifold* getPersistentManifold() + { + return m_manifoldPtr; + } + + virtual void setShapeIdentifiersA(int partId0, int index0) + { + m_partId0 = partId0; + m_index0 = index0; + } + + virtual void setShapeIdentifiersB(int partId1, int index1) + { + m_partId1 = partId1; + m_index1 = index1; + } + + virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth); + + SIMD_FORCE_INLINE void refreshContactPoints() + { + btAssert(m_manifoldPtr); + if (!m_manifoldPtr->getNumContacts()) + return; + + bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject(); + + if (isSwapped) + { + m_manifoldPtr->refreshContactPoints(m_body1Wrap->getCollisionObject()->getWorldTransform(), m_body0Wrap->getCollisionObject()->getWorldTransform()); + } + else + { + m_manifoldPtr->refreshContactPoints(m_body0Wrap->getCollisionObject()->getWorldTransform(), m_body1Wrap->getCollisionObject()->getWorldTransform()); + } + } + + const btCollisionObjectWrapper* getBody0Wrap() const + { + return m_body0Wrap; + } + const btCollisionObjectWrapper* getBody1Wrap() const + { + return m_body1Wrap; + } + + void setBody0Wrap(const btCollisionObjectWrapper* obj0Wrap) + { + m_body0Wrap = obj0Wrap; + } + + void setBody1Wrap(const btCollisionObjectWrapper* obj1Wrap) + { + m_body1Wrap = obj1Wrap; + } + + const btCollisionObject* getBody0Internal() const + { + return m_body0Wrap->getCollisionObject(); + } + + const btCollisionObject* getBody1Internal() const + { + return m_body1Wrap->getCollisionObject(); + } + + btScalar m_closestPointDistanceThreshold; + + /// in the future we can let the user override the methods to combine restitution and friction + static btScalar calculateCombinedRestitution(const btCollisionObject* body0, const btCollisionObject* body1); + static btScalar calculateCombinedFriction(const btCollisionObject* body0, const btCollisionObject* body1); + static btScalar calculateCombinedRollingFriction(const btCollisionObject* body0, const btCollisionObject* body1); + static btScalar calculateCombinedSpinningFriction(const btCollisionObject* body0, const btCollisionObject* body1); + static btScalar calculateCombinedContactDamping(const btCollisionObject* body0, const btCollisionObject* body1); + static btScalar calculateCombinedContactStiffness(const btCollisionObject* body0, const btCollisionObject* body1); +}; + +#endif //BT_MANIFOLD_RESULT_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.h.i new file mode 100644 index 00000000..d98d5d7c --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btManifoldResult.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btManifoldResult.h ---------------- + +%include "BulletCollision/CollisionDispatch/btManifoldResult.h" + +%{ +#include "BulletCollision/CollisionDispatch/btManifoldResult.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp new file mode 100644 index 00000000..63c9e360 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp @@ -0,0 +1,445 @@ + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "LinearMath/btScalar.h" +#include "btSimulationIslandManager.h" +#include "BulletCollision/BroadphaseCollision/btDispatcher.h" +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionDispatch/btCollisionWorld.h" + +//#include +#include "LinearMath/btQuickprof.h" + +btSimulationIslandManager::btSimulationIslandManager() : m_splitIslands(true) +{ +} + +btSimulationIslandManager::~btSimulationIslandManager() +{ +} + +void btSimulationIslandManager::initUnionFind(int n) +{ + m_unionFind.reset(n); +} + +void btSimulationIslandManager::findUnions(btDispatcher* /* dispatcher */, btCollisionWorld* colWorld) +{ + { + btOverlappingPairCache* pairCachePtr = colWorld->getPairCache(); + const int numOverlappingPairs = pairCachePtr->getNumOverlappingPairs(); + if (numOverlappingPairs) + { + btBroadphasePair* pairPtr = pairCachePtr->getOverlappingPairArrayPtr(); + + for (int i = 0; i < numOverlappingPairs; i++) + { + const btBroadphasePair& collisionPair = pairPtr[i]; + btCollisionObject* colObj0 = (btCollisionObject*)collisionPair.m_pProxy0->m_clientObject; + btCollisionObject* colObj1 = (btCollisionObject*)collisionPair.m_pProxy1->m_clientObject; + + if (((colObj0) && ((colObj0)->mergesSimulationIslands())) && + ((colObj1) && ((colObj1)->mergesSimulationIslands()))) + { + m_unionFind.unite((colObj0)->getIslandTag(), + (colObj1)->getIslandTag()); + } + } + } + } +} + +#ifdef STATIC_SIMULATION_ISLAND_OPTIMIZATION +void btSimulationIslandManager::updateActivationState(btCollisionWorld* colWorld, btDispatcher* dispatcher) +{ + // put the index into m_controllers into m_tag + int index = 0; + { + int i; + for (i = 0; i < colWorld->getCollisionObjectArray().size(); i++) + { + btCollisionObject* collisionObject = colWorld->getCollisionObjectArray()[i]; + //Adding filtering here + if (!collisionObject->isStaticOrKinematicObject()) + { + collisionObject->setIslandTag(index++); + } + collisionObject->setCompanionId(-1); + collisionObject->setHitFraction(btScalar(1.)); + } + } + // do the union find + + initUnionFind(index); + + findUnions(dispatcher, colWorld); +} + +void btSimulationIslandManager::storeIslandActivationState(btCollisionWorld* colWorld) +{ + // put the islandId ('find' value) into m_tag + { + int index = 0; + int i; + for (i = 0; i < colWorld->getCollisionObjectArray().size(); i++) + { + btCollisionObject* collisionObject = colWorld->getCollisionObjectArray()[i]; + if (!collisionObject->isStaticOrKinematicObject()) + { + collisionObject->setIslandTag(m_unionFind.find(index)); + //Set the correct object offset in Collision Object Array + m_unionFind.getElement(index).m_sz = i; + collisionObject->setCompanionId(-1); + index++; + } + else + { + collisionObject->setIslandTag(-1); + collisionObject->setCompanionId(-2); + } + } + } +} + +#else //STATIC_SIMULATION_ISLAND_OPTIMIZATION +void btSimulationIslandManager::updateActivationState(btCollisionWorld* colWorld, btDispatcher* dispatcher) +{ + initUnionFind(int(colWorld->getCollisionObjectArray().size())); + + // put the index into m_controllers into m_tag + { + int index = 0; + int i; + for (i = 0; i < colWorld->getCollisionObjectArray().size(); i++) + { + btCollisionObject* collisionObject = colWorld->getCollisionObjectArray()[i]; + collisionObject->setIslandTag(index); + collisionObject->setCompanionId(-1); + collisionObject->setHitFraction(btScalar(1.)); + index++; + } + } + // do the union find + + findUnions(dispatcher, colWorld); +} + +void btSimulationIslandManager::storeIslandActivationState(btCollisionWorld* colWorld) +{ + // put the islandId ('find' value) into m_tag + { + int index = 0; + int i; + for (i = 0; i < colWorld->getCollisionObjectArray().size(); i++) + { + btCollisionObject* collisionObject = colWorld->getCollisionObjectArray()[i]; + if (!collisionObject->isStaticOrKinematicObject()) + { + collisionObject->setIslandTag(m_unionFind.find(index)); + collisionObject->setCompanionId(-1); + } + else + { + collisionObject->setIslandTag(-1); + collisionObject->setCompanionId(-2); + } + index++; + } + } +} + +#endif //STATIC_SIMULATION_ISLAND_OPTIMIZATION + +inline int getIslandId(const btPersistentManifold* lhs) +{ + int islandId; + const btCollisionObject* rcolObj0 = static_cast(lhs->getBody0()); + const btCollisionObject* rcolObj1 = static_cast(lhs->getBody1()); + islandId = rcolObj0->getIslandTag() >= 0 ? rcolObj0->getIslandTag() : rcolObj1->getIslandTag(); + return islandId; +} + +/// function object that routes calls to operator< +class btPersistentManifoldSortPredicate +{ +public: + SIMD_FORCE_INLINE bool operator()(const btPersistentManifold* lhs, const btPersistentManifold* rhs) const + { + return getIslandId(lhs) < getIslandId(rhs); + } +}; + +class btPersistentManifoldSortPredicateDeterministic +{ +public: + SIMD_FORCE_INLINE bool operator()(const btPersistentManifold* lhs, const btPersistentManifold* rhs) const + { + return ( + (getIslandId(lhs) < getIslandId(rhs)) || ((getIslandId(lhs) == getIslandId(rhs)) && lhs->getBody0()->getBroadphaseHandle()->m_uniqueId < rhs->getBody0()->getBroadphaseHandle()->m_uniqueId) || ((getIslandId(lhs) == getIslandId(rhs)) && (lhs->getBody0()->getBroadphaseHandle()->m_uniqueId == rhs->getBody0()->getBroadphaseHandle()->m_uniqueId) && (lhs->getBody1()->getBroadphaseHandle()->m_uniqueId < rhs->getBody1()->getBroadphaseHandle()->m_uniqueId))); + } +}; + +void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher, btCollisionWorld* collisionWorld) +{ +//\1("islandUnionFindAndQuickSort"); + + btCollisionObjectArray& collisionObjects = collisionWorld->getCollisionObjectArray(); + + m_islandmanifold.resize(0); + + //we are going to sort the unionfind array, and store the element id in the size + //afterwards, we clean unionfind, to make sure no-one uses it anymore + + getUnionFind().sortIslands(); + int numElem = getUnionFind().getNumElements(); + + int endIslandIndex = 1; + int startIslandIndex; + + //update the sleeping state for bodies, if all are sleeping + for (startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex) + { + int islandId = getUnionFind().getElement(startIslandIndex).m_id; + for (endIslandIndex = startIslandIndex + 1; (endIslandIndex < numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId); endIslandIndex++) + { + } + + //int numSleeping = 0; + + bool allSleeping = true; + + int idx; + for (idx = startIslandIndex; idx < endIslandIndex; idx++) + { + int i = getUnionFind().getElement(idx).m_sz; + + btCollisionObject* colObj0 = collisionObjects[i]; + if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1)) + { + // printf("error in island management\n"); + } + + btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1)); + if (colObj0->getIslandTag() == islandId) + { + if (colObj0->getActivationState() == ACTIVE_TAG || + colObj0->getActivationState() == DISABLE_DEACTIVATION) + { + allSleeping = false; + break; + } + } + } + + if (allSleeping) + { + int idx; + for (idx = startIslandIndex; idx < endIslandIndex; idx++) + { + int i = getUnionFind().getElement(idx).m_sz; + btCollisionObject* colObj0 = collisionObjects[i]; + if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1)) + { + // printf("error in island management\n"); + } + + btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1)); + + if (colObj0->getIslandTag() == islandId) + { + colObj0->setActivationState(ISLAND_SLEEPING); + } + } + } + else + { + int idx; + for (idx = startIslandIndex; idx < endIslandIndex; idx++) + { + int i = getUnionFind().getElement(idx).m_sz; + + btCollisionObject* colObj0 = collisionObjects[i]; + if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1)) + { + // printf("error in island management\n"); + } + + btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1)); + + + if (colObj0->getIslandTag() == islandId) + { + if (colObj0->getActivationState() == ISLAND_SLEEPING) + { + colObj0->setActivationState(WANTS_DEACTIVATION); + colObj0->setDeactivationTime(0.f); + } + } + } + } + } + + int i; + int maxNumManifolds = dispatcher->getNumManifolds(); + + //#define SPLIT_ISLANDS 1 + //#ifdef SPLIT_ISLANDS + + //#endif //SPLIT_ISLANDS + + for (i = 0; i < maxNumManifolds; i++) + { + btPersistentManifold* manifold = dispatcher->getManifoldByIndexInternal(i); + if (collisionWorld->getDispatchInfo().m_deterministicOverlappingPairs) + { + if (manifold->getNumContacts() == 0) + continue; + } + + const btCollisionObject* colObj0 = static_cast(manifold->getBody0()); + const btCollisionObject* colObj1 = static_cast(manifold->getBody1()); + + ///@todo: check sleeping conditions! + if (((colObj0) && colObj0->getActivationState() != ISLAND_SLEEPING) || + ((colObj1) && colObj1->getActivationState() != ISLAND_SLEEPING)) + { + //kinematic objects don't merge islands, but wake up all connected objects + if (colObj0->isKinematicObject() && colObj0->getActivationState() != ISLAND_SLEEPING) + { + if (colObj0->hasContactResponse()) + colObj1->activate(); + } + if (colObj1->isKinematicObject() && colObj1->getActivationState() != ISLAND_SLEEPING) + { + if (colObj1->hasContactResponse()) + colObj0->activate(); + } + if (m_splitIslands) + { + //filtering for response + if (dispatcher->needsResponse(colObj0, colObj1)) + m_islandmanifold.push_back(manifold); + } + } + } +} + + +///@todo: this is random access, it can be walked 'cache friendly'! +void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher, btCollisionWorld* collisionWorld, IslandCallback* callback) +{ + buildIslands(dispatcher, collisionWorld); + processIslands(dispatcher, collisionWorld, callback); +} + +void btSimulationIslandManager::processIslands(btDispatcher* dispatcher, btCollisionWorld* collisionWorld, IslandCallback* callback) +{ + btCollisionObjectArray& collisionObjects = collisionWorld->getCollisionObjectArray(); + int endIslandIndex = 1; + int startIslandIndex; + int numElem = getUnionFind().getNumElements(); + +//\1("processIslands"); + + if (!m_splitIslands) + { + btPersistentManifold** manifold = dispatcher->getInternalManifoldPointer(); + int maxNumManifolds = dispatcher->getNumManifolds(); + callback->processIsland(&collisionObjects[0], collisionObjects.size(), manifold, maxNumManifolds, -1); + } + else + { + // Sort manifolds, based on islands + // Sort the vector using predicate and std::sort + //std::sort(islandmanifold.begin(), islandmanifold.end(), btPersistentManifoldSortPredicate); + + int numManifolds = int(m_islandmanifold.size()); + + //tried a radix sort, but quicksort/heapsort seems still faster + //@todo rewrite island management + //btPersistentManifoldSortPredicateDeterministic sorts contact manifolds based on islandid, + //but also based on object0 unique id and object1 unique id + if (collisionWorld->getDispatchInfo().m_deterministicOverlappingPairs) + { + m_islandmanifold.quickSort(btPersistentManifoldSortPredicateDeterministic()); + } + else + { + m_islandmanifold.quickSort(btPersistentManifoldSortPredicate()); + } + + //m_islandmanifold.heapSort(btPersistentManifoldSortPredicate()); + + //now process all active islands (sets of manifolds for now) + + int startManifoldIndex = 0; + int endManifoldIndex = 1; + + //int islandId; + + // printf("Start Islands\n"); + + //traverse the simulation islands, and call the solver, unless all objects are sleeping/deactivated + for (startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex) + { + int islandId = getUnionFind().getElement(startIslandIndex).m_id; + + bool islandSleeping = true; + + for (endIslandIndex = startIslandIndex; (endIslandIndex < numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId); endIslandIndex++) + { + int i = getUnionFind().getElement(endIslandIndex).m_sz; + btCollisionObject* colObj0 = collisionObjects[i]; + m_islandBodies.push_back(colObj0); + if (colObj0->isActive()) + islandSleeping = false; + } + + //find the accompanying contact manifold for this islandId + int numIslandManifolds = 0; + btPersistentManifold** startManifold = 0; + + if (startManifoldIndex < numManifolds) + { + int curIslandId = getIslandId(m_islandmanifold[startManifoldIndex]); + if (curIslandId == islandId) + { + startManifold = &m_islandmanifold[startManifoldIndex]; + + for (endManifoldIndex = startManifoldIndex + 1; (endManifoldIndex < numManifolds) && (islandId == getIslandId(m_islandmanifold[endManifoldIndex])); endManifoldIndex++) + { + } + /// Process the actual simulation, only if not sleeping/deactivated + numIslandManifolds = endManifoldIndex - startManifoldIndex; + } + } + + if (!islandSleeping) + { + callback->processIsland(&m_islandBodies[0], m_islandBodies.size(), startManifold, numIslandManifolds, islandId); + // printf("Island callback of size:%d bodies, %d manifolds\n",islandBodies.size(),numIslandManifolds); + } + + if (numIslandManifolds) + { + startManifoldIndex = endManifoldIndex; + } + + m_islandBodies.resize(0); + } + } // else if(!splitIslands) +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp.i new file mode 100644 index 00000000..97c86eab --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.h new file mode 100644 index 00000000..bd222a19 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.h @@ -0,0 +1,75 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SIMULATION_ISLAND_MANAGER_H +#define BT_SIMULATION_ISLAND_MANAGER_H + +#include "BulletCollision/CollisionDispatch/btUnionFind.h" +#include "btCollisionCreateFunc.h" +#include "LinearMath/btAlignedObjectArray.h" +#include "btCollisionObject.h" + +class btCollisionObject; +class btCollisionWorld; +class btDispatcher; +class btPersistentManifold; + +///SimulationIslandManager creates and handles simulation islands, using btUnionFind +class btSimulationIslandManager +{ + btUnionFind m_unionFind; + + btAlignedObjectArray m_islandmanifold; + btAlignedObjectArray m_islandBodies; + + bool m_splitIslands; + +public: + btSimulationIslandManager(); + virtual ~btSimulationIslandManager(); + + void initUnionFind(int n); + + btUnionFind& getUnionFind() { return m_unionFind; } + + virtual void updateActivationState(btCollisionWorld* colWorld, btDispatcher* dispatcher); + virtual void storeIslandActivationState(btCollisionWorld* world); + + void findUnions(btDispatcher* dispatcher, btCollisionWorld* colWorld); + + struct IslandCallback + { + virtual ~IslandCallback(){}; + + virtual void processIsland(btCollisionObject** bodies, int numBodies, class btPersistentManifold** manifolds, int numManifolds, int islandId) = 0; + }; + + void buildAndProcessIslands(btDispatcher* dispatcher, btCollisionWorld* collisionWorld, IslandCallback* callback); + + void buildIslands(btDispatcher* dispatcher, btCollisionWorld* colWorld); + + void processIslands(btDispatcher* dispatcher, btCollisionWorld* collisionWorld, IslandCallback* callback); + + bool getSplitIslands() + { + return m_splitIslands; + } + void setSplitIslands(bool doSplitIslands) + { + m_splitIslands = doSplitIslands; + } +}; + +#endif //BT_SIMULATION_ISLAND_MANAGER_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.h.i new file mode 100644 index 00000000..d97f55e0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSimulationIslandManager.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btSimulationIslandManager.h ---------------- + +%include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" + +%{ +#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp new file mode 100644 index 00000000..5ab26f50 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp @@ -0,0 +1,209 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btSphereBoxCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" +#include "BulletCollision/CollisionShapes/btBoxShape.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" +//#include + +btSphereBoxCollisionAlgorithm::btSphereBoxCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* col0Wrap, const btCollisionObjectWrapper* col1Wrap, bool isSwapped) + : btActivatingCollisionAlgorithm(ci, col0Wrap, col1Wrap), + m_ownManifold(false), + m_manifoldPtr(mf), + m_isSwapped(isSwapped) +{ + const btCollisionObjectWrapper* sphereObjWrap = m_isSwapped ? col1Wrap : col0Wrap; + const btCollisionObjectWrapper* boxObjWrap = m_isSwapped ? col0Wrap : col1Wrap; + + if (!m_manifoldPtr && m_dispatcher->needsCollision(sphereObjWrap->getCollisionObject(), boxObjWrap->getCollisionObject())) + { + m_manifoldPtr = m_dispatcher->getNewManifold(sphereObjWrap->getCollisionObject(), boxObjWrap->getCollisionObject()); + m_ownManifold = true; + } +} + +btSphereBoxCollisionAlgorithm::~btSphereBoxCollisionAlgorithm() +{ + if (m_ownManifold) + { + if (m_manifoldPtr) + m_dispatcher->releaseManifold(m_manifoldPtr); + } +} + +void btSphereBoxCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + (void)dispatchInfo; + (void)resultOut; + if (!m_manifoldPtr) + return; + + const btCollisionObjectWrapper* sphereObjWrap = m_isSwapped ? body1Wrap : body0Wrap; + const btCollisionObjectWrapper* boxObjWrap = m_isSwapped ? body0Wrap : body1Wrap; + + btVector3 pOnBox; + + btVector3 normalOnSurfaceB; + btScalar penetrationDepth; + btVector3 sphereCenter = sphereObjWrap->getWorldTransform().getOrigin(); + const btSphereShape* sphere0 = (const btSphereShape*)sphereObjWrap->getCollisionShape(); + btScalar radius = sphere0->getRadius(); + btScalar maxContactDistance = m_manifoldPtr->getContactBreakingThreshold(); + + resultOut->setPersistentManifold(m_manifoldPtr); + + if (getSphereDistance(boxObjWrap, pOnBox, normalOnSurfaceB, penetrationDepth, sphereCenter, radius, maxContactDistance)) + { + /// report a contact. internally this will be kept persistent, and contact reduction is done + resultOut->addContactPoint(normalOnSurfaceB, pOnBox, penetrationDepth); + } + + if (m_ownManifold) + { + if (m_manifoldPtr->getNumContacts()) + { + resultOut->refreshContactPoints(); + } + } +} + +btScalar btSphereBoxCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0, btCollisionObject* col1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + (void)resultOut; + (void)dispatchInfo; + (void)col0; + (void)col1; + + //not yet + return btScalar(1.); +} + +bool btSphereBoxCollisionAlgorithm::getSphereDistance(const btCollisionObjectWrapper* boxObjWrap, btVector3& pointOnBox, btVector3& normal, btScalar& penetrationDepth, const btVector3& sphereCenter, btScalar fRadius, btScalar maxContactDistance) +{ + const btBoxShape* boxShape = (const btBoxShape*)boxObjWrap->getCollisionShape(); + btVector3 const& boxHalfExtent = boxShape->getHalfExtentsWithoutMargin(); + btScalar boxMargin = boxShape->getMargin(); + penetrationDepth = 1.0f; + + // convert the sphere position to the box's local space + btTransform const& m44T = boxObjWrap->getWorldTransform(); + btVector3 sphereRelPos = m44T.invXform(sphereCenter); + + // Determine the closest point to the sphere center in the box + btVector3 closestPoint = sphereRelPos; + closestPoint.setX(btMin(boxHalfExtent.getX(), closestPoint.getX())); + closestPoint.setX(btMax(-boxHalfExtent.getX(), closestPoint.getX())); + closestPoint.setY(btMin(boxHalfExtent.getY(), closestPoint.getY())); + closestPoint.setY(btMax(-boxHalfExtent.getY(), closestPoint.getY())); + closestPoint.setZ(btMin(boxHalfExtent.getZ(), closestPoint.getZ())); + closestPoint.setZ(btMax(-boxHalfExtent.getZ(), closestPoint.getZ())); + + btScalar intersectionDist = fRadius + boxMargin; + btScalar contactDist = intersectionDist + maxContactDistance; + normal = sphereRelPos - closestPoint; + + //if there is no penetration, we are done + btScalar dist2 = normal.length2(); + if (dist2 > contactDist * contactDist) + { + return false; + } + + btScalar distance; + + //special case if the sphere center is inside the box + if (dist2 <= SIMD_EPSILON) + { + distance = -getSpherePenetration(boxHalfExtent, sphereRelPos, closestPoint, normal); + } + else //compute the penetration details + { + distance = normal.length(); + normal /= distance; + } + + pointOnBox = closestPoint + normal * boxMargin; + // v3PointOnSphere = sphereRelPos - (normal * fRadius); + penetrationDepth = distance - intersectionDist; + + // transform back in world space + btVector3 tmp = m44T(pointOnBox); + pointOnBox = tmp; + // tmp = m44T(v3PointOnSphere); + // v3PointOnSphere = tmp; + tmp = m44T.getBasis() * normal; + normal = tmp; + + return true; +} + +btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration(btVector3 const& boxHalfExtent, btVector3 const& sphereRelPos, btVector3& closestPoint, btVector3& normal) +{ + //project the center of the sphere on the closest face of the box + btScalar faceDist = boxHalfExtent.getX() - sphereRelPos.getX(); + btScalar minDist = faceDist; + closestPoint.setX(boxHalfExtent.getX()); + normal.setValue(btScalar(1.0f), btScalar(0.0f), btScalar(0.0f)); + + faceDist = boxHalfExtent.getX() + sphereRelPos.getX(); + if (faceDist < minDist) + { + minDist = faceDist; + closestPoint = sphereRelPos; + closestPoint.setX(-boxHalfExtent.getX()); + normal.setValue(btScalar(-1.0f), btScalar(0.0f), btScalar(0.0f)); + } + + faceDist = boxHalfExtent.getY() - sphereRelPos.getY(); + if (faceDist < minDist) + { + minDist = faceDist; + closestPoint = sphereRelPos; + closestPoint.setY(boxHalfExtent.getY()); + normal.setValue(btScalar(0.0f), btScalar(1.0f), btScalar(0.0f)); + } + + faceDist = boxHalfExtent.getY() + sphereRelPos.getY(); + if (faceDist < minDist) + { + minDist = faceDist; + closestPoint = sphereRelPos; + closestPoint.setY(-boxHalfExtent.getY()); + normal.setValue(btScalar(0.0f), btScalar(-1.0f), btScalar(0.0f)); + } + + faceDist = boxHalfExtent.getZ() - sphereRelPos.getZ(); + if (faceDist < minDist) + { + minDist = faceDist; + closestPoint = sphereRelPos; + closestPoint.setZ(boxHalfExtent.getZ()); + normal.setValue(btScalar(0.0f), btScalar(0.0f), btScalar(1.0f)); + } + + faceDist = boxHalfExtent.getZ() + sphereRelPos.getZ(); + if (faceDist < minDist) + { + minDist = faceDist; + closestPoint = sphereRelPos; + closestPoint.setZ(-boxHalfExtent.getZ()); + normal.setValue(btScalar(0.0f), btScalar(0.0f), btScalar(-1.0f)); + } + + return minDist; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..5b77a1ac --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h new file mode 100644 index 00000000..33060e83 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h @@ -0,0 +1,73 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SPHERE_BOX_COLLISION_ALGORITHM_H +#define BT_SPHERE_BOX_COLLISION_ALGORITHM_H + +#include "btActivatingCollisionAlgorithm.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +class btPersistentManifold; +#include "btCollisionDispatcher.h" + +#include "LinearMath/btVector3.h" + +/// btSphereBoxCollisionAlgorithm provides sphere-box collision detection. +/// Other features are frame-coherency (persistent data) and collision response. +class btSphereBoxCollisionAlgorithm : public btActivatingCollisionAlgorithm +{ + bool m_ownManifold; + btPersistentManifold* m_manifoldPtr; + bool m_isSwapped; + +public: + btSphereBoxCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped); + + virtual ~btSphereBoxCollisionAlgorithm(); + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, 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); + } + } + + bool getSphereDistance(const btCollisionObjectWrapper* boxObjWrap, btVector3& v3PointOnBox, btVector3& normal, btScalar& penetrationDepth, const btVector3& v3SphereCenter, btScalar fRadius, btScalar maxContactDistance); + + btScalar getSpherePenetration(btVector3 const& boxHalfExtent, btVector3 const& sphereRelPos, btVector3& closestPoint, btVector3& normal); + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSphereBoxCollisionAlgorithm)); + if (!m_swapped) + { + return new (mem) btSphereBoxCollisionAlgorithm(0, ci, body0Wrap, body1Wrap, false); + } + else + { + return new (mem) btSphereBoxCollisionAlgorithm(0, ci, body0Wrap, body1Wrap, true); + } + } + }; +}; + +#endif //BT_SPHERE_BOX_COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h.i new file mode 100644 index 00000000..d5736962 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp new file mode 100644 index 00000000..9c35565e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp @@ -0,0 +1,105 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +#define CLEAR_MANIFOLD 1 + +#include "btSphereSphereCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +btSphereSphereCollisionAlgorithm::btSphereSphereCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* col0Wrap, const btCollisionObjectWrapper* col1Wrap) + : btActivatingCollisionAlgorithm(ci, col0Wrap, col1Wrap), + m_ownManifold(false), + m_manifoldPtr(mf) +{ + if (!m_manifoldPtr) + { + m_manifoldPtr = m_dispatcher->getNewManifold(col0Wrap->getCollisionObject(), col1Wrap->getCollisionObject()); + m_ownManifold = true; + } +} + +btSphereSphereCollisionAlgorithm::~btSphereSphereCollisionAlgorithm() +{ + if (m_ownManifold) + { + if (m_manifoldPtr) + m_dispatcher->releaseManifold(m_manifoldPtr); + } +} + +void btSphereSphereCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* col0Wrap, const btCollisionObjectWrapper* col1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + (void)dispatchInfo; + + if (!m_manifoldPtr) + return; + + resultOut->setPersistentManifold(m_manifoldPtr); + + btSphereShape* sphere0 = (btSphereShape*)col0Wrap->getCollisionShape(); + btSphereShape* sphere1 = (btSphereShape*)col1Wrap->getCollisionShape(); + + btVector3 diff = col0Wrap->getWorldTransform().getOrigin() - col1Wrap->getWorldTransform().getOrigin(); + btScalar len = diff.length(); + btScalar radius0 = sphere0->getRadius(); + btScalar radius1 = sphere1->getRadius(); + +#ifdef CLEAR_MANIFOLD + m_manifoldPtr->clearManifold(); //don't do this, it disables warmstarting +#endif + + ///iff distance positive, don't generate a new contact + if (len > (radius0 + radius1 + resultOut->m_closestPointDistanceThreshold)) + { +#ifndef CLEAR_MANIFOLD + resultOut->refreshContactPoints(); +#endif //CLEAR_MANIFOLD + return; + } + ///distance (negative means penetration) + btScalar dist = len - (radius0 + radius1); + + btVector3 normalOnSurfaceB(1, 0, 0); + if (len > SIMD_EPSILON) + { + normalOnSurfaceB = diff / len; + } + + ///point on A (worldspace) + ///btVector3 pos0 = col0->getWorldTransform().getOrigin() - radius0 * normalOnSurfaceB; + ///point on B (worldspace) + btVector3 pos1 = col1Wrap->getWorldTransform().getOrigin() + radius1 * normalOnSurfaceB; + + /// report a contact. internally this will be kept persistent, and contact reduction is done + + resultOut->addContactPoint(normalOnSurfaceB, pos1, dist); + +#ifndef CLEAR_MANIFOLD + resultOut->refreshContactPoints(); +#endif //CLEAR_MANIFOLD +} + +btScalar btSphereSphereCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0, btCollisionObject* col1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + (void)col0; + (void)col1; + (void)dispatchInfo; + (void)resultOut; + + //not yet + return btScalar(1.); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..3fd6fd90 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h new file mode 100644 index 00000000..399c9279 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h @@ -0,0 +1,64 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +#define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H + +#include "btActivatingCollisionAlgorithm.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +#include "btCollisionDispatcher.h" + +class btPersistentManifold; + +/// btSphereSphereCollisionAlgorithm provides sphere-sphere collision detection. +/// Other features are frame-coherency (persistent data) and collision response. +/// Also provides the most basic sample for custom/user btCollisionAlgorithm +class btSphereSphereCollisionAlgorithm : public btActivatingCollisionAlgorithm +{ + bool m_ownManifold; + btPersistentManifold* m_manifoldPtr; + +public: + btSphereSphereCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* col0Wrap, const btCollisionObjectWrapper* col1Wrap); + + btSphereSphereCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci) + : btActivatingCollisionAlgorithm(ci) {} + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, 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); + } + } + + virtual ~btSphereSphereCollisionAlgorithm(); + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* col0Wrap, const btCollisionObjectWrapper* col1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSphereSphereCollisionAlgorithm)); + return new (mem) btSphereSphereCollisionAlgorithm(0, ci, col0Wrap, col1Wrap); + } + }; +}; + +#endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h.i new file mode 100644 index 00000000..59e69f05 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp new file mode 100644 index 00000000..21e0d943 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp @@ -0,0 +1,82 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btSphereTriangleCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "SphereTriangleDetector.h" +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + +btSphereTriangleCollisionAlgorithm::btSphereTriangleCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool swapped) + : btActivatingCollisionAlgorithm(ci, body0Wrap, body1Wrap), + m_ownManifold(false), + m_manifoldPtr(mf), + m_swapped(swapped) +{ + if (!m_manifoldPtr) + { + m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject()); + m_ownManifold = true; + } +} + +btSphereTriangleCollisionAlgorithm::~btSphereTriangleCollisionAlgorithm() +{ + if (m_ownManifold) + { + if (m_manifoldPtr) + m_dispatcher->releaseManifold(m_manifoldPtr); + } +} + +void btSphereTriangleCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* col0Wrap, const btCollisionObjectWrapper* col1Wrap, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + if (!m_manifoldPtr) + return; + + const btCollisionObjectWrapper* sphereObjWrap = m_swapped ? col1Wrap : col0Wrap; + const btCollisionObjectWrapper* triObjWrap = m_swapped ? col0Wrap : col1Wrap; + + btSphereShape* sphere = (btSphereShape*)sphereObjWrap->getCollisionShape(); + btTriangleShape* triangle = (btTriangleShape*)triObjWrap->getCollisionShape(); + + /// report a contact. internally this will be kept persistent, and contact reduction is done + resultOut->setPersistentManifold(m_manifoldPtr); + SphereTriangleDetector detector(sphere, triangle, m_manifoldPtr->getContactBreakingThreshold() + resultOut->m_closestPointDistanceThreshold); + + btDiscreteCollisionDetectorInterface::ClosestPointInput input; + input.m_maximumDistanceSquared = btScalar(BT_LARGE_FLOAT); ///@todo: tighter bounds + input.m_transformA = sphereObjWrap->getWorldTransform(); + input.m_transformB = triObjWrap->getWorldTransform(); + + bool swapResults = m_swapped; + + detector.getClosestPoints(input, *resultOut, dispatchInfo.m_debugDraw, swapResults); + + if (m_ownManifold) + resultOut->refreshContactPoints(); +} + +btScalar btSphereTriangleCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0, btCollisionObject* col1, const btDispatcherInfo& dispatchInfo, btManifoldResult* resultOut) +{ + (void)resultOut; + (void)dispatchInfo; + (void)col0; + (void)col1; + + //not yet + return btScalar(1.); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp.i new file mode 100644 index 00000000..fddd5048 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp ---------------- + +// %include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h new file mode 100644 index 00000000..73c6fd1d --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h @@ -0,0 +1,65 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H +#define BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H + +#include "btActivatingCollisionAlgorithm.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +class btPersistentManifold; +#include "btCollisionDispatcher.h" + +/// btSphereSphereCollisionAlgorithm provides sphere-sphere collision detection. +/// Other features are frame-coherency (persistent data) and collision response. +/// Also provides the most basic sample for custom/user btCollisionAlgorithm +class btSphereTriangleCollisionAlgorithm : public btActivatingCollisionAlgorithm +{ + bool m_ownManifold; + btPersistentManifold* m_manifoldPtr; + bool m_swapped; + +public: + btSphereTriangleCollisionAlgorithm(btPersistentManifold* mf, const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool swapped); + + btSphereTriangleCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci) + : btActivatingCollisionAlgorithm(ci) {} + + virtual void processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, 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); + } + } + + virtual ~btSphereTriangleCollisionAlgorithm(); + + struct CreateFunc : public btCollisionAlgorithmCreateFunc + { + virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap) + { + void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSphereTriangleCollisionAlgorithm)); + + return new (mem) btSphereTriangleCollisionAlgorithm(ci.m_manifold, ci, body0Wrap, body1Wrap, m_swapped); + } + }; +}; + +#endif //BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h.i new file mode 100644 index 00000000..03b2f4a7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h ---------------- + +%include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h" + +%{ +#include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.cpp new file mode 100644 index 00000000..906c3313 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.cpp @@ -0,0 +1,74 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btUnionFind.h" + +btUnionFind::~btUnionFind() +{ + Free(); +} + +btUnionFind::btUnionFind() +{ +} + +void btUnionFind::allocate(int N) +{ + m_elements.resize(N); +} +void btUnionFind::Free() +{ + m_elements.clear(); +} + +void btUnionFind::reset(int N) +{ + allocate(N); + + for (int i = 0; i < N; i++) + { + m_elements[i].m_id = i; + m_elements[i].m_sz = 1; + } +} + +class btUnionFindElementSortPredicate +{ +public: + bool operator()(const btElement& lhs, const btElement& rhs) const + { + return lhs.m_id < rhs.m_id; + } +}; + +///this is a special operation, destroying the content of btUnionFind. +///it sorts the elements, based on island id, in order to make it easy to iterate over islands +void btUnionFind::sortIslands() +{ + //first store the original body index, and islandId + int numElements = m_elements.size(); + + for (int i = 0; i < numElements; i++) + { + m_elements[i].m_id = find(i); +#ifndef STATIC_SIMULATION_ISLAND_OPTIMIZATION + m_elements[i].m_sz = i; +#endif //STATIC_SIMULATION_ISLAND_OPTIMIZATION + } + + // Sort the vector using predicate and std::sort + //std::sort(m_elements.begin(), m_elements.end(), btUnionFindElementSortPredicate); + m_elements.quickSort(btUnionFindElementSortPredicate()); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.cpp.i new file mode 100644 index 00000000..ac6889d0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btUnionFind.cpp ---------------- + +%include "BulletCollision/CollisionDispatch/btUnionFind.cpp" + +%{ +#include "BulletCollision/CollisionDispatch/btUnionFind.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.h b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.h new file mode 100644 index 00000000..59a30b16 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.h @@ -0,0 +1,123 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_UNION_FIND_H +#define BT_UNION_FIND_H + +#include "LinearMath/btAlignedObjectArray.h" + +#define USE_PATH_COMPRESSION 1 + +///see for discussion of static island optimizations by Vroonsh here: http://code.google.com/p/bullet/issues/detail?id=406 +#define STATIC_SIMULATION_ISLAND_OPTIMIZATION 1 + +struct btElement +{ + int m_id; + int m_sz; +}; + +///UnionFind calculates connected subsets +// Implements weighted Quick Union with path compression +// optimization: could use short ints instead of ints (halving memory, would limit the number of rigid bodies to 64k, sounds reasonable) +class btUnionFind +{ +private: + btAlignedObjectArray m_elements; + +public: + btUnionFind(); + ~btUnionFind(); + + //this is a special operation, destroying the content of btUnionFind. + //it sorts the elements, based on island id, in order to make it easy to iterate over islands + void sortIslands(); + + void reset(int N); + + SIMD_FORCE_INLINE int getNumElements() const + { + return int(m_elements.size()); + } + SIMD_FORCE_INLINE bool isRoot(int x) const + { + return (x == m_elements[x].m_id); + } + + btElement& getElement(int index) + { + return m_elements[index]; + } + const btElement& getElement(int index) const + { + return m_elements[index]; + } + + void allocate(int N); + void Free(); + + int find(int p, int q) + { + return (find(p) == find(q)); + } + + void unite(int p, int q) + { + int i = find(p), j = find(q); + if (i == j) + return; + +#ifndef USE_PATH_COMPRESSION + //weighted quick union, this keeps the 'trees' balanced, and keeps performance of unite O( log(n) ) + if (m_elements[i].m_sz < m_elements[j].m_sz) + { + m_elements[i].m_id = j; + m_elements[j].m_sz += m_elements[i].m_sz; + } + else + { + m_elements[j].m_id = i; + m_elements[i].m_sz += m_elements[j].m_sz; + } +#else + m_elements[i].m_id = j; + m_elements[j].m_sz += m_elements[i].m_sz; +#endif //USE_PATH_COMPRESSION + } + + int find(int x) + { + //btAssert(x < m_N); + //btAssert(x >= 0); + + while (x != m_elements[x].m_id) + { + //not really a reason not to use path compression, and it flattens the trees/improves find performance dramatically + +#ifdef USE_PATH_COMPRESSION + const btElement* elementPtr = &m_elements[m_elements[x].m_id]; + m_elements[x].m_id = elementPtr->m_id; + x = elementPtr->m_id; +#else // + x = m_elements[x].m_id; +#endif + //btAssert(x < m_N); + //btAssert(x >= 0); + } + return x; + } +}; + +#endif //BT_UNION_FIND_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.h.i new file mode 100644 index 00000000..0779c5cd --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionDispatch/btUnionFind.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionDispatch/btUnionFind.h ---------------- + +%include "BulletCollision/CollisionDispatch/btUnionFind.h" + +%{ +#include "BulletCollision/CollisionDispatch/btUnionFind.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.cpp new file mode 100644 index 00000000..501890ce --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.cpp @@ -0,0 +1,37 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btBox2dShape.h" + +//{ + +void btBox2dShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + btTransformAabb(getHalfExtentsWithoutMargin(), getMargin(), t, aabbMin, aabbMax); +} + +void btBox2dShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + //btScalar margin = btScalar(0.); + btVector3 halfExtents = getHalfExtentsWithMargin(); + + btScalar lx = btScalar(2.) * (halfExtents.x()); + btScalar ly = btScalar(2.) * (halfExtents.y()); + btScalar lz = btScalar(2.) * (halfExtents.z()); + + inertia.setValue(mass / (btScalar(12.0)) * (ly * ly + lz * lz), + mass / (btScalar(12.0)) * (lx * lx + lz * lz), + mass / (btScalar(12.0)) * (lx * lx + ly * ly)); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.cpp.i new file mode 100644 index 00000000..5373f970 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btBox2dShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btBox2dShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btBox2dShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.h new file mode 100644 index 00000000..6c6e7292 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.h @@ -0,0 +1,339 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_OBB_BOX_2D_SHAPE_H +#define BT_OBB_BOX_2D_SHAPE_H + +#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "LinearMath/btVector3.h" +#include "LinearMath/btMinMax.h" + +///The btBox2dShape is a box primitive around the origin, its sides axis aligned with length specified by half extents, in local shape coordinates. When used as part of a btCollisionObject or btRigidBody it will be an oriented box in world space. +ATTRIBUTE_ALIGNED16(class) +btBox2dShape : public btPolyhedralConvexShape +{ + //btVector3 m_boxHalfExtents1; //use m_implicitShapeDimensions instead + + btVector3 m_centroid; + btVector3 m_vertices[4]; + btVector3 m_normals[4]; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btVector3 getHalfExtentsWithMargin() const + { + btVector3 halfExtents = getHalfExtentsWithoutMargin(); + btVector3 margin(getMargin(), getMargin(), getMargin()); + halfExtents += margin; + return halfExtents; + } + + const btVector3& getHalfExtentsWithoutMargin() const + { + return m_implicitShapeDimensions; //changed in Bullet 2.63: assume the scaling and margin are included + } + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const + { + btVector3 halfExtents = getHalfExtentsWithoutMargin(); + btVector3 margin(getMargin(), getMargin(), getMargin()); + halfExtents += margin; + + return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()), + btFsels(vec.y(), halfExtents.y(), -halfExtents.y()), + btFsels(vec.z(), halfExtents.z(), -halfExtents.z())); + } + + SIMD_FORCE_INLINE btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const + { + const btVector3& halfExtents = getHalfExtentsWithoutMargin(); + + return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()), + btFsels(vec.y(), halfExtents.y(), -halfExtents.y()), + btFsels(vec.z(), halfExtents.z(), -halfExtents.z())); + } + + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const + { + const btVector3& halfExtents = getHalfExtentsWithoutMargin(); + + for (int i = 0; i < numVectors; i++) + { + const btVector3& vec = vectors[i]; + supportVerticesOut[i].setValue(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()), + btFsels(vec.y(), halfExtents.y(), -halfExtents.y()), + btFsels(vec.z(), halfExtents.z(), -halfExtents.z())); + } + } + + ///a btBox2dShape is a flat 2D box in the X-Y plane (Z extents are zero) + btBox2dShape(const btVector3& boxHalfExtents) + : btPolyhedralConvexShape(), + m_centroid(0, 0, 0) + { + m_vertices[0].setValue(-boxHalfExtents.getX(), -boxHalfExtents.getY(), 0); + m_vertices[1].setValue(boxHalfExtents.getX(), -boxHalfExtents.getY(), 0); + m_vertices[2].setValue(boxHalfExtents.getX(), boxHalfExtents.getY(), 0); + m_vertices[3].setValue(-boxHalfExtents.getX(), boxHalfExtents.getY(), 0); + + m_normals[0].setValue(0, -1, 0); + m_normals[1].setValue(1, 0, 0); + m_normals[2].setValue(0, 1, 0); + m_normals[3].setValue(-1, 0, 0); + + btScalar minDimension = boxHalfExtents.getX(); + if (minDimension > boxHalfExtents.getY()) + minDimension = boxHalfExtents.getY(); + + m_shapeType = BOX_2D_SHAPE_PROXYTYPE; + btVector3 margin(getMargin(), getMargin(), getMargin()); + m_implicitShapeDimensions = (boxHalfExtents * m_localScaling) - margin; + + setSafeMargin(minDimension); + }; + + virtual void setMargin(btScalar collisionMargin) + { + //correct the m_implicitShapeDimensions for the margin + btVector3 oldMargin(getMargin(), getMargin(), getMargin()); + btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin; + + btConvexInternalShape::setMargin(collisionMargin); + btVector3 newMargin(getMargin(), getMargin(), getMargin()); + m_implicitShapeDimensions = implicitShapeDimensionsWithMargin - newMargin; + } + virtual void setLocalScaling(const btVector3& scaling) + { + btVector3 oldMargin(getMargin(), getMargin(), getMargin()); + btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin; + btVector3 unScaledImplicitShapeDimensionsWithMargin = implicitShapeDimensionsWithMargin / m_localScaling; + + btConvexInternalShape::setLocalScaling(scaling); + + m_implicitShapeDimensions = (unScaledImplicitShapeDimensionsWithMargin * m_localScaling) - oldMargin; + } + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + int getVertexCount() const + { + return 4; + } + + virtual int getNumVertices() const + { + return 4; + } + + const btVector3* getVertices() const + { + return &m_vertices[0]; + } + + const btVector3* getNormals() const + { + return &m_normals[0]; + } + + virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const + { + //this plane might not be aligned... + btVector4 plane; + getPlaneEquation(plane, i); + planeNormal = btVector3(plane.getX(), plane.getY(), plane.getZ()); + planeSupport = localGetSupportingVertex(-planeNormal); + } + + const btVector3& getCentroid() const + { + return m_centroid; + } + + virtual int getNumPlanes() const + { + return 6; + } + + virtual int getNumEdges() const + { + return 12; + } + + virtual void getVertex(int i, btVector3& vtx) const + { + btVector3 halfExtents = getHalfExtentsWithoutMargin(); + + vtx = btVector3( + halfExtents.x() * (1 - (i & 1)) - halfExtents.x() * (i & 1), + halfExtents.y() * (1 - ((i & 2) >> 1)) - halfExtents.y() * ((i & 2) >> 1), + halfExtents.z() * (1 - ((i & 4) >> 2)) - halfExtents.z() * ((i & 4) >> 2)); + } + + virtual void getPlaneEquation(btVector4 & plane, int i) const + { + btVector3 halfExtents = getHalfExtentsWithoutMargin(); + + switch (i) + { + case 0: + plane.setValue(btScalar(1.), btScalar(0.), btScalar(0.), -halfExtents.x()); + break; + case 1: + plane.setValue(btScalar(-1.), btScalar(0.), btScalar(0.), -halfExtents.x()); + break; + case 2: + plane.setValue(btScalar(0.), btScalar(1.), btScalar(0.), -halfExtents.y()); + break; + case 3: + plane.setValue(btScalar(0.), btScalar(-1.), btScalar(0.), -halfExtents.y()); + break; + case 4: + plane.setValue(btScalar(0.), btScalar(0.), btScalar(1.), -halfExtents.z()); + break; + case 5: + plane.setValue(btScalar(0.), btScalar(0.), btScalar(-1.), -halfExtents.z()); + break; + default: + btAssert(0); + } + } + + virtual void getEdge(int i, btVector3& pa, btVector3& pb) const + //virtual void getEdge(int i,Edge& edge) const + { + int edgeVert0 = 0; + int edgeVert1 = 0; + + switch (i) + { + case 0: + edgeVert0 = 0; + edgeVert1 = 1; + break; + case 1: + edgeVert0 = 0; + edgeVert1 = 2; + break; + case 2: + edgeVert0 = 1; + edgeVert1 = 3; + + break; + case 3: + edgeVert0 = 2; + edgeVert1 = 3; + break; + case 4: + edgeVert0 = 0; + edgeVert1 = 4; + break; + case 5: + edgeVert0 = 1; + edgeVert1 = 5; + + break; + case 6: + edgeVert0 = 2; + edgeVert1 = 6; + break; + case 7: + edgeVert0 = 3; + edgeVert1 = 7; + break; + case 8: + edgeVert0 = 4; + edgeVert1 = 5; + break; + case 9: + edgeVert0 = 4; + edgeVert1 = 6; + break; + case 10: + edgeVert0 = 5; + edgeVert1 = 7; + break; + case 11: + edgeVert0 = 6; + edgeVert1 = 7; + break; + default: + btAssert(0); + } + + getVertex(edgeVert0, pa); + getVertex(edgeVert1, pb); + } + + virtual bool isInside(const btVector3& pt, btScalar tolerance) const + { + btVector3 halfExtents = getHalfExtentsWithoutMargin(); + + //btScalar minDist = 2*tolerance; + + bool result = (pt.x() <= (halfExtents.x() + tolerance)) && + (pt.x() >= (-halfExtents.x() - tolerance)) && + (pt.y() <= (halfExtents.y() + tolerance)) && + (pt.y() >= (-halfExtents.y() - tolerance)) && + (pt.z() <= (halfExtents.z() + tolerance)) && + (pt.z() >= (-halfExtents.z() - tolerance)); + + return result; + } + + //debugging + virtual const char* getName() const + { + return "Box2d"; + } + + virtual int getNumPreferredPenetrationDirections() const + { + return 6; + } + + virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const + { + switch (index) + { + case 0: + penetrationVector.setValue(btScalar(1.), btScalar(0.), btScalar(0.)); + break; + case 1: + penetrationVector.setValue(btScalar(-1.), btScalar(0.), btScalar(0.)); + break; + case 2: + penetrationVector.setValue(btScalar(0.), btScalar(1.), btScalar(0.)); + break; + case 3: + penetrationVector.setValue(btScalar(0.), btScalar(-1.), btScalar(0.)); + break; + case 4: + penetrationVector.setValue(btScalar(0.), btScalar(0.), btScalar(1.)); + break; + case 5: + penetrationVector.setValue(btScalar(0.), btScalar(0.), btScalar(-1.)); + break; + default: + btAssert(0); + } + } +}; + +#endif //BT_OBB_BOX_2D_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.h.i new file mode 100644 index 00000000..9cccfe18 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBox2dShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btBox2dShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btBox2dShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btBox2dShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.cpp new file mode 100644 index 00000000..cb91d023 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.cpp @@ -0,0 +1,45 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +#include "btBoxShape.h" + +btBoxShape::btBoxShape(const btVector3& boxHalfExtents) + : btPolyhedralConvexShape() +{ + m_shapeType = BOX_SHAPE_PROXYTYPE; + + btVector3 margin(getMargin(), getMargin(), getMargin()); + m_implicitShapeDimensions = (boxHalfExtents * m_localScaling) - margin; + + setSafeMargin(boxHalfExtents); +}; + +void btBoxShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + btTransformAabb(getHalfExtentsWithoutMargin(), getMargin(), t, aabbMin, aabbMax); +} + +void btBoxShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + //btScalar margin = btScalar(0.); + btVector3 halfExtents = getHalfExtentsWithMargin(); + + btScalar lx = btScalar(2.) * (halfExtents.x()); + btScalar ly = btScalar(2.) * (halfExtents.y()); + btScalar lz = btScalar(2.) * (halfExtents.z()); + + inertia.setValue(mass / (btScalar(12.0)) * (ly * ly + lz * lz), + mass / (btScalar(12.0)) * (lx * lx + lz * lz), + mass / (btScalar(12.0)) * (lx * lx + ly * ly)); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.cpp.i new file mode 100644 index 00000000..ee7e14ef --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btBoxShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btBoxShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btBoxShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.h new file mode 100644 index 00000000..3c65505d --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.h @@ -0,0 +1,291 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_OBB_BOX_MINKOWSKI_H +#define BT_OBB_BOX_MINKOWSKI_H + +#include "btPolyhedralConvexShape.h" +#include "btCollisionMargin.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "LinearMath/btVector3.h" +#include "LinearMath/btMinMax.h" + +///The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by half extents, in local shape coordinates. When used as part of a btCollisionObject or btRigidBody it will be an oriented box in world space. +ATTRIBUTE_ALIGNED16(class) +btBoxShape : public btPolyhedralConvexShape +{ + //btVector3 m_boxHalfExtents1; //use m_implicitShapeDimensions instead + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btVector3 getHalfExtentsWithMargin() const + { + btVector3 halfExtents = getHalfExtentsWithoutMargin(); + btVector3 margin(getMargin(), getMargin(), getMargin()); + halfExtents += margin; + return halfExtents; + } + + const btVector3& getHalfExtentsWithoutMargin() const + { + return m_implicitShapeDimensions; //scaling is included, margin is not + } + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const + { + btVector3 halfExtents = getHalfExtentsWithoutMargin(); + btVector3 margin(getMargin(), getMargin(), getMargin()); + halfExtents += margin; + + return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()), + btFsels(vec.y(), halfExtents.y(), -halfExtents.y()), + btFsels(vec.z(), halfExtents.z(), -halfExtents.z())); + } + + SIMD_FORCE_INLINE btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const + { + const btVector3& halfExtents = getHalfExtentsWithoutMargin(); + + return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()), + btFsels(vec.y(), halfExtents.y(), -halfExtents.y()), + btFsels(vec.z(), halfExtents.z(), -halfExtents.z())); + } + + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const + { + const btVector3& halfExtents = getHalfExtentsWithoutMargin(); + + for (int i = 0; i < numVectors; i++) + { + const btVector3& vec = vectors[i]; + supportVerticesOut[i].setValue(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()), + btFsels(vec.y(), halfExtents.y(), -halfExtents.y()), + btFsels(vec.z(), halfExtents.z(), -halfExtents.z())); + } + } + + btBoxShape(const btVector3& boxHalfExtents); + + virtual void setMargin(btScalar collisionMargin) + { + //correct the m_implicitShapeDimensions for the margin + btVector3 oldMargin(getMargin(), getMargin(), getMargin()); + btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin; + + btConvexInternalShape::setMargin(collisionMargin); + btVector3 newMargin(getMargin(), getMargin(), getMargin()); + m_implicitShapeDimensions = implicitShapeDimensionsWithMargin - newMargin; + } + virtual void setLocalScaling(const btVector3& scaling) + { + btVector3 oldMargin(getMargin(), getMargin(), getMargin()); + btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin; + btVector3 unScaledImplicitShapeDimensionsWithMargin = implicitShapeDimensionsWithMargin / m_localScaling; + + btConvexInternalShape::setLocalScaling(scaling); + + m_implicitShapeDimensions = (unScaledImplicitShapeDimensionsWithMargin * m_localScaling) - oldMargin; + } + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const + { + //this plane might not be aligned... + btVector4 plane; + getPlaneEquation(plane, i); + planeNormal = btVector3(plane.getX(), plane.getY(), plane.getZ()); + planeSupport = localGetSupportingVertex(-planeNormal); + } + + virtual int getNumPlanes() const + { + return 6; + } + + virtual int getNumVertices() const + { + return 8; + } + + virtual int getNumEdges() const + { + return 12; + } + + virtual void getVertex(int i, btVector3& vtx) const + { + btVector3 halfExtents = getHalfExtentsWithMargin(); + + vtx = btVector3( + halfExtents.x() * (1 - (i & 1)) - halfExtents.x() * (i & 1), + halfExtents.y() * (1 - ((i & 2) >> 1)) - halfExtents.y() * ((i & 2) >> 1), + halfExtents.z() * (1 - ((i & 4) >> 2)) - halfExtents.z() * ((i & 4) >> 2)); + } + + virtual void getPlaneEquation(btVector4 & plane, int i) const + { + btVector3 halfExtents = getHalfExtentsWithoutMargin(); + + switch (i) + { + case 0: + plane.setValue(btScalar(1.), btScalar(0.), btScalar(0.), -halfExtents.x()); + break; + case 1: + plane.setValue(btScalar(-1.), btScalar(0.), btScalar(0.), -halfExtents.x()); + break; + case 2: + plane.setValue(btScalar(0.), btScalar(1.), btScalar(0.), -halfExtents.y()); + break; + case 3: + plane.setValue(btScalar(0.), btScalar(-1.), btScalar(0.), -halfExtents.y()); + break; + case 4: + plane.setValue(btScalar(0.), btScalar(0.), btScalar(1.), -halfExtents.z()); + break; + case 5: + plane.setValue(btScalar(0.), btScalar(0.), btScalar(-1.), -halfExtents.z()); + break; + default: + btAssert(0); + } + } + + virtual void getEdge(int i, btVector3& pa, btVector3& pb) const + //virtual void getEdge(int i,Edge& edge) const + { + int edgeVert0 = 0; + int edgeVert1 = 0; + + switch (i) + { + case 0: + edgeVert0 = 0; + edgeVert1 = 1; + break; + case 1: + edgeVert0 = 0; + edgeVert1 = 2; + break; + case 2: + edgeVert0 = 1; + edgeVert1 = 3; + + break; + case 3: + edgeVert0 = 2; + edgeVert1 = 3; + break; + case 4: + edgeVert0 = 0; + edgeVert1 = 4; + break; + case 5: + edgeVert0 = 1; + edgeVert1 = 5; + + break; + case 6: + edgeVert0 = 2; + edgeVert1 = 6; + break; + case 7: + edgeVert0 = 3; + edgeVert1 = 7; + break; + case 8: + edgeVert0 = 4; + edgeVert1 = 5; + break; + case 9: + edgeVert0 = 4; + edgeVert1 = 6; + break; + case 10: + edgeVert0 = 5; + edgeVert1 = 7; + break; + case 11: + edgeVert0 = 6; + edgeVert1 = 7; + break; + default: + btAssert(0); + } + + getVertex(edgeVert0, pa); + getVertex(edgeVert1, pb); + } + + virtual bool isInside(const btVector3& pt, btScalar tolerance) const + { + btVector3 halfExtents = getHalfExtentsWithoutMargin(); + + //btScalar minDist = 2*tolerance; + + bool result = (pt.x() <= (halfExtents.x() + tolerance)) && + (pt.x() >= (-halfExtents.x() - tolerance)) && + (pt.y() <= (halfExtents.y() + tolerance)) && + (pt.y() >= (-halfExtents.y() - tolerance)) && + (pt.z() <= (halfExtents.z() + tolerance)) && + (pt.z() >= (-halfExtents.z() - tolerance)); + + return result; + } + + //debugging + virtual const char* getName() const + { + return "Box"; + } + + virtual int getNumPreferredPenetrationDirections() const + { + return 6; + } + + virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const + { + switch (index) + { + case 0: + penetrationVector.setValue(btScalar(1.), btScalar(0.), btScalar(0.)); + break; + case 1: + penetrationVector.setValue(btScalar(-1.), btScalar(0.), btScalar(0.)); + break; + case 2: + penetrationVector.setValue(btScalar(0.), btScalar(1.), btScalar(0.)); + break; + case 3: + penetrationVector.setValue(btScalar(0.), btScalar(-1.), btScalar(0.)); + break; + case 4: + penetrationVector.setValue(btScalar(0.), btScalar(0.), btScalar(1.)); + break; + case 5: + penetrationVector.setValue(btScalar(0.), btScalar(0.), btScalar(-1.)); + break; + default: + btAssert(0); + } + } +}; + +#endif //BT_OBB_BOX_MINKOWSKI_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.h.i new file mode 100644 index 00000000..6cf63d0b --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBoxShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btBoxShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btBoxShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btBoxShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp new file mode 100644 index 00000000..c66ce58e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp @@ -0,0 +1,462 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +//#define DISABLE_BVH + +#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" +#include "BulletCollision/CollisionShapes/btOptimizedBvh.h" +#include "LinearMath/btSerializer.h" + +///Bvh Concave triangle mesh is a static-triangle mesh shape with Bounding Volume Hierarchy optimization. +///Uses an interface to access the triangles to allow for sharing graphics/physics triangles. +btBvhTriangleMeshShape::btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface, bool useQuantizedAabbCompression, bool buildBvh) + : btTriangleMeshShape(meshInterface), + m_bvh(0), + m_triangleInfoMap(0), + m_useQuantizedAabbCompression(useQuantizedAabbCompression), + m_ownsBvh(false) +{ + m_shapeType = TRIANGLE_MESH_SHAPE_PROXYTYPE; + //construct bvh from meshInterface +#ifndef DISABLE_BVH + + if (buildBvh) + { + buildOptimizedBvh(); + } + +#endif //DISABLE_BVH +} + +btBvhTriangleMeshShape::btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface, bool useQuantizedAabbCompression, const btVector3& bvhAabbMin, const btVector3& bvhAabbMax, bool buildBvh) + : btTriangleMeshShape(meshInterface), + m_bvh(0), + m_triangleInfoMap(0), + m_useQuantizedAabbCompression(useQuantizedAabbCompression), + m_ownsBvh(false) +{ + m_shapeType = TRIANGLE_MESH_SHAPE_PROXYTYPE; + //construct bvh from meshInterface +#ifndef DISABLE_BVH + + if (buildBvh) + { + void* mem = btAlignedAlloc(sizeof(btOptimizedBvh), 16); + m_bvh = new (mem) btOptimizedBvh(); + + m_bvh->build(meshInterface, m_useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax); + m_ownsBvh = true; + } + +#endif //DISABLE_BVH +} + +void btBvhTriangleMeshShape::partialRefitTree(const btVector3& aabbMin, const btVector3& aabbMax) +{ + m_bvh->refitPartial(m_meshInterface, aabbMin, aabbMax); + + m_localAabbMin.setMin(aabbMin); + m_localAabbMax.setMax(aabbMax); +} + +void btBvhTriangleMeshShape::refitTree(const btVector3& aabbMin, const btVector3& aabbMax) +{ + m_bvh->refit(m_meshInterface, aabbMin, aabbMax); + + recalcLocalAabb(); +} + +btBvhTriangleMeshShape::~btBvhTriangleMeshShape() +{ + if (m_ownsBvh) + { + m_bvh->~btOptimizedBvh(); + btAlignedFree(m_bvh); + } +} + +void btBvhTriangleMeshShape::performRaycast(btTriangleCallback* callback, const btVector3& raySource, const btVector3& rayTarget) +{ + struct MyNodeOverlapCallback : public btNodeOverlapCallback + { + btStridingMeshInterface* m_meshInterface; + btTriangleCallback* m_callback; + + MyNodeOverlapCallback(btTriangleCallback* callback, btStridingMeshInterface* meshInterface) + : m_meshInterface(meshInterface), + m_callback(callback) + { + } + + virtual void processNode(int nodeSubPart, int nodeTriangleIndex) + { + btVector3 m_triangle[3]; + const unsigned char* vertexbase; + int numverts; + PHY_ScalarType type; + int stride; + const unsigned char* indexbase; + int indexstride; + int numfaces; + PHY_ScalarType indicestype; + + m_meshInterface->getLockedReadOnlyVertexIndexBase( + &vertexbase, + numverts, + type, + stride, + &indexbase, + indexstride, + numfaces, + indicestype, + nodeSubPart); + + unsigned int* gfxbase = (unsigned int*)(indexbase + nodeTriangleIndex * indexstride); + + const btVector3& meshScaling = m_meshInterface->getScaling(); + for (int j = 2; j >= 0; j--) + { + int graphicsindex; + switch (indicestype) { + case PHY_INTEGER: graphicsindex = gfxbase[j]; break; + case PHY_SHORT: graphicsindex = ((unsigned short*)gfxbase)[j]; break; + case PHY_UCHAR: graphicsindex = ((unsigned char*)gfxbase)[j]; break; + default: btAssert(0); + } + + if (type == PHY_FLOAT) + { + float* graphicsbase = (float*)(vertexbase + graphicsindex * stride); + + m_triangle[j] = btVector3(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + } + else + { + double* graphicsbase = (double*)(vertexbase + graphicsindex * stride); + + m_triangle[j] = btVector3(btScalar(graphicsbase[0]) * meshScaling.getX(), btScalar(graphicsbase[1]) * meshScaling.getY(), btScalar(graphicsbase[2]) * meshScaling.getZ()); + } + } + + /* Perform ray vs. triangle collision here */ + m_callback->processTriangle(m_triangle, nodeSubPart, nodeTriangleIndex); + m_meshInterface->unLockReadOnlyVertexBase(nodeSubPart); + } + }; + + MyNodeOverlapCallback myNodeCallback(callback, m_meshInterface); + + m_bvh->reportRayOverlappingNodex(&myNodeCallback, raySource, rayTarget); +} + +void btBvhTriangleMeshShape::performConvexcast(btTriangleCallback* callback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax) +{ + struct MyNodeOverlapCallback : public btNodeOverlapCallback + { + btStridingMeshInterface* m_meshInterface; + btTriangleCallback* m_callback; + + MyNodeOverlapCallback(btTriangleCallback* callback, btStridingMeshInterface* meshInterface) + : m_meshInterface(meshInterface), + m_callback(callback) + { + } + + virtual void processNode(int nodeSubPart, int nodeTriangleIndex) + { + btVector3 m_triangle[3]; + const unsigned char* vertexbase; + int numverts; + PHY_ScalarType type; + int stride; + const unsigned char* indexbase; + int indexstride; + int numfaces; + PHY_ScalarType indicestype; + + m_meshInterface->getLockedReadOnlyVertexIndexBase( + &vertexbase, + numverts, + type, + stride, + &indexbase, + indexstride, + numfaces, + indicestype, + nodeSubPart); + + unsigned int* gfxbase = (unsigned int*)(indexbase + nodeTriangleIndex * indexstride); + + const btVector3& meshScaling = m_meshInterface->getScaling(); + for (int j = 2; j >= 0; j--) + { + int graphicsindex; + switch (indicestype) { + case PHY_INTEGER: graphicsindex = gfxbase[j]; break; + case PHY_SHORT: graphicsindex = ((unsigned short*)gfxbase)[j]; break; + case PHY_UCHAR: graphicsindex = ((unsigned char*)gfxbase)[j]; break; + default: btAssert(0); + } + + if (type == PHY_FLOAT) + { + float* graphicsbase = (float*)(vertexbase + graphicsindex * stride); + + m_triangle[j] = btVector3(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + } + else + { + double* graphicsbase = (double*)(vertexbase + graphicsindex * stride); + + m_triangle[j] = btVector3(btScalar(graphicsbase[0]) * meshScaling.getX(), btScalar(graphicsbase[1]) * meshScaling.getY(), btScalar(graphicsbase[2]) * meshScaling.getZ()); + } + } + + /* Perform ray vs. triangle collision here */ + m_callback->processTriangle(m_triangle, nodeSubPart, nodeTriangleIndex); + m_meshInterface->unLockReadOnlyVertexBase(nodeSubPart); + } + }; + + MyNodeOverlapCallback myNodeCallback(callback, m_meshInterface); + + m_bvh->reportBoxCastOverlappingNodex(&myNodeCallback, raySource, rayTarget, aabbMin, aabbMax); +} + +//perform bvh tree traversal and report overlapping triangles to 'callback' +void btBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const +{ +#ifdef DISABLE_BVH + //brute force traverse all triangles + btTriangleMeshShape::processAllTriangles(callback, aabbMin, aabbMax); +#else + + //first get all the nodes + + struct MyNodeOverlapCallback : public btNodeOverlapCallback + { + btStridingMeshInterface* m_meshInterface; + btTriangleCallback* m_callback; + btVector3 m_triangle[3]; + int m_numOverlap; + + MyNodeOverlapCallback(btTriangleCallback* callback, btStridingMeshInterface* meshInterface) + : m_meshInterface(meshInterface), + m_callback(callback), + m_numOverlap(0) + { + } + + virtual void processNode(int nodeSubPart, int nodeTriangleIndex) + { + m_numOverlap++; + const unsigned char* vertexbase; + int numverts; + PHY_ScalarType type; + int stride; + const unsigned char* indexbase; + int indexstride; + int numfaces; + PHY_ScalarType indicestype; + + m_meshInterface->getLockedReadOnlyVertexIndexBase( + &vertexbase, + numverts, + type, + stride, + &indexbase, + indexstride, + numfaces, + indicestype, + nodeSubPart); + + unsigned int* gfxbase = (unsigned int*)(indexbase + nodeTriangleIndex * indexstride); + btAssert(indicestype == PHY_INTEGER || indicestype == PHY_SHORT || indicestype == PHY_UCHAR); + + const btVector3& meshScaling = m_meshInterface->getScaling(); + for (int j = 2; j >= 0; j--) + { + int graphicsindex = indicestype == PHY_SHORT ? ((unsigned short*)gfxbase)[j] : indicestype == PHY_INTEGER ? gfxbase[j] : ((unsigned char*)gfxbase)[j]; + +#ifdef DEBUG_TRIANGLE_MESH + printf("%d ,", graphicsindex); +#endif //DEBUG_TRIANGLE_MESH + if (type == PHY_FLOAT) + { + float* graphicsbase = (float*)(vertexbase + graphicsindex * stride); + + m_triangle[j] = btVector3( + graphicsbase[0] * meshScaling.getX(), + graphicsbase[1] * meshScaling.getY(), + graphicsbase[2] * meshScaling.getZ()); + } + else + { + double* graphicsbase = (double*)(vertexbase + graphicsindex * stride); + + m_triangle[j] = btVector3( + btScalar(graphicsbase[0]) * meshScaling.getX(), + btScalar(graphicsbase[1]) * meshScaling.getY(), + btScalar(graphicsbase[2]) * meshScaling.getZ()); + } +#ifdef DEBUG_TRIANGLE_MESH + printf("triangle vertices:%f,%f,%f\n", triangle[j].x(), triangle[j].y(), triangle[j].z()); +#endif //DEBUG_TRIANGLE_MESH + } + + m_callback->processTriangle(m_triangle, nodeSubPart, nodeTriangleIndex); + m_meshInterface->unLockReadOnlyVertexBase(nodeSubPart); + } + }; + + MyNodeOverlapCallback myNodeCallback(callback, m_meshInterface); + + m_bvh->reportAabbOverlappingNodex(&myNodeCallback, aabbMin, aabbMax); + +#endif //DISABLE_BVH +} + +void btBvhTriangleMeshShape::setLocalScaling(const btVector3& scaling) +{ + if ((getLocalScaling() - scaling).length2() > SIMD_EPSILON) + { + btTriangleMeshShape::setLocalScaling(scaling); + buildOptimizedBvh(); + } +} + +void btBvhTriangleMeshShape::buildOptimizedBvh() +{ + if (m_ownsBvh) + { + m_bvh->~btOptimizedBvh(); + btAlignedFree(m_bvh); + } + ///m_localAabbMin/m_localAabbMax is already re-calculated in btTriangleMeshShape. We could just scale aabb, but this needs some more work + void* mem = btAlignedAlloc(sizeof(btOptimizedBvh), 16); + m_bvh = new (mem) btOptimizedBvh(); + //rebuild the bvh... + m_bvh->build(m_meshInterface, m_useQuantizedAabbCompression, m_localAabbMin, m_localAabbMax); + m_ownsBvh = true; +} + +void btBvhTriangleMeshShape::setOptimizedBvh(btOptimizedBvh* bvh, const btVector3& scaling) +{ + btAssert(!m_bvh); + btAssert(!m_ownsBvh); + + m_bvh = bvh; + m_ownsBvh = false; + // update the scaling without rebuilding the bvh + if ((getLocalScaling() - scaling).length2() > SIMD_EPSILON) + { + btTriangleMeshShape::setLocalScaling(scaling); + } +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +const char* btBvhTriangleMeshShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btTriangleMeshShapeData* trimeshData = (btTriangleMeshShapeData*)dataBuffer; + + btCollisionShape::serialize(&trimeshData->m_collisionShapeData, serializer); + + m_meshInterface->serialize(&trimeshData->m_meshInterface, serializer); + + trimeshData->m_collisionMargin = float(m_collisionMargin); + + if (m_bvh && !(serializer->getSerializationFlags() & BT_SERIALIZE_NO_BVH)) + { + void* chunk = serializer->findPointer(m_bvh); + if (chunk) + { +#ifdef BT_USE_DOUBLE_PRECISION + trimeshData->m_quantizedDoubleBvh = (btQuantizedBvhData*)chunk; + trimeshData->m_quantizedFloatBvh = 0; +#else + trimeshData->m_quantizedFloatBvh = (btQuantizedBvhData*)chunk; + trimeshData->m_quantizedDoubleBvh = 0; +#endif //BT_USE_DOUBLE_PRECISION + } + else + { +#ifdef BT_USE_DOUBLE_PRECISION + trimeshData->m_quantizedDoubleBvh = (btQuantizedBvhData*)serializer->getUniquePointer(m_bvh); + trimeshData->m_quantizedFloatBvh = 0; +#else + trimeshData->m_quantizedFloatBvh = (btQuantizedBvhData*)serializer->getUniquePointer(m_bvh); + trimeshData->m_quantizedDoubleBvh = 0; +#endif //BT_USE_DOUBLE_PRECISION + + int sz = m_bvh->calculateSerializeBufferSizeNew(); + btChunk* chunk = serializer->allocate(sz, 1); + const char* structType = m_bvh->serialize(chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_QUANTIZED_BVH_CODE, m_bvh); + } + } + else + { + trimeshData->m_quantizedFloatBvh = 0; + trimeshData->m_quantizedDoubleBvh = 0; + } + + if (m_triangleInfoMap && !(serializer->getSerializationFlags() & BT_SERIALIZE_NO_TRIANGLEINFOMAP)) + { + void* chunk = serializer->findPointer(m_triangleInfoMap); + if (chunk) + { + trimeshData->m_triangleInfoMap = (btTriangleInfoMapData*)chunk; + } + else + { + trimeshData->m_triangleInfoMap = (btTriangleInfoMapData*)serializer->getUniquePointer(m_triangleInfoMap); + int sz = m_triangleInfoMap->calculateSerializeBufferSize(); + btChunk* chunk = serializer->allocate(sz, 1); + const char* structType = m_triangleInfoMap->serialize(chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_TRIANLGE_INFO_MAP, m_triangleInfoMap); + } + } + else + { + trimeshData->m_triangleInfoMap = 0; + } + + // Fill padding with zeros to appease msan. + memset(trimeshData->m_pad3, 0, sizeof(trimeshData->m_pad3)); + + return "btTriangleMeshShapeData"; +} + +void btBvhTriangleMeshShape::serializeSingleBvh(btSerializer* serializer) const +{ + if (m_bvh) + { + int len = m_bvh->calculateSerializeBufferSizeNew(); //make sure not to use calculateSerializeBufferSize because it is used for in-place + btChunk* chunk = serializer->allocate(len, 1); + const char* structType = m_bvh->serialize(chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_QUANTIZED_BVH_CODE, (void*)m_bvh); + } +} + +void btBvhTriangleMeshShape::serializeSingleTriangleInfoMap(btSerializer* serializer) const +{ + if (m_triangleInfoMap) + { + int len = m_triangleInfoMap->calculateSerializeBufferSize(); + btChunk* chunk = serializer->allocate(len, 1); + const char* structType = m_triangleInfoMap->serialize(chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_TRIANLGE_INFO_MAP, (void*)m_triangleInfoMap); + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp.i new file mode 100644 index 00000000..ab64c2fd --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h new file mode 100644 index 00000000..8b2f2ee8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h @@ -0,0 +1,144 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_BVH_TRIANGLE_MESH_SHAPE_H +#define BT_BVH_TRIANGLE_MESH_SHAPE_H + +#include "btTriangleMeshShape.h" +#include "btOptimizedBvh.h" +#include "LinearMath/btAlignedAllocator.h" +#include "btTriangleInfoMap.h" + +///The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving objects. +///If you required moving concave triangle meshes, it is recommended to perform convex decomposition +///using HACD, see Bullet/Demos/ConvexDecompositionDemo. +///Alternatively, you can use btGimpactMeshShape for moving concave triangle meshes. +///btBvhTriangleMeshShape has several optimizations, such as bounding volume hierarchy and +///cache friendly traversal for PlayStation 3 Cell SPU. +///It is recommended to enable useQuantizedAabbCompression for better memory usage. +///It takes a triangle mesh as input, for example a btTriangleMesh or btTriangleIndexVertexArray. The btBvhTriangleMeshShape class allows for triangle mesh deformations by a refit or partialRefit method. +///Instead of building the bounding volume hierarchy acceleration structure, it is also possible to serialize (save) and deserialize (load) the structure from disk. +///See Demos\ConcaveDemo\ConcavePhysicsDemo.cpp for an example. +ATTRIBUTE_ALIGNED16(class) +btBvhTriangleMeshShape : public btTriangleMeshShape +{ + btOptimizedBvh* m_bvh; + btTriangleInfoMap* m_triangleInfoMap; + + bool m_useQuantizedAabbCompression; + bool m_ownsBvh; +#ifdef __clang__ + bool m_pad[11] __attribute__((unused)); ////need padding due to alignment +#else + bool m_pad[11]; ////need padding due to alignment +#endif + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btBvhTriangleMeshShape(btStridingMeshInterface * meshInterface, bool useQuantizedAabbCompression, bool buildBvh = true); + + ///optionally pass in a larger bvh aabb, used for quantization. This allows for deformations within this aabb + btBvhTriangleMeshShape(btStridingMeshInterface * meshInterface, bool useQuantizedAabbCompression, const btVector3& bvhAabbMin, const btVector3& bvhAabbMax, bool buildBvh = true); + + virtual ~btBvhTriangleMeshShape(); + + bool getOwnsBvh() const + { + return m_ownsBvh; + } + + void performRaycast(btTriangleCallback * callback, const btVector3& raySource, const btVector3& rayTarget); + void performConvexcast(btTriangleCallback * callback, const btVector3& boxSource, const btVector3& boxTarget, const btVector3& boxMin, const btVector3& boxMax); + + virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const; + + void refitTree(const btVector3& aabbMin, const btVector3& aabbMax); + + ///for a fast incremental refit of parts of the tree. Note: the entire AABB of the tree will become more conservative, it never shrinks + void partialRefitTree(const btVector3& aabbMin, const btVector3& aabbMax); + + //debugging + virtual const char* getName() const { return "BVHTRIANGLEMESH"; } + + virtual void setLocalScaling(const btVector3& scaling); + + btOptimizedBvh* getOptimizedBvh() + { + return m_bvh; + } + + void setOptimizedBvh(btOptimizedBvh * bvh, const btVector3& localScaling = btVector3(1, 1, 1)); + + void buildOptimizedBvh(); + + bool usesQuantizedAabbCompression() const + { + return m_useQuantizedAabbCompression; + } + + void setTriangleInfoMap(btTriangleInfoMap * triangleInfoMap) + { + m_triangleInfoMap = triangleInfoMap; + } + + const btTriangleInfoMap* getTriangleInfoMap() const + { + return m_triangleInfoMap; + } + + btTriangleInfoMap* getTriangleInfoMap() + { + return m_triangleInfoMap; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; + + virtual void serializeSingleBvh(btSerializer * serializer) const; + + virtual void serializeSingleTriangleInfoMap(btSerializer * serializer) const; +}; + +// clang-format off + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btTriangleMeshShapeData +{ + btCollisionShapeData m_collisionShapeData; + + btStridingMeshInterfaceData m_meshInterface; + + btQuantizedBvhFloatData *m_quantizedFloatBvh; + btQuantizedBvhDoubleData *m_quantizedDoubleBvh; + + btTriangleInfoMapData *m_triangleInfoMap; + + float m_collisionMargin; + + char m_pad3[4]; + +}; + +// clang-format on + +SIMD_FORCE_INLINE int btBvhTriangleMeshShape::calculateSerializeBufferSize() const +{ + return sizeof(btTriangleMeshShapeData); +} + +#endif //BT_BVH_TRIANGLE_MESH_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h.i new file mode 100644 index 00000000..9f681047 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.cpp new file mode 100644 index 00000000..7c337742 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.cpp @@ -0,0 +1,148 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btCapsuleShape.h" + +#include "LinearMath/btQuaternion.h" + +btCapsuleShape::btCapsuleShape(btScalar radius, btScalar height) : btConvexInternalShape() +{ + m_collisionMargin = radius; + m_shapeType = CAPSULE_SHAPE_PROXYTYPE; + m_upAxis = 1; + m_implicitShapeDimensions.setValue(radius, 0.5f * height, radius); +} + +btVector3 btCapsuleShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0) const +{ + btVector3 supVec(0, 0, 0); + + btScalar maxDot(btScalar(-BT_LARGE_FLOAT)); + + btVector3 vec = vec0; + btScalar lenSqr = vec.length2(); + if (lenSqr < btScalar(0.0001)) + { + vec.setValue(1, 0, 0); + } + else + { + btScalar rlen = btScalar(1.) / btSqrt(lenSqr); + vec *= rlen; + } + + btVector3 vtx; + btScalar newDot; + + { + btVector3 pos(0, 0, 0); + pos[getUpAxis()] = getHalfHeight(); + + vtx = pos; + newDot = vec.dot(vtx); + if (newDot > maxDot) + { + maxDot = newDot; + supVec = vtx; + } + } + { + btVector3 pos(0, 0, 0); + pos[getUpAxis()] = -getHalfHeight(); + + vtx = pos; + newDot = vec.dot(vtx); + if (newDot > maxDot) + { + maxDot = newDot; + supVec = vtx; + } + } + + return supVec; +} + +void btCapsuleShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + for (int j = 0; j < numVectors; j++) + { + btScalar maxDot(btScalar(-BT_LARGE_FLOAT)); + const btVector3& vec = vectors[j]; + + btVector3 vtx; + btScalar newDot; + { + btVector3 pos(0, 0, 0); + pos[getUpAxis()] = getHalfHeight(); + vtx = pos; + newDot = vec.dot(vtx); + if (newDot > maxDot) + { + maxDot = newDot; + supportVerticesOut[j] = vtx; + } + } + { + btVector3 pos(0, 0, 0); + pos[getUpAxis()] = -getHalfHeight(); + vtx = pos; + newDot = vec.dot(vtx); + if (newDot > maxDot) + { + maxDot = newDot; + supportVerticesOut[j] = vtx; + } + } + } +} + +void btCapsuleShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + //as an approximation, take the inertia of the box that bounds the spheres + + btTransform ident; + ident.setIdentity(); + + btScalar radius = getRadius(); + + btVector3 halfExtents(radius, radius, radius); + halfExtents[getUpAxis()] += getHalfHeight(); + + btScalar lx = btScalar(2.) * (halfExtents[0]); + btScalar ly = btScalar(2.) * (halfExtents[1]); + btScalar lz = btScalar(2.) * (halfExtents[2]); + const btScalar x2 = lx * lx; + const btScalar y2 = ly * ly; + const btScalar z2 = lz * lz; + const btScalar scaledmass = mass * btScalar(.08333333); + + inertia[0] = scaledmass * (y2 + z2); + inertia[1] = scaledmass * (x2 + z2); + inertia[2] = scaledmass * (x2 + y2); +} + +btCapsuleShapeX::btCapsuleShapeX(btScalar radius, btScalar height) +{ + m_collisionMargin = radius; + m_upAxis = 0; + m_implicitShapeDimensions.setValue(0.5f * height, radius, radius); +} + +btCapsuleShapeZ::btCapsuleShapeZ(btScalar radius, btScalar height) +{ + m_collisionMargin = radius; + m_upAxis = 2; + m_implicitShapeDimensions.setValue(radius, radius, 0.5f * height); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.cpp.i new file mode 100644 index 00000000..65c0c209 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btCapsuleShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btCapsuleShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btCapsuleShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.h new file mode 100644 index 00000000..138d0c0f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.h @@ -0,0 +1,182 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CAPSULE_SHAPE_H +#define BT_CAPSULE_SHAPE_H + +#include "btConvexInternalShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +///The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned around the X axis and btCapsuleShapeZ around the Z axis. +///The total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. +///The btCapsuleShape is a convex hull of two spheres. The btMultiSphereShape is a more general collision shape that takes the convex hull of multiple sphere, so it can also represent a capsule when just using two spheres. +ATTRIBUTE_ALIGNED16(class) +btCapsuleShape : public btConvexInternalShape +{ +protected: + int m_upAxis; + +protected: + ///only used for btCapsuleShapeZ and btCapsuleShapeX subclasses. + btCapsuleShape() : btConvexInternalShape() { m_shapeType = CAPSULE_SHAPE_PROXYTYPE; }; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btCapsuleShape(btScalar radius, btScalar height); + + ///CollisionShape Interface + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + /// btConvexShape Interface + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + virtual void setMargin(btScalar collisionMargin) + { + //don't override the margin for capsules, their entire radius == margin + (void)collisionMargin; + } + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const + { + btVector3 halfExtents(getRadius(), getRadius(), getRadius()); + halfExtents[m_upAxis] = getRadius() + getHalfHeight(); + btMatrix3x3 abs_b = t.getBasis().absolute(); + btVector3 center = t.getOrigin(); + btVector3 extent = halfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]); + + aabbMin = center - extent; + aabbMax = center + extent; + } + + virtual const char* getName() const + { + return "CapsuleShape"; + } + + int getUpAxis() const + { + return m_upAxis; + } + + btScalar getRadius() const + { + int radiusAxis = (m_upAxis + 2) % 3; + return m_implicitShapeDimensions[radiusAxis]; + } + + btScalar getHalfHeight() const + { + return m_implicitShapeDimensions[m_upAxis]; + } + + virtual void setLocalScaling(const btVector3& scaling) + { + btVector3 unScaledImplicitShapeDimensions = m_implicitShapeDimensions / m_localScaling; + btConvexInternalShape::setLocalScaling(scaling); + m_implicitShapeDimensions = (unScaledImplicitShapeDimensions * scaling); + //update m_collisionMargin, since entire radius==margin + int radiusAxis = (m_upAxis + 2) % 3; + m_collisionMargin = m_implicitShapeDimensions[radiusAxis]; + } + + virtual btVector3 getAnisotropicRollingFrictionDirection() const + { + btVector3 aniDir(0, 0, 0); + aniDir[getUpAxis()] = 1; + return aniDir; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; + + SIMD_FORCE_INLINE void deSerializeFloat(struct btCapsuleShapeData * dataBuffer); +}; + +///btCapsuleShapeX represents a capsule around the Z axis +///the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. +class btCapsuleShapeX : public btCapsuleShape +{ +public: + btCapsuleShapeX(btScalar radius, btScalar height); + + //debugging + virtual const char* getName() const + { + return "CapsuleX"; + } +}; + +///btCapsuleShapeZ represents a capsule around the Z axis +///the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. +class btCapsuleShapeZ : public btCapsuleShape +{ +public: + btCapsuleShapeZ(btScalar radius, btScalar height); + + //debugging + virtual const char* getName() const + { + return "CapsuleZ"; + } +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btCapsuleShapeData +{ + btConvexInternalShapeData m_convexInternalShapeData; + + int m_upAxis; + + char m_padding[4]; +}; + +SIMD_FORCE_INLINE int btCapsuleShape::calculateSerializeBufferSize() const +{ + return sizeof(btCapsuleShapeData); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btCapsuleShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btCapsuleShapeData* shapeData = (btCapsuleShapeData*)dataBuffer; + + btConvexInternalShape::serialize(&shapeData->m_convexInternalShapeData, serializer); + + shapeData->m_upAxis = m_upAxis; + + // Fill padding with zeros to appease msan. + shapeData->m_padding[0] = 0; + shapeData->m_padding[1] = 0; + shapeData->m_padding[2] = 0; + shapeData->m_padding[3] = 0; + + return "btCapsuleShapeData"; +} + +SIMD_FORCE_INLINE void btCapsuleShape::deSerializeFloat(btCapsuleShapeData* dataBuffer) +{ + m_implicitShapeDimensions.deSerializeFloat(dataBuffer->m_convexInternalShapeData.m_implicitShapeDimensions); + m_collisionMargin = dataBuffer->m_convexInternalShapeData.m_collisionMargin; + m_localScaling.deSerializeFloat(dataBuffer->m_convexInternalShapeData.m_localScaling); + //it is best to already pre-allocate the matching btCapsuleShape*(X/Z) version to match m_upAxis + m_upAxis = dataBuffer->m_upAxis; +} + +#endif //BT_CAPSULE_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.h.i new file mode 100644 index 00000000..9d62a7cf --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCapsuleShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btCapsuleShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btCapsuleShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btCapsuleShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionMargin.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionMargin.h new file mode 100644 index 00000000..abd8ab3e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionMargin.h @@ -0,0 +1,24 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COLLISION_MARGIN_H +#define BT_COLLISION_MARGIN_H + +///The CONVEX_DISTANCE_MARGIN is a default collision margin for convex collision shapes derived from btConvexInternalShape. +///This collision margin is used by Gjk and some other algorithms +///Note that when creating small objects, you need to make sure to set a smaller collision margin, using the 'setMargin' API +#define CONVEX_DISTANCE_MARGIN btScalar(0.04) // btScalar(0.1)//;//btScalar(0.01) + +#endif //BT_COLLISION_MARGIN_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionMargin.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionMargin.h.i new file mode 100644 index 00000000..68ae94ac --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionMargin.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btCollisionMargin.h ---------------- + +%include "BulletCollision/CollisionShapes/btCollisionMargin.h" + +%{ +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.cpp new file mode 100644 index 00000000..0b3640a6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.cpp @@ -0,0 +1,119 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +#include "BulletCollision/CollisionShapes/btCollisionShape.h" +#include "LinearMath/btSerializer.h" + +/* + Make sure this dummy function never changes so that it + can be used by probes that are checking whether the + library is actually installed. +*/ +extern "C" +{ + void btBulletCollisionProbe(); + + void btBulletCollisionProbe() {} +} + +void btCollisionShape::getBoundingSphere(btVector3& center, btScalar& radius) const +{ + btTransform tr; + tr.setIdentity(); + btVector3 aabbMin, aabbMax; + + getAabb(tr, aabbMin, aabbMax); + + radius = (aabbMax - aabbMin).length() * btScalar(0.5); + center = (aabbMin + aabbMax) * btScalar(0.5); +} + +btScalar btCollisionShape::getContactBreakingThreshold(btScalar defaultContactThreshold) const +{ + return getAngularMotionDisc() * defaultContactThreshold; +} + +btScalar btCollisionShape::getAngularMotionDisc() const +{ + ///@todo cache this value, to improve performance + btVector3 center; + btScalar disc; + getBoundingSphere(center, disc); + disc += (center).length(); + return disc; +} + +void btCollisionShape::calculateTemporalAabb(const btTransform& curTrans, const btVector3& linvel, const btVector3& angvel, btScalar timeStep, btVector3& temporalAabbMin, btVector3& temporalAabbMax) const +{ + //start with static aabb + getAabb(curTrans, temporalAabbMin, temporalAabbMax); + + btScalar temporalAabbMaxx = temporalAabbMax.getX(); + btScalar temporalAabbMaxy = temporalAabbMax.getY(); + btScalar temporalAabbMaxz = temporalAabbMax.getZ(); + btScalar temporalAabbMinx = temporalAabbMin.getX(); + btScalar temporalAabbMiny = temporalAabbMin.getY(); + btScalar temporalAabbMinz = temporalAabbMin.getZ(); + + // add linear motion + btVector3 linMotion = linvel * timeStep; + ///@todo: simd would have a vector max/min operation, instead of per-element access + if (linMotion.x() > btScalar(0.)) + temporalAabbMaxx += linMotion.x(); + else + temporalAabbMinx += linMotion.x(); + if (linMotion.y() > btScalar(0.)) + temporalAabbMaxy += linMotion.y(); + else + temporalAabbMiny += linMotion.y(); + if (linMotion.z() > btScalar(0.)) + temporalAabbMaxz += linMotion.z(); + else + temporalAabbMinz += linMotion.z(); + + //add conservative angular motion + btScalar angularMotion = angvel.length() * getAngularMotionDisc() * timeStep; + btVector3 angularMotion3d(angularMotion, angularMotion, angularMotion); + temporalAabbMin = btVector3(temporalAabbMinx, temporalAabbMiny, temporalAabbMinz); + temporalAabbMax = btVector3(temporalAabbMaxx, temporalAabbMaxy, temporalAabbMaxz); + + temporalAabbMin -= angularMotion3d; + temporalAabbMax += angularMotion3d; +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +const char* btCollisionShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btCollisionShapeData* shapeData = (btCollisionShapeData*)dataBuffer; + char* name = (char*)serializer->findNameForPointer(this); + shapeData->m_name = (char*)serializer->getUniquePointer(name); + if (shapeData->m_name) + { + serializer->serializeName(name); + } + shapeData->m_shapeType = m_shapeType; + + // Fill padding with zeros to appease msan. + memset(shapeData->m_padding, 0, sizeof(shapeData->m_padding)); + + return "btCollisionShapeData"; +} + +void btCollisionShape::serializeSingleShape(btSerializer* serializer) const +{ + int len = calculateSerializeBufferSize(); + btChunk* chunk = serializer->allocate(len, 1); + const char* structType = serialize(chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_SHAPE_CODE, (void*)this); +} \ No newline at end of file diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.cpp.i new file mode 100644 index 00000000..b29979bb --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btCollisionShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btCollisionShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btCollisionShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.h new file mode 100644 index 00000000..16f9e0c7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.h @@ -0,0 +1,174 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COLLISION_SHAPE_H +#define BT_COLLISION_SHAPE_H + +#include "LinearMath/btTransform.h" +#include "LinearMath/btVector3.h" +#include "LinearMath/btMatrix3x3.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types +class btSerializer; + +///The btCollisionShape class provides an interface for collision shapes that can be shared among btCollisionObjects. +ATTRIBUTE_ALIGNED16(class) +btCollisionShape +{ +protected: + int m_shapeType; + void* m_userPointer; + int m_userIndex; + int m_userIndex2; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btCollisionShape() : m_shapeType(INVALID_SHAPE_PROXYTYPE), m_userPointer(0), m_userIndex(-1), m_userIndex2(-1) + { + } + + virtual ~btCollisionShape() + { + } + + ///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 = 0; + + virtual void getBoundingSphere(btVector3 & center, btScalar & radius) const; + + ///getAngularMotionDisc returns the maximum radius needed for Conservative Advancement to handle time-of-impact with rotations. + virtual btScalar getAngularMotionDisc() const; + + virtual btScalar getContactBreakingThreshold(btScalar defaultContactThresholdFactor) const; + + ///calculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0..timeStep) + ///result is conservative + void calculateTemporalAabb(const btTransform& curTrans, const btVector3& linvel, const btVector3& angvel, btScalar timeStep, btVector3& temporalAabbMin, btVector3& temporalAabbMax) const; + + SIMD_FORCE_INLINE bool isPolyhedral() const + { + return btBroadphaseProxy::isPolyhedral(getShapeType()); + } + + SIMD_FORCE_INLINE bool isConvex2d() const + { + return btBroadphaseProxy::isConvex2d(getShapeType()); + } + + SIMD_FORCE_INLINE bool isConvex() const + { + return btBroadphaseProxy::isConvex(getShapeType()); + } + SIMD_FORCE_INLINE bool isNonMoving() const + { + return btBroadphaseProxy::isNonMoving(getShapeType()); + } + SIMD_FORCE_INLINE bool isConcave() const + { + return btBroadphaseProxy::isConcave(getShapeType()); + } + SIMD_FORCE_INLINE bool isCompound() const + { + return btBroadphaseProxy::isCompound(getShapeType()); + } + + SIMD_FORCE_INLINE bool isSoftBody() const + { + return btBroadphaseProxy::isSoftBody(getShapeType()); + } + + ///isInfinite is used to catch simulation error (aabb check) + SIMD_FORCE_INLINE bool isInfinite() const + { + return btBroadphaseProxy::isInfinite(getShapeType()); + } + +#ifndef __SPU__ + virtual void setLocalScaling(const btVector3& scaling) = 0; + virtual const btVector3& getLocalScaling() const = 0; + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const = 0; + + //debugging support + virtual const char* getName() const = 0; +#endif //__SPU__ + + int getShapeType() const + { + return m_shapeType; + } + + ///the getAnisotropicRollingFrictionDirection can be used in combination with setAnisotropicFriction + ///See Bullet/Demos/RollingFrictionDemo for an example + virtual btVector3 getAnisotropicRollingFrictionDirection() const + { + return btVector3(1, 1, 1); + } + virtual void setMargin(btScalar margin) = 0; + virtual btScalar getMargin() const = 0; + + ///optional user data pointer + void setUserPointer(void* userPtr) + { + m_userPointer = userPtr; + } + + void* getUserPointer() const + { + return m_userPointer; + } + void setUserIndex(int index) + { + m_userIndex = index; + } + + int getUserIndex() const + { + return m_userIndex; + } + + void setUserIndex2(int index) + { + m_userIndex2 = index; + } + + int getUserIndex2() const + { + return m_userIndex2; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; + + virtual void serializeSingleShape(btSerializer * serializer) const; +}; + +// clang-format off +// parser needs * with the name +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btCollisionShapeData +{ + char *m_name; + int m_shapeType; + char m_padding[4]; +}; +// clang-format on +SIMD_FORCE_INLINE int btCollisionShape::calculateSerializeBufferSize() const +{ + return sizeof(btCollisionShapeData); +} + +#endif //BT_COLLISION_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.h.i new file mode 100644 index 00000000..9fe4da70 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCollisionShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btCollisionShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btCollisionShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btCollisionShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.cpp new file mode 100644 index 00000000..fd7828b1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.cpp @@ -0,0 +1,335 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btCompoundShape.h" +#include "btCollisionShape.h" +#include "BulletCollision/BroadphaseCollision/btDbvt.h" +#include "LinearMath/btSerializer.h" + +btCompoundShape::btCompoundShape(bool enableDynamicAabbTree, const int initialChildCapacity) + : m_localAabbMin(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)), + m_localAabbMax(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)), + m_dynamicAabbTree(0), + m_updateRevision(1), + m_collisionMargin(btScalar(0.)), + m_localScaling(btScalar(1.), btScalar(1.), btScalar(1.)) +{ + m_shapeType = COMPOUND_SHAPE_PROXYTYPE; + + if (enableDynamicAabbTree) + { + void* mem = btAlignedAlloc(sizeof(btDbvt), 16); + m_dynamicAabbTree = new (mem) btDbvt(); + btAssert(mem == m_dynamicAabbTree); + } + + m_children.reserve(initialChildCapacity); +} + +btCompoundShape::~btCompoundShape() +{ + if (m_dynamicAabbTree) + { + m_dynamicAabbTree->~btDbvt(); + btAlignedFree(m_dynamicAabbTree); + } +} + +void btCompoundShape::addChildShape(const btTransform& localTransform, btCollisionShape* shape) +{ + m_updateRevision++; + //m_childTransforms.push_back(localTransform); + //m_childShapes.push_back(shape); + btCompoundShapeChild child; + child.m_node = 0; + child.m_transform = localTransform; + child.m_childShape = shape; + child.m_childShapeType = shape->getShapeType(); + child.m_childMargin = shape->getMargin(); + + //extend the local aabbMin/aabbMax + btVector3 localAabbMin, localAabbMax; + shape->getAabb(localTransform, localAabbMin, localAabbMax); + for (int i = 0; i < 3; i++) + { + if (m_localAabbMin[i] > localAabbMin[i]) + { + m_localAabbMin[i] = localAabbMin[i]; + } + if (m_localAabbMax[i] < localAabbMax[i]) + { + m_localAabbMax[i] = localAabbMax[i]; + } + } + if (m_dynamicAabbTree) + { + const btDbvtVolume bounds = btDbvtVolume::FromMM(localAabbMin, localAabbMax); + size_t index = m_children.size(); + child.m_node = m_dynamicAabbTree->insert(bounds, reinterpret_cast(index)); + } + + m_children.push_back(child); +} + +void btCompoundShape::updateChildTransform(int childIndex, const btTransform& newChildTransform, bool shouldRecalculateLocalAabb) +{ + m_children[childIndex].m_transform = newChildTransform; + + if (m_dynamicAabbTree) + { + ///update the dynamic aabb tree + btVector3 localAabbMin, localAabbMax; + m_children[childIndex].m_childShape->getAabb(newChildTransform, localAabbMin, localAabbMax); + ATTRIBUTE_ALIGNED16(btDbvtVolume) + bounds = btDbvtVolume::FromMM(localAabbMin, localAabbMax); + //int index = m_children.size()-1; + m_dynamicAabbTree->update(m_children[childIndex].m_node, bounds); + } + + if (shouldRecalculateLocalAabb) + { + recalculateLocalAabb(); + } +} + +void btCompoundShape::removeChildShapeByIndex(int childShapeIndex) +{ + m_updateRevision++; + btAssert(childShapeIndex >= 0 && childShapeIndex < m_children.size()); + if (m_dynamicAabbTree) + { + m_dynamicAabbTree->remove(m_children[childShapeIndex].m_node); + } + m_children.swap(childShapeIndex, m_children.size() - 1); + if (m_dynamicAabbTree) + m_children[childShapeIndex].m_node->dataAsInt = childShapeIndex; + m_children.pop_back(); +} + +void btCompoundShape::removeChildShape(btCollisionShape* shape) +{ + m_updateRevision++; + // Find the children containing the shape specified, and remove those children. + //note: there might be multiple children using the same shape! + for (int i = m_children.size() - 1; i >= 0; i--) + { + if (m_children[i].m_childShape == shape) + { + removeChildShapeByIndex(i); + } + } + + recalculateLocalAabb(); +} + +void btCompoundShape::recalculateLocalAabb() +{ + // Recalculate the local aabb + // Brute force, it iterates over all the shapes left. + + m_localAabbMin = btVector3(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + m_localAabbMax = btVector3(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + + //extend the local aabbMin/aabbMax + for (int j = 0; j < m_children.size(); j++) + { + btVector3 localAabbMin, localAabbMax; + m_children[j].m_childShape->getAabb(m_children[j].m_transform, localAabbMin, localAabbMax); + for (int i = 0; i < 3; i++) + { + if (m_localAabbMin[i] > localAabbMin[i]) + m_localAabbMin[i] = localAabbMin[i]; + if (m_localAabbMax[i] < localAabbMax[i]) + m_localAabbMax[i] = localAabbMax[i]; + } + } +} + +///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version +void btCompoundShape::getAabb(const btTransform& trans, btVector3& aabbMin, btVector3& aabbMax) const +{ + btVector3 localHalfExtents = btScalar(0.5) * (m_localAabbMax - m_localAabbMin); + btVector3 localCenter = btScalar(0.5) * (m_localAabbMax + m_localAabbMin); + + //avoid an illegal AABB when there are no children + if (!m_children.size()) + { + localHalfExtents.setValue(0, 0, 0); + localCenter.setValue(0, 0, 0); + } + localHalfExtents += btVector3(getMargin(), getMargin(), getMargin()); + + btMatrix3x3 abs_b = trans.getBasis().absolute(); + + btVector3 center = trans(localCenter); + + btVector3 extent = localHalfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]); + aabbMin = center - extent; + aabbMax = center + extent; +} + +void btCompoundShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + //approximation: take the inertia from the aabb for now + btTransform ident; + ident.setIdentity(); + btVector3 aabbMin, aabbMax; + getAabb(ident, aabbMin, aabbMax); + + btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5); + + btScalar lx = btScalar(2.) * (halfExtents.x()); + btScalar ly = btScalar(2.) * (halfExtents.y()); + btScalar lz = btScalar(2.) * (halfExtents.z()); + + inertia[0] = mass / (btScalar(12.0)) * (ly * ly + lz * lz); + inertia[1] = mass / (btScalar(12.0)) * (lx * lx + lz * lz); + inertia[2] = mass / (btScalar(12.0)) * (lx * lx + ly * ly); +} + +void btCompoundShape::calculatePrincipalAxisTransform(const btScalar* masses, btTransform& principal, btVector3& inertia) const +{ + int n = m_children.size(); + + btScalar totalMass = 0; + btVector3 center(0, 0, 0); + int k; + + for (k = 0; k < n; k++) + { + btAssert(masses[k] > 0); + center += m_children[k].m_transform.getOrigin() * masses[k]; + totalMass += masses[k]; + } + + btAssert(totalMass > 0); + + center /= totalMass; + principal.setOrigin(center); + + btMatrix3x3 tensor(0, 0, 0, 0, 0, 0, 0, 0, 0); + for (k = 0; k < n; k++) + { + btVector3 i; + m_children[k].m_childShape->calculateLocalInertia(masses[k], i); + + const btTransform& t = m_children[k].m_transform; + btVector3 o = t.getOrigin() - center; + + //compute inertia tensor in coordinate system of compound shape + btMatrix3x3 j = t.getBasis().transpose(); + j[0] *= i[0]; + j[1] *= i[1]; + j[2] *= i[2]; + j = t.getBasis() * j; + + //add inertia tensor + tensor[0] += j[0]; + tensor[1] += j[1]; + tensor[2] += j[2]; + + //compute inertia tensor of pointmass at o + btScalar o2 = o.length2(); + j[0].setValue(o2, 0, 0); + j[1].setValue(0, o2, 0); + j[2].setValue(0, 0, o2); + j[0] += o * -o.x(); + j[1] += o * -o.y(); + j[2] += o * -o.z(); + + //add inertia tensor of pointmass + tensor[0] += masses[k] * j[0]; + tensor[1] += masses[k] * j[1]; + tensor[2] += masses[k] * j[2]; + } + + tensor.diagonalize(principal.getBasis(), btScalar(0.00001), 20); + inertia.setValue(tensor[0][0], tensor[1][1], tensor[2][2]); +} + +void btCompoundShape::setLocalScaling(const btVector3& scaling) +{ + for (int i = 0; i < m_children.size(); i++) + { + btTransform childTrans = getChildTransform(i); + btVector3 childScale = m_children[i].m_childShape->getLocalScaling(); + // childScale = childScale * (childTrans.getBasis() * scaling); + childScale = childScale * scaling / m_localScaling; + m_children[i].m_childShape->setLocalScaling(childScale); + childTrans.setOrigin((childTrans.getOrigin()) * scaling / m_localScaling); + updateChildTransform(i, childTrans, false); + } + + m_localScaling = scaling; + recalculateLocalAabb(); +} + +void btCompoundShape::createAabbTreeFromChildren() +{ + if (!m_dynamicAabbTree) + { + void* mem = btAlignedAlloc(sizeof(btDbvt), 16); + m_dynamicAabbTree = new (mem) btDbvt(); + btAssert(mem == m_dynamicAabbTree); + + for (int index = 0; index < m_children.size(); index++) + { + btCompoundShapeChild& child = m_children[index]; + + //extend the local aabbMin/aabbMax + btVector3 localAabbMin, localAabbMax; + child.m_childShape->getAabb(child.m_transform, localAabbMin, localAabbMax); + + const btDbvtVolume bounds = btDbvtVolume::FromMM(localAabbMin, localAabbMax); + size_t index2 = index; + child.m_node = m_dynamicAabbTree->insert(bounds, reinterpret_cast(index2)); + } + } +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +const char* btCompoundShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btCompoundShapeData* shapeData = (btCompoundShapeData*)dataBuffer; + btCollisionShape::serialize(&shapeData->m_collisionShapeData, serializer); + + shapeData->m_collisionMargin = float(m_collisionMargin); + shapeData->m_numChildShapes = m_children.size(); + shapeData->m_childShapePtr = 0; + if (shapeData->m_numChildShapes) + { + btChunk* chunk = serializer->allocate(sizeof(btCompoundShapeChildData), shapeData->m_numChildShapes); + btCompoundShapeChildData* memPtr = (btCompoundShapeChildData*)chunk->m_oldPtr; + shapeData->m_childShapePtr = (btCompoundShapeChildData*)serializer->getUniquePointer(memPtr); + + for (int i = 0; i < shapeData->m_numChildShapes; i++, memPtr++) + { + memPtr->m_childMargin = float(m_children[i].m_childMargin); + memPtr->m_childShape = (btCollisionShapeData*)serializer->getUniquePointer(m_children[i].m_childShape); + //don't serialize shapes that already have been serialized + if (!serializer->findPointer(m_children[i].m_childShape)) + { + btChunk* chunk = serializer->allocate(m_children[i].m_childShape->calculateSerializeBufferSize(), 1); + const char* structType = m_children[i].m_childShape->serialize(chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_SHAPE_CODE, m_children[i].m_childShape); + } + + memPtr->m_childShapeType = m_children[i].m_childShapeType; + m_children[i].m_transform.serializeFloat(memPtr->m_transform); + } + serializer->finalizeChunk(chunk, "btCompoundShapeChildData", BT_ARRAY_CODE, chunk->m_oldPtr); + } + return "btCompoundShapeData"; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.cpp.i new file mode 100644 index 00000000..86ca5eee --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btCompoundShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btCompoundShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btCompoundShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.h new file mode 100644 index 00000000..7e2d0eb8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.h @@ -0,0 +1,207 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COMPOUND_SHAPE_H +#define BT_COMPOUND_SHAPE_H + +#include "btCollisionShape.h" + +#include "LinearMath/btVector3.h" +#include "LinearMath/btTransform.h" +#include "LinearMath/btMatrix3x3.h" +#include "btCollisionMargin.h" +#include "LinearMath/btAlignedObjectArray.h" + +//class btOptimizedBvh; +struct btDbvt; + +ATTRIBUTE_ALIGNED16(struct) +btCompoundShapeChild +{ + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btTransform m_transform; + btCollisionShape* m_childShape; + int m_childShapeType; + btScalar m_childMargin; + struct btDbvtNode* m_node; +}; + +SIMD_FORCE_INLINE bool operator==(const btCompoundShapeChild& c1, const btCompoundShapeChild& c2) +{ + return (c1.m_transform == c2.m_transform && + c1.m_childShape == c2.m_childShape && + c1.m_childShapeType == c2.m_childShapeType && + c1.m_childMargin == c2.m_childMargin); +} + +/// The btCompoundShape allows to store multiple other btCollisionShapes +/// This allows for moving concave collision objects. This is more general then the static concave btBvhTriangleMeshShape. +/// It has an (optional) dynamic aabb tree to accelerate early rejection tests. +/// @todo: This aabb tree can also be use to speed up ray tests on btCompoundShape, see http://code.google.com/p/bullet/issues/detail?id=25 +/// Currently, removal of child shapes is only supported when disabling the aabb tree (pass 'false' in the constructor of btCompoundShape) +ATTRIBUTE_ALIGNED16(class) +btCompoundShape : public btCollisionShape +{ +protected: + btAlignedObjectArray m_children; + btVector3 m_localAabbMin; + btVector3 m_localAabbMax; + + btDbvt* m_dynamicAabbTree; + + ///increment m_updateRevision when adding/removing/replacing child shapes, so that some caches can be updated + int m_updateRevision; + + btScalar m_collisionMargin; + + btVector3 m_localScaling; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + explicit btCompoundShape(bool enableDynamicAabbTree = true, const int initialChildCapacity = 0); + + virtual ~btCompoundShape(); + + void addChildShape(const btTransform& localTransform, btCollisionShape* shape); + + /// Remove all children shapes that contain the specified shape + virtual void removeChildShape(btCollisionShape * shape); + + void removeChildShapeByIndex(int childShapeindex); + + int getNumChildShapes() const + { + return int(m_children.size()); + } + + btCollisionShape* getChildShape(int index) + { + return m_children[index].m_childShape; + } + const btCollisionShape* getChildShape(int index) const + { + return m_children[index].m_childShape; + } + + btTransform& getChildTransform(int index) + { + return m_children[index].m_transform; + } + const btTransform& getChildTransform(int index) const + { + return m_children[index].m_transform; + } + + ///set a new transform for a child, and update internal data structures (local aabb and dynamic tree) + void updateChildTransform(int childIndex, const btTransform& newChildTransform, bool shouldRecalculateLocalAabb = true); + + btCompoundShapeChild* getChildList() + { + return &m_children[0]; + } + + ///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + /** Re-calculate the local Aabb. Is called at the end of removeChildShapes. + Use this yourself if you modify the children or their transforms. */ + virtual void recalculateLocalAabb(); + + virtual void setLocalScaling(const btVector3& scaling); + + virtual const btVector3& getLocalScaling() const + { + return m_localScaling; + } + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + virtual void setMargin(btScalar margin) + { + m_collisionMargin = margin; + } + virtual btScalar getMargin() const + { + return m_collisionMargin; + } + virtual const char* getName() const + { + return "Compound"; + } + + const btDbvt* getDynamicAabbTree() const + { + return m_dynamicAabbTree; + } + + btDbvt* getDynamicAabbTree() + { + return m_dynamicAabbTree; + } + + void createAabbTreeFromChildren(); + + ///computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia + ///and the center of mass to the current coordinate system. "masses" points to an array of masses of the children. The resulting transform + ///"principal" has to be applied inversely to all children transforms in order for the local coordinate system of the compound + ///shape to be centered at the center of mass and to coincide with the principal axes. This also necessitates a correction of the world transform + ///of the collision object by the principal transform. + void calculatePrincipalAxisTransform(const btScalar* masses, btTransform& principal, btVector3& inertia) const; + + int getUpdateRevision() const + { + return m_updateRevision; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +// clang-format off + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btCompoundShapeChildData +{ + btTransformFloatData m_transform; + btCollisionShapeData *m_childShape; + int m_childShapeType; + float m_childMargin; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btCompoundShapeData +{ + btCollisionShapeData m_collisionShapeData; + + btCompoundShapeChildData *m_childShapePtr; + + int m_numChildShapes; + + float m_collisionMargin; + +}; + +// clang-format on + +SIMD_FORCE_INLINE int btCompoundShape::calculateSerializeBufferSize() const +{ + return sizeof(btCompoundShapeData); +} + +#endif //BT_COMPOUND_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.h.i new file mode 100644 index 00000000..85bdc1ac --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCompoundShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btCompoundShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btCompoundShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btCompoundShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.cpp new file mode 100644 index 00000000..5d396844 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.cpp @@ -0,0 +1,24 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btConcaveShape.h" + +btConcaveShape::btConcaveShape() : m_collisionMargin(btScalar(0.)) +{ +} + +btConcaveShape::~btConcaveShape() +{ +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.cpp.i new file mode 100644 index 00000000..2cf18c7d --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConcaveShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btConcaveShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btConcaveShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.h new file mode 100644 index 00000000..716624e1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.h @@ -0,0 +1,62 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONCAVE_SHAPE_H +#define BT_CONCAVE_SHAPE_H + +#include "btCollisionShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +#include "btTriangleCallback.h" + +/// PHY_ScalarType enumerates possible scalar types. +/// See the btStridingMeshInterface or btHeightfieldTerrainShape for its use +typedef enum PHY_ScalarType +{ + PHY_FLOAT, + PHY_DOUBLE, + PHY_INTEGER, + PHY_SHORT, + PHY_FIXEDPOINT88, + PHY_UCHAR +} PHY_ScalarType; + +///The btConcaveShape class provides an interface for non-moving (static) concave shapes. +///It has been implemented by the btStaticPlaneShape, btBvhTriangleMeshShape and btHeightfieldTerrainShape. +ATTRIBUTE_ALIGNED16(class) +btConcaveShape : public btCollisionShape +{ +protected: + btScalar m_collisionMargin; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btConcaveShape(); + + virtual ~btConcaveShape(); + + virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const = 0; + + virtual btScalar getMargin() const + { + return m_collisionMargin; + } + virtual void setMargin(btScalar collisionMargin) + { + m_collisionMargin = collisionMargin; + } +}; + +#endif //BT_CONCAVE_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.h.i new file mode 100644 index 00000000..c7fe7cc5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConcaveShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConcaveShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btConcaveShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btConcaveShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.cpp new file mode 100644 index 00000000..64a6f272 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.cpp @@ -0,0 +1,142 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btConeShape.h" + +btConeShape::btConeShape(btScalar radius, btScalar height) : btConvexInternalShape(), + m_radius(radius), + m_height(height) +{ + m_shapeType = CONE_SHAPE_PROXYTYPE; + setConeUpIndex(1); + btVector3 halfExtents; + m_sinAngle = (m_radius / btSqrt(m_radius * m_radius + m_height * m_height)); +} + +btConeShapeZ::btConeShapeZ(btScalar radius, btScalar height) : btConeShape(radius, height) +{ + setConeUpIndex(2); +} + +btConeShapeX::btConeShapeX(btScalar radius, btScalar height) : btConeShape(radius, height) +{ + setConeUpIndex(0); +} + +///choose upAxis index +void btConeShape::setConeUpIndex(int upIndex) +{ + switch (upIndex) + { + case 0: + m_coneIndices[0] = 1; + m_coneIndices[1] = 0; + m_coneIndices[2] = 2; + break; + case 1: + m_coneIndices[0] = 0; + m_coneIndices[1] = 1; + m_coneIndices[2] = 2; + break; + case 2: + m_coneIndices[0] = 0; + m_coneIndices[1] = 2; + m_coneIndices[2] = 1; + break; + default: + btAssert(0); + }; + + m_implicitShapeDimensions[m_coneIndices[0]] = m_radius; + m_implicitShapeDimensions[m_coneIndices[1]] = m_height; + m_implicitShapeDimensions[m_coneIndices[2]] = m_radius; +} + +btVector3 btConeShape::coneLocalSupport(const btVector3& v) const +{ + btScalar halfHeight = m_height * btScalar(0.5); + + if (v[m_coneIndices[1]] > v.length() * m_sinAngle) + { + btVector3 tmp; + + tmp[m_coneIndices[0]] = btScalar(0.); + tmp[m_coneIndices[1]] = halfHeight; + tmp[m_coneIndices[2]] = btScalar(0.); + return tmp; + } + else + { + btScalar s = btSqrt(v[m_coneIndices[0]] * v[m_coneIndices[0]] + v[m_coneIndices[2]] * v[m_coneIndices[2]]); + if (s > SIMD_EPSILON) + { + btScalar d = m_radius / s; + btVector3 tmp; + tmp[m_coneIndices[0]] = v[m_coneIndices[0]] * d; + tmp[m_coneIndices[1]] = -halfHeight; + tmp[m_coneIndices[2]] = v[m_coneIndices[2]] * d; + return tmp; + } + else + { + btVector3 tmp; + tmp[m_coneIndices[0]] = btScalar(0.); + tmp[m_coneIndices[1]] = -halfHeight; + tmp[m_coneIndices[2]] = btScalar(0.); + return tmp; + } + } +} + +btVector3 btConeShape::localGetSupportingVertexWithoutMargin(const btVector3& vec) const +{ + return coneLocalSupport(vec); +} + +void btConeShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + for (int i = 0; i < numVectors; i++) + { + const btVector3& vec = vectors[i]; + supportVerticesOut[i] = coneLocalSupport(vec); + } +} + +btVector3 btConeShape::localGetSupportingVertex(const btVector3& vec) const +{ + btVector3 supVertex = coneLocalSupport(vec); + if (getMargin() != btScalar(0.)) + { + btVector3 vecnorm = vec; + if (vecnorm.length2() < (SIMD_EPSILON * SIMD_EPSILON)) + { + vecnorm.setValue(btScalar(-1.), btScalar(-1.), btScalar(-1.)); + } + vecnorm.normalize(); + supVertex += getMargin() * vecnorm; + } + return supVertex; +} + +void btConeShape::setLocalScaling(const btVector3& scaling) +{ + int axis = m_coneIndices[1]; + int r1 = m_coneIndices[0]; + int r2 = m_coneIndices[2]; + m_height *= scaling[axis] / m_localScaling[axis]; + m_radius *= (scaling[r1] / m_localScaling[r1] + scaling[r2] / m_localScaling[r2]) / 2; + m_sinAngle = (m_radius / btSqrt(m_radius * m_radius + m_height * m_height)); + btConvexInternalShape::setLocalScaling(scaling); +} \ No newline at end of file diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.cpp.i new file mode 100644 index 00000000..4451d1a8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConeShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btConeShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btConeShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.h new file mode 100644 index 00000000..49f26bc4 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.h @@ -0,0 +1,175 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONE_MINKOWSKI_H +#define BT_CONE_MINKOWSKI_H + +#include "btConvexInternalShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +///The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y axis. The btConeShapeX is aligned around the X axis and btConeShapeZ around the Z axis. +ATTRIBUTE_ALIGNED16(class) +btConeShape : public btConvexInternalShape + +{ + btScalar m_sinAngle; + btScalar m_radius; + btScalar m_height; + int m_coneIndices[3]; + btVector3 coneLocalSupport(const btVector3& v) const; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btConeShape(btScalar radius, btScalar height); + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const; + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + btScalar getRadius() const { return m_radius; } + btScalar getHeight() const { return m_height; } + + void setRadius(const btScalar radius) + { + m_radius = radius; + } + void setHeight(const btScalar height) + { + m_height = height; + } + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const + { + btTransform identity; + identity.setIdentity(); + btVector3 aabbMin, aabbMax; + getAabb(identity, aabbMin, aabbMax); + + btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5); + + btScalar margin = getMargin(); + + btScalar lx = btScalar(2.) * (halfExtents.x() + margin); + btScalar ly = btScalar(2.) * (halfExtents.y() + margin); + btScalar lz = btScalar(2.) * (halfExtents.z() + margin); + const btScalar x2 = lx * lx; + const btScalar y2 = ly * ly; + const btScalar z2 = lz * lz; + const btScalar scaledmass = mass * btScalar(0.08333333); + + inertia = scaledmass * (btVector3(y2 + z2, x2 + z2, x2 + y2)); + + // inertia.x() = scaledmass * (y2+z2); + // inertia.y() = scaledmass * (x2+z2); + // inertia.z() = scaledmass * (x2+y2); + } + + virtual const char* getName() const + { + return "Cone"; + } + + ///choose upAxis index + void setConeUpIndex(int upIndex); + + int getConeUpIndex() const + { + return m_coneIndices[1]; + } + + virtual btVector3 getAnisotropicRollingFrictionDirection() const + { + return btVector3(0, 1, 0); + } + + virtual void setLocalScaling(const btVector3& scaling); + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +///btConeShape implements a Cone shape, around the X axis +class btConeShapeX : public btConeShape +{ +public: + btConeShapeX(btScalar radius, btScalar height); + + virtual btVector3 getAnisotropicRollingFrictionDirection() const + { + return btVector3(1, 0, 0); + } + + //debugging + virtual const char* getName() const + { + return "ConeX"; + } +}; + +///btConeShapeZ implements a Cone shape, around the Z axis +class btConeShapeZ : public btConeShape +{ +public: + btConeShapeZ(btScalar radius, btScalar height); + + virtual btVector3 getAnisotropicRollingFrictionDirection() const + { + return btVector3(0, 0, 1); + } + + //debugging + virtual const char* getName() const + { + return "ConeZ"; + } +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btConeShapeData +{ + btConvexInternalShapeData m_convexInternalShapeData; + + int m_upIndex; + + char m_padding[4]; +}; + +SIMD_FORCE_INLINE int btConeShape::calculateSerializeBufferSize() const +{ + return sizeof(btConeShapeData); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btConeShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btConeShapeData* shapeData = (btConeShapeData*)dataBuffer; + + btConvexInternalShape::serialize(&shapeData->m_convexInternalShapeData, serializer); + + shapeData->m_upIndex = m_coneIndices[1]; + + // Fill padding with zeros to appease msan. + shapeData->m_padding[0] = 0; + shapeData->m_padding[1] = 0; + shapeData->m_padding[2] = 0; + shapeData->m_padding[3] = 0; + + return "btConeShapeData"; +} + +#endif //BT_CONE_MINKOWSKI_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.h.i new file mode 100644 index 00000000..63a31eb9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConeShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConeShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btConeShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btConeShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.cpp new file mode 100644 index 00000000..7d3d1d36 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.cpp @@ -0,0 +1,86 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btConvex2dShape.h" + +btConvex2dShape::btConvex2dShape(btConvexShape* convexChildShape) : btConvexShape(), m_childConvexShape(convexChildShape) +{ + m_shapeType = CONVEX_2D_SHAPE_PROXYTYPE; +} + +btConvex2dShape::~btConvex2dShape() +{ +} + +btVector3 btConvex2dShape::localGetSupportingVertexWithoutMargin(const btVector3& vec) const +{ + return m_childConvexShape->localGetSupportingVertexWithoutMargin(vec); +} + +void btConvex2dShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + m_childConvexShape->batchedUnitVectorGetSupportingVertexWithoutMargin(vectors, supportVerticesOut, numVectors); +} + +btVector3 btConvex2dShape::localGetSupportingVertex(const btVector3& vec) const +{ + return m_childConvexShape->localGetSupportingVertex(vec); +} + +void btConvex2dShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + ///this linear upscaling is not realistic, but we don't deal with large mass ratios... + m_childConvexShape->calculateLocalInertia(mass, inertia); +} + +///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version +void btConvex2dShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + m_childConvexShape->getAabb(t, aabbMin, aabbMax); +} + +void btConvex2dShape::getAabbSlow(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + m_childConvexShape->getAabbSlow(t, aabbMin, aabbMax); +} + +void btConvex2dShape::setLocalScaling(const btVector3& scaling) +{ + m_childConvexShape->setLocalScaling(scaling); +} + +const btVector3& btConvex2dShape::getLocalScaling() const +{ + return m_childConvexShape->getLocalScaling(); +} + +void btConvex2dShape::setMargin(btScalar margin) +{ + m_childConvexShape->setMargin(margin); +} +btScalar btConvex2dShape::getMargin() const +{ + return m_childConvexShape->getMargin(); +} + +int btConvex2dShape::getNumPreferredPenetrationDirections() const +{ + return m_childConvexShape->getNumPreferredPenetrationDirections(); +} + +void btConvex2dShape::getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const +{ + m_childConvexShape->getPreferredPenetrationDirection(index, penetrationVector); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.cpp.i new file mode 100644 index 00000000..47fd32da --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvex2dShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btConvex2dShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btConvex2dShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.h new file mode 100644 index 00000000..cd4f1ef7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.h @@ -0,0 +1,77 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_2D_SHAPE_H +#define BT_CONVEX_2D_SHAPE_H + +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +///The btConvex2dShape allows to use arbitrary convex shapes as 2d convex shapes, with the Z component assumed to be 0. +///For 2d boxes, the btBox2dShape is recommended. +ATTRIBUTE_ALIGNED16(class) +btConvex2dShape : public btConvexShape +{ + btConvexShape* m_childConvexShape; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btConvex2dShape(btConvexShape * convexChildShape); + + virtual ~btConvex2dShape(); + + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const; + + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + btConvexShape* getChildShape() + { + return m_childConvexShape; + } + + const btConvexShape* getChildShape() const + { + return m_childConvexShape; + } + + virtual const char* getName() const + { + return "Convex2dShape"; + } + + /////////////////////////// + + ///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version + void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void getAabbSlow(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void setLocalScaling(const btVector3& scaling); + virtual const btVector3& getLocalScaling() const; + + virtual void setMargin(btScalar margin); + virtual btScalar getMargin() const; + + virtual int getNumPreferredPenetrationDirections() const; + + virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const; +}; + +#endif //BT_CONVEX_2D_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.h.i new file mode 100644 index 00000000..9a2cd45d --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvex2dShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvex2dShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btConvex2dShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btConvex2dShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.cpp new file mode 100644 index 00000000..703de459 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.cpp @@ -0,0 +1,244 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#if defined(_WIN32) || defined(__i386__) +#define BT_USE_SSE_IN_API +#endif + +#include "btConvexHullShape.h" +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" + +#include "LinearMath/btQuaternion.h" +#include "LinearMath/btSerializer.h" +#include "btConvexPolyhedron.h" +#include "LinearMath/btConvexHullComputer.h" + +btConvexHullShape ::btConvexHullShape(const btScalar* points, int numPoints, int stride) : btPolyhedralConvexAabbCachingShape() +{ + m_shapeType = CONVEX_HULL_SHAPE_PROXYTYPE; + m_unscaledPoints.resize(numPoints); + + unsigned char* pointsAddress = (unsigned char*)points; + + for (int i = 0; i < numPoints; i++) + { + btScalar* point = (btScalar*)pointsAddress; + m_unscaledPoints[i] = btVector3(point[0], point[1], point[2]); + pointsAddress += stride; + } + + recalcLocalAabb(); +} + +void btConvexHullShape::setLocalScaling(const btVector3& scaling) +{ + m_localScaling = scaling; + recalcLocalAabb(); +} + +void btConvexHullShape::addPoint(const btVector3& point, bool recalculateLocalAabb) +{ + m_unscaledPoints.push_back(point); + if (recalculateLocalAabb) + recalcLocalAabb(); +} + +btVector3 btConvexHullShape::localGetSupportingVertexWithoutMargin(const btVector3& vec) const +{ + btVector3 supVec(btScalar(0.), btScalar(0.), btScalar(0.)); + btScalar maxDot = btScalar(-BT_LARGE_FLOAT); + + // Here we take advantage of dot(a, b*c) = dot(a*b, c). Note: This is true mathematically, but not numerically. + if (0 < m_unscaledPoints.size()) + { + btVector3 scaled = vec * m_localScaling; + int index = (int)scaled.maxDot(&m_unscaledPoints[0], m_unscaledPoints.size(), maxDot); // FIXME: may violate encapsulation of m_unscaledPoints + return m_unscaledPoints[index] * m_localScaling; + } + + return supVec; +} + +void btConvexHullShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + btScalar newDot; + //use 'w' component of supportVerticesOut? + { + for (int i = 0; i < numVectors; i++) + { + supportVerticesOut[i][3] = btScalar(-BT_LARGE_FLOAT); + } + } + + for (int j = 0; j < numVectors; j++) + { + btVector3 vec = vectors[j] * m_localScaling; // dot(a*b,c) = dot(a,b*c) + if (0 < m_unscaledPoints.size()) + { + int i = (int)vec.maxDot(&m_unscaledPoints[0], m_unscaledPoints.size(), newDot); + supportVerticesOut[j] = getScaledPoint(i); + supportVerticesOut[j][3] = newDot; + } + else + supportVerticesOut[j][3] = -BT_LARGE_FLOAT; + } +} + +btVector3 btConvexHullShape::localGetSupportingVertex(const btVector3& vec) const +{ + btVector3 supVertex = localGetSupportingVertexWithoutMargin(vec); + + if (getMargin() != btScalar(0.)) + { + btVector3 vecnorm = vec; + if (vecnorm.length2() < (SIMD_EPSILON * SIMD_EPSILON)) + { + vecnorm.setValue(btScalar(-1.), btScalar(-1.), btScalar(-1.)); + } + vecnorm.normalize(); + supVertex += getMargin() * vecnorm; + } + return supVertex; +} + +void btConvexHullShape::optimizeConvexHull() +{ + btConvexHullComputer conv; + conv.compute(&m_unscaledPoints[0].getX(), sizeof(btVector3), m_unscaledPoints.size(), 0.f, 0.f); + int numVerts = conv.vertices.size(); + m_unscaledPoints.resize(0); + for (int i = 0; i < numVerts; i++) + { + m_unscaledPoints.push_back(conv.vertices[i]); + } +} + +//currently just for debugging (drawing), perhaps future support for algebraic continuous collision detection +//Please note that you can debug-draw btConvexHullShape with the Raytracer Demo +int btConvexHullShape::getNumVertices() const +{ + return m_unscaledPoints.size(); +} + +int btConvexHullShape::getNumEdges() const +{ + return m_unscaledPoints.size(); +} + +void btConvexHullShape::getEdge(int i, btVector3& pa, btVector3& pb) const +{ + int index0 = i % m_unscaledPoints.size(); + int index1 = (i + 1) % m_unscaledPoints.size(); + pa = getScaledPoint(index0); + pb = getScaledPoint(index1); +} + +void btConvexHullShape::getVertex(int i, btVector3& vtx) const +{ + vtx = getScaledPoint(i); +} + +int btConvexHullShape::getNumPlanes() const +{ + return 0; +} + +void btConvexHullShape::getPlane(btVector3&, btVector3&, int) const +{ + btAssert(0); +} + +//not yet +bool btConvexHullShape::isInside(const btVector3&, btScalar) const +{ + btAssert(0); + return false; +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +const char* btConvexHullShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + //int szc = sizeof(btConvexHullShapeData); + btConvexHullShapeData* shapeData = (btConvexHullShapeData*)dataBuffer; + btConvexInternalShape::serialize(&shapeData->m_convexInternalShapeData, serializer); + + int numElem = m_unscaledPoints.size(); + shapeData->m_numUnscaledPoints = numElem; +#ifdef BT_USE_DOUBLE_PRECISION + shapeData->m_unscaledPointsFloatPtr = 0; + shapeData->m_unscaledPointsDoublePtr = numElem ? (btVector3Data*)serializer->getUniquePointer((void*)&m_unscaledPoints[0]) : 0; +#else + shapeData->m_unscaledPointsFloatPtr = numElem ? (btVector3Data*)serializer->getUniquePointer((void*)&m_unscaledPoints[0]) : 0; + shapeData->m_unscaledPointsDoublePtr = 0; +#endif + + if (numElem) + { + int sz = sizeof(btVector3Data); + // int sz2 = sizeof(btVector3DoubleData); + // int sz3 = sizeof(btVector3FloatData); + btChunk* chunk = serializer->allocate(sz, numElem); + btVector3Data* memPtr = (btVector3Data*)chunk->m_oldPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + m_unscaledPoints[i].serialize(*memPtr); + } + serializer->finalizeChunk(chunk, btVector3DataName, BT_ARRAY_CODE, (void*)&m_unscaledPoints[0]); + } + + // Fill padding with zeros to appease msan. + memset(shapeData->m_padding3, 0, sizeof(shapeData->m_padding3)); + + return "btConvexHullShapeData"; +} + +void btConvexHullShape::project(const btTransform& trans, const btVector3& dir, btScalar& minProj, btScalar& maxProj, btVector3& witnesPtMin, btVector3& witnesPtMax) const +{ +#if 1 + minProj = FLT_MAX; + maxProj = -FLT_MAX; + + int numVerts = m_unscaledPoints.size(); + for (int i = 0; i < numVerts; i++) + { + btVector3 vtx = m_unscaledPoints[i] * m_localScaling; + btVector3 pt = trans * vtx; + btScalar dp = pt.dot(dir); + if (dp < minProj) + { + minProj = dp; + witnesPtMin = pt; + } + if (dp > maxProj) + { + maxProj = dp; + witnesPtMax = pt; + } + } +#else + btVector3 localAxis = dir * trans.getBasis(); + witnesPtMin = trans(localGetSupportingVertex(localAxis)); + witnesPtMax = trans(localGetSupportingVertex(-localAxis)); + + minProj = witnesPtMin.dot(dir); + maxProj = witnesPtMax.dot(dir); +#endif + + if (minProj > maxProj) + { + btSwap(minProj, maxProj); + btSwap(witnesPtMin, witnesPtMax); + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.cpp.i new file mode 100644 index 00000000..8597565a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexHullShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btConvexHullShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btConvexHullShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.h new file mode 100644 index 00000000..01058a6c --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.h @@ -0,0 +1,117 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_HULL_SHAPE_H +#define BT_CONVEX_HULL_SHAPE_H + +#include "btPolyhedralConvexShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +#include "LinearMath/btAlignedObjectArray.h" + +///The btConvexHullShape implements an implicit convex hull of an array of vertices. +///Bullet provides a general and fast collision detector for convex shapes based on GJK and EPA using localGetSupportingVertex. +ATTRIBUTE_ALIGNED16(class) +btConvexHullShape : public btPolyhedralConvexAabbCachingShape +{ +protected: + btAlignedObjectArray m_unscaledPoints; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + ///this constructor optionally takes in a pointer to points. Each point is assumed to be 3 consecutive btScalar (x,y,z), the striding defines the number of bytes between each point, in memory. + ///It is easier to not pass any points in the constructor, and just add one point at a time, using addPoint. + ///btConvexHullShape make an internal copy of the points. + btConvexHullShape(const btScalar* points = 0, int numPoints = 0, int stride = sizeof(btVector3)); + + void addPoint(const btVector3& point, bool recalculateLocalAabb = true); + + btVector3* getUnscaledPoints() + { + return &m_unscaledPoints[0]; + } + + const btVector3* getUnscaledPoints() const + { + return &m_unscaledPoints[0]; + } + + ///getPoints is obsolete, please use getUnscaledPoints + const btVector3* getPoints() const + { + return getUnscaledPoints(); + } + + void optimizeConvexHull(); + + SIMD_FORCE_INLINE btVector3 getScaledPoint(int i) const + { + return m_unscaledPoints[i] * m_localScaling; + } + + SIMD_FORCE_INLINE int getNumPoints() const + { + return m_unscaledPoints.size(); + } + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const; + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + virtual void project(const btTransform& trans, const btVector3& dir, btScalar& minProj, btScalar& maxProj, btVector3& witnesPtMin, btVector3& witnesPtMax) const; + + //debugging + virtual const char* getName() const { return "Convex"; } + + virtual int getNumVertices() const; + virtual int getNumEdges() const; + virtual void getEdge(int i, btVector3& pa, btVector3& pb) const; + virtual void getVertex(int i, btVector3& vtx) const; + virtual int getNumPlanes() const; + virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const; + virtual bool isInside(const btVector3& pt, btScalar tolerance) const; + + ///in case we receive negative scaling + virtual void setLocalScaling(const btVector3& scaling); + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +// clang-format off + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btConvexHullShapeData +{ + btConvexInternalShapeData m_convexInternalShapeData; + + btVector3FloatData *m_unscaledPointsFloatPtr; + btVector3DoubleData *m_unscaledPointsDoublePtr; + + int m_numUnscaledPoints; + char m_padding3[4]; + +}; + +// clang-format on + +SIMD_FORCE_INLINE int btConvexHullShape::calculateSerializeBufferSize() const +{ + return sizeof(btConvexHullShapeData); +} + +#endif //BT_CONVEX_HULL_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.h.i new file mode 100644 index 00000000..ed458d72 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexHullShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexHullShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btConvexHullShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btConvexHullShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.cpp new file mode 100644 index 00000000..4d598b1a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.cpp @@ -0,0 +1,137 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btConvexInternalShape.h" + +btConvexInternalShape::btConvexInternalShape() + : m_localScaling(btScalar(1.), btScalar(1.), btScalar(1.)), + m_collisionMargin(CONVEX_DISTANCE_MARGIN) +{ +} + +void btConvexInternalShape::setLocalScaling(const btVector3& scaling) +{ + m_localScaling = scaling.absolute(); +} + +void btConvexInternalShape::getAabbSlow(const btTransform& trans, btVector3& minAabb, btVector3& maxAabb) const +{ +#ifndef __SPU__ + //use localGetSupportingVertexWithoutMargin? + btScalar margin = getMargin(); + for (int i = 0; i < 3; i++) + { + btVector3 vec(btScalar(0.), btScalar(0.), btScalar(0.)); + vec[i] = btScalar(1.); + + btVector3 sv = localGetSupportingVertex(vec * trans.getBasis()); + + btVector3 tmp = trans(sv); + maxAabb[i] = tmp[i] + margin; + vec[i] = btScalar(-1.); + tmp = trans(localGetSupportingVertex(vec * trans.getBasis())); + minAabb[i] = tmp[i] - margin; + } +#endif +} + +btVector3 btConvexInternalShape::localGetSupportingVertex(const btVector3& vec) const +{ +#ifndef __SPU__ + + btVector3 supVertex = localGetSupportingVertexWithoutMargin(vec); + + if (getMargin() != btScalar(0.)) + { + btVector3 vecnorm = vec; + if (vecnorm.length2() < (SIMD_EPSILON * SIMD_EPSILON)) + { + vecnorm.setValue(btScalar(-1.), btScalar(-1.), btScalar(-1.)); + } + vecnorm.normalize(); + supVertex += getMargin() * vecnorm; + } + return supVertex; + +#else + btAssert(0); + return btVector3(0, 0, 0); +#endif //__SPU__ +} + +btConvexInternalAabbCachingShape::btConvexInternalAabbCachingShape() + : btConvexInternalShape(), + m_localAabbMin(1, 1, 1), + m_localAabbMax(-1, -1, -1), + m_isLocalAabbValid(false) +{ +} + +void btConvexInternalAabbCachingShape::getAabb(const btTransform& trans, btVector3& aabbMin, btVector3& aabbMax) const +{ + getNonvirtualAabb(trans, aabbMin, aabbMax, getMargin()); +} + +void btConvexInternalAabbCachingShape::setLocalScaling(const btVector3& scaling) +{ + btConvexInternalShape::setLocalScaling(scaling); + recalcLocalAabb(); +} + +void btConvexInternalAabbCachingShape::recalcLocalAabb() +{ + m_isLocalAabbValid = true; + +#if 1 + static const btVector3 _directions[] = + { + btVector3(1., 0., 0.), + btVector3(0., 1., 0.), + btVector3(0., 0., 1.), + btVector3(-1., 0., 0.), + btVector3(0., -1., 0.), + btVector3(0., 0., -1.)}; + + btVector3 _supporting[] = + { + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.)}; + + batchedUnitVectorGetSupportingVertexWithoutMargin(_directions, _supporting, 6); + + for (int i = 0; i < 3; ++i) + { + m_localAabbMax[i] = _supporting[i][i] + m_collisionMargin; + m_localAabbMin[i] = _supporting[i + 3][i] - m_collisionMargin; + } + +#else + + for (int i = 0; i < 3; i++) + { + btVector3 vec(btScalar(0.), btScalar(0.), btScalar(0.)); + vec[i] = btScalar(1.); + btVector3 tmp = localGetSupportingVertex(vec); + m_localAabbMax[i] = tmp[i] + m_collisionMargin; + vec[i] = btScalar(-1.); + tmp = localGetSupportingVertex(vec); + m_localAabbMin[i] = tmp[i] - m_collisionMargin; + } +#endif +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.cpp.i new file mode 100644 index 00000000..1d7f0ec7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexInternalShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btConvexInternalShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btConvexInternalShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.h new file mode 100644 index 00000000..a28c57de --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.h @@ -0,0 +1,208 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_INTERNAL_SHAPE_H +#define BT_CONVEX_INTERNAL_SHAPE_H + +#include "btConvexShape.h" +#include "LinearMath/btAabbUtil2.h" + +///The btConvexInternalShape is an internal base class, shared by most convex shape implementations. +///The btConvexInternalShape uses a default collision margin set to CONVEX_DISTANCE_MARGIN. +///This collision margin used by Gjk and some other algorithms, see also btCollisionMargin.h +///Note that when creating small shapes (derived from btConvexInternalShape), +///you need to make sure to set a smaller collision margin, using the 'setMargin' API +///There is a automatic mechanism 'setSafeMargin' used by btBoxShape and btCylinderShape +ATTRIBUTE_ALIGNED16(class) +btConvexInternalShape : public btConvexShape +{ +protected: + //local scaling. collisionMargin is not scaled ! + btVector3 m_localScaling; + + btVector3 m_implicitShapeDimensions; + + btScalar m_collisionMargin; + + btScalar m_padding; + + btConvexInternalShape(); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + virtual ~btConvexInternalShape() + { + } + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const; + + const btVector3& getImplicitShapeDimensions() const + { + return m_implicitShapeDimensions; + } + + ///warning: use setImplicitShapeDimensions with care + ///changing a collision shape while the body is in the world is not recommended, + ///it is best to remove the body from the world, then make the change, and re-add it + ///alternatively flush the contact points, see documentation for 'cleanProxyFromPairs' + void setImplicitShapeDimensions(const btVector3& dimensions) + { + m_implicitShapeDimensions = dimensions; + } + + void setSafeMargin(btScalar minDimension, btScalar defaultMarginMultiplier = 0.1f) + { + btScalar safeMargin = defaultMarginMultiplier * minDimension; + if (safeMargin < getMargin()) + { + setMargin(safeMargin); + } + } + void setSafeMargin(const btVector3& halfExtents, btScalar defaultMarginMultiplier = 0.1f) + { + //see http://code.google.com/p/bullet/issues/detail?id=349 + //this margin check could could be added to other collision shapes too, + //or add some assert/warning somewhere + btScalar minDimension = halfExtents[halfExtents.minAxis()]; + setSafeMargin(minDimension, defaultMarginMultiplier); + } + + ///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version + void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const + { + getAabbSlow(t, aabbMin, aabbMax); + } + + virtual void getAabbSlow(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void setLocalScaling(const btVector3& scaling); + virtual const btVector3& getLocalScaling() const + { + return m_localScaling; + } + + const btVector3& getLocalScalingNV() const + { + return m_localScaling; + } + + virtual void setMargin(btScalar margin) + { + m_collisionMargin = margin; + } + virtual btScalar getMargin() const + { + return m_collisionMargin; + } + + btScalar getMarginNV() const + { + return m_collisionMargin; + } + + virtual int getNumPreferredPenetrationDirections() const + { + return 0; + } + + virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const + { + (void)penetrationVector; + (void)index; + btAssert(0); + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btConvexInternalShapeData +{ + btCollisionShapeData m_collisionShapeData; + + btVector3FloatData m_localScaling; + + btVector3FloatData m_implicitShapeDimensions; + + float m_collisionMargin; + + int m_padding; +}; + +SIMD_FORCE_INLINE int btConvexInternalShape::calculateSerializeBufferSize() const +{ + return sizeof(btConvexInternalShapeData); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btConvexInternalShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btConvexInternalShapeData* shapeData = (btConvexInternalShapeData*)dataBuffer; + btCollisionShape::serialize(&shapeData->m_collisionShapeData, serializer); + + m_implicitShapeDimensions.serializeFloat(shapeData->m_implicitShapeDimensions); + m_localScaling.serializeFloat(shapeData->m_localScaling); + shapeData->m_collisionMargin = float(m_collisionMargin); + + // Fill padding with zeros to appease msan. + shapeData->m_padding = 0; + + return "btConvexInternalShapeData"; +} + +///btConvexInternalAabbCachingShape adds local aabb caching for convex shapes, to avoid expensive bounding box calculations +class btConvexInternalAabbCachingShape : public btConvexInternalShape +{ + btVector3 m_localAabbMin; + btVector3 m_localAabbMax; + bool m_isLocalAabbValid; + +protected: + btConvexInternalAabbCachingShape(); + + void setCachedLocalAabb(const btVector3& aabbMin, const btVector3& aabbMax) + { + m_isLocalAabbValid = true; + m_localAabbMin = aabbMin; + m_localAabbMax = aabbMax; + } + + inline void getCachedLocalAabb(btVector3& aabbMin, btVector3& aabbMax) const + { + btAssert(m_isLocalAabbValid); + aabbMin = m_localAabbMin; + aabbMax = m_localAabbMax; + } + + inline void getNonvirtualAabb(const btTransform& trans, btVector3& aabbMin, btVector3& aabbMax, btScalar margin) const + { + //lazy evaluation of local aabb + btAssert(m_isLocalAabbValid); + btTransformAabb(m_localAabbMin, m_localAabbMax, margin, trans, aabbMin, aabbMax); + } + +public: + virtual void setLocalScaling(const btVector3& scaling); + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + void recalcLocalAabb(); +}; + +#endif //BT_CONVEX_INTERNAL_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.h.i new file mode 100644 index 00000000..469d4bfe --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexInternalShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexInternalShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btConvexInternalShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btConvexInternalShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp new file mode 100644 index 00000000..f00a440f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp @@ -0,0 +1,129 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btConvexPointCloudShape.h" +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" + +#include "LinearMath/btQuaternion.h" + +void btConvexPointCloudShape::setLocalScaling(const btVector3& scaling) +{ + m_localScaling = scaling; + recalcLocalAabb(); +} + +#ifndef __SPU__ +btVector3 btConvexPointCloudShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0) const +{ + btVector3 supVec(btScalar(0.), btScalar(0.), btScalar(0.)); + btScalar maxDot = btScalar(-BT_LARGE_FLOAT); + + btVector3 vec = vec0; + btScalar lenSqr = vec.length2(); + if (lenSqr < btScalar(0.0001)) + { + vec.setValue(1, 0, 0); + } + else + { + btScalar rlen = btScalar(1.) / btSqrt(lenSqr); + vec *= rlen; + } + + if (m_numPoints > 0) + { + // Here we take advantage of dot(a*b, c) = dot( a, b*c) to do less work. Note this transformation is true mathematically, not numerically. + // btVector3 scaled = vec * m_localScaling; + int index = (int)vec.maxDot(&m_unscaledPoints[0], m_numPoints, maxDot); //FIXME: may violate encapsulation of m_unscaledPoints + return getScaledPoint(index); + } + + return supVec; +} + +void btConvexPointCloudShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + for (int j = 0; j < numVectors; j++) + { + const btVector3& vec = vectors[j] * m_localScaling; // dot( a*c, b) = dot(a, b*c) + btScalar maxDot; + int index = (int)vec.maxDot(&m_unscaledPoints[0], m_numPoints, maxDot); + supportVerticesOut[j][3] = btScalar(-BT_LARGE_FLOAT); + if (0 <= index) + { + //WARNING: don't swap next lines, the w component would get overwritten! + supportVerticesOut[j] = getScaledPoint(index); + supportVerticesOut[j][3] = maxDot; + } + } +} + +btVector3 btConvexPointCloudShape::localGetSupportingVertex(const btVector3& vec) const +{ + btVector3 supVertex = localGetSupportingVertexWithoutMargin(vec); + + if (getMargin() != btScalar(0.)) + { + btVector3 vecnorm = vec; + if (vecnorm.length2() < (SIMD_EPSILON * SIMD_EPSILON)) + { + vecnorm.setValue(btScalar(-1.), btScalar(-1.), btScalar(-1.)); + } + vecnorm.normalize(); + supVertex += getMargin() * vecnorm; + } + return supVertex; +} + +#endif + +//currently just for debugging (drawing), perhaps future support for algebraic continuous collision detection +//Please note that you can debug-draw btConvexHullShape with the Raytracer Demo +int btConvexPointCloudShape::getNumVertices() const +{ + return m_numPoints; +} + +int btConvexPointCloudShape::getNumEdges() const +{ + return 0; +} + +void btConvexPointCloudShape::getEdge(int i, btVector3& pa, btVector3& pb) const +{ + btAssert(0); +} + +void btConvexPointCloudShape::getVertex(int i, btVector3& vtx) const +{ + vtx = m_unscaledPoints[i] * m_localScaling; +} + +int btConvexPointCloudShape::getNumPlanes() const +{ + return 0; +} + +void btConvexPointCloudShape::getPlane(btVector3&, btVector3&, int) const +{ + btAssert(0); +} + +//not yet +bool btConvexPointCloudShape::isInside(const btVector3&, btScalar) const +{ + btAssert(0); + return false; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp.i new file mode 100644 index 00000000..da51d92e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btConvexPointCloudShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.h new file mode 100644 index 00000000..c7d554a4 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.h @@ -0,0 +1,103 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_POINT_CLOUD_SHAPE_H +#define BT_CONVEX_POINT_CLOUD_SHAPE_H + +#include "btPolyhedralConvexShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +#include "LinearMath/btAlignedObjectArray.h" + +///The btConvexPointCloudShape implements an implicit convex hull of an array of vertices. +ATTRIBUTE_ALIGNED16(class) +btConvexPointCloudShape : public btPolyhedralConvexAabbCachingShape +{ + btVector3* m_unscaledPoints; + int m_numPoints; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btConvexPointCloudShape() + { + m_localScaling.setValue(1.f, 1.f, 1.f); + m_shapeType = CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE; + m_unscaledPoints = 0; + m_numPoints = 0; + } + + btConvexPointCloudShape(btVector3 * points, int numPoints, const btVector3& localScaling, bool computeAabb = true) + { + m_localScaling = localScaling; + m_shapeType = CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE; + m_unscaledPoints = points; + m_numPoints = numPoints; + + if (computeAabb) + recalcLocalAabb(); + } + + void setPoints(btVector3 * points, int numPoints, bool computeAabb = true, const btVector3& localScaling = btVector3(1.f, 1.f, 1.f)) + { + m_unscaledPoints = points; + m_numPoints = numPoints; + m_localScaling = localScaling; + + if (computeAabb) + recalcLocalAabb(); + } + + SIMD_FORCE_INLINE btVector3* getUnscaledPoints() + { + return m_unscaledPoints; + } + + SIMD_FORCE_INLINE const btVector3* getUnscaledPoints() const + { + return m_unscaledPoints; + } + + SIMD_FORCE_INLINE int getNumPoints() const + { + return m_numPoints; + } + + SIMD_FORCE_INLINE btVector3 getScaledPoint(int index) const + { + return m_unscaledPoints[index] * m_localScaling; + } + +#ifndef __SPU__ + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const; + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; +#endif + + //debugging + virtual const char* getName() const { return "ConvexPointCloud"; } + + virtual int getNumVertices() const; + virtual int getNumEdges() const; + virtual void getEdge(int i, btVector3& pa, btVector3& pb) const; + virtual void getVertex(int i, btVector3& vtx) const; + virtual int getNumPlanes() const; + virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const; + virtual bool isInside(const btVector3& pt, btScalar tolerance) const; + + ///in case we receive negative scaling + virtual void setLocalScaling(const btVector3& scaling); +}; + +#endif //BT_CONVEX_POINT_CLOUD_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.h.i new file mode 100644 index 00000000..29a1b903 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPointCloudShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexPointCloudShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btConvexPointCloudShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btConvexPointCloudShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.cpp new file mode 100644 index 00000000..9694f4dd --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.cpp @@ -0,0 +1,302 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///This file was written by Erwin Coumans +///Separating axis rest based on work from Pierre Terdiman, see +///And contact clipping based on work from Simon Hobbs + +#include "btConvexPolyhedron.h" +#include "LinearMath/btHashMap.h" + +btConvexPolyhedron::btConvexPolyhedron() +{ +} +btConvexPolyhedron::~btConvexPolyhedron() +{ +} + +inline bool IsAlmostZero1(const btVector3& v) +{ + if (btFabs(v.x()) > 1e-6 || btFabs(v.y()) > 1e-6 || btFabs(v.z()) > 1e-6) return false; + return true; +} + +struct btInternalVertexPair +{ + btInternalVertexPair(short int v0, short int v1) + : m_v0(v0), + m_v1(v1) + { + if (m_v1 > m_v0) + btSwap(m_v0, m_v1); + } + short int m_v0; + short int m_v1; + int getHash() const + { + return m_v0 + (m_v1 << 16); + } + bool equals(const btInternalVertexPair& other) const + { + return m_v0 == other.m_v0 && m_v1 == other.m_v1; + } +}; + +struct btInternalEdge +{ + btInternalEdge() + : m_face0(-1), + m_face1(-1) + { + } + short int m_face0; + short int m_face1; +}; + +// + +#ifdef TEST_INTERNAL_OBJECTS +bool btConvexPolyhedron::testContainment() const +{ + for (int p = 0; p < 8; p++) + { + btVector3 LocalPt; + if (p == 0) + LocalPt = m_localCenter + btVector3(m_extents[0], m_extents[1], m_extents[2]); + else if (p == 1) + LocalPt = m_localCenter + btVector3(m_extents[0], m_extents[1], -m_extents[2]); + else if (p == 2) + LocalPt = m_localCenter + btVector3(m_extents[0], -m_extents[1], m_extents[2]); + else if (p == 3) + LocalPt = m_localCenter + btVector3(m_extents[0], -m_extents[1], -m_extents[2]); + else if (p == 4) + LocalPt = m_localCenter + btVector3(-m_extents[0], m_extents[1], m_extents[2]); + else if (p == 5) + LocalPt = m_localCenter + btVector3(-m_extents[0], m_extents[1], -m_extents[2]); + else if (p == 6) + LocalPt = m_localCenter + btVector3(-m_extents[0], -m_extents[1], m_extents[2]); + else if (p == 7) + LocalPt = m_localCenter + btVector3(-m_extents[0], -m_extents[1], -m_extents[2]); + + for (int i = 0; i < m_faces.size(); i++) + { + const btVector3 Normal(m_faces[i].m_plane[0], m_faces[i].m_plane[1], m_faces[i].m_plane[2]); + const btScalar d = LocalPt.dot(Normal) + m_faces[i].m_plane[3]; + if (d > 0.0f) + return false; + } + } + return true; +} +#endif + +void btConvexPolyhedron::initialize() +{ + btHashMap edges; + + for (int i = 0; i < m_faces.size(); i++) + { + int numVertices = m_faces[i].m_indices.size(); + int NbTris = numVertices; + for (int j = 0; j < NbTris; j++) + { + int k = (j + 1) % numVertices; + btInternalVertexPair vp(m_faces[i].m_indices[j], m_faces[i].m_indices[k]); + btInternalEdge* edptr = edges.find(vp); + btVector3 edge = m_vertices[vp.m_v1] - m_vertices[vp.m_v0]; + edge.normalize(); + + bool found = false; + + for (int p = 0; p < m_uniqueEdges.size(); p++) + { + if (IsAlmostZero1(m_uniqueEdges[p] - edge) || + IsAlmostZero1(m_uniqueEdges[p] + edge)) + { + found = true; + break; + } + } + + if (!found) + { + m_uniqueEdges.push_back(edge); + } + + if (edptr) + { + btAssert(edptr->m_face0 >= 0); + btAssert(edptr->m_face1 < 0); + edptr->m_face1 = i; + } + else + { + btInternalEdge ed; + ed.m_face0 = i; + edges.insert(vp, ed); + } + } + } + +#ifdef USE_CONNECTED_FACES + for (int i = 0; i < m_faces.size(); i++) + { + int numVertices = m_faces[i].m_indices.size(); + m_faces[i].m_connectedFaces.resize(numVertices); + + for (int j = 0; j < numVertices; j++) + { + int k = (j + 1) % numVertices; + btInternalVertexPair vp(m_faces[i].m_indices[j], m_faces[i].m_indices[k]); + btInternalEdge* edptr = edges.find(vp); + btAssert(edptr); + btAssert(edptr->m_face0 >= 0); + btAssert(edptr->m_face1 >= 0); + + int connectedFace = (edptr->m_face0 == i) ? edptr->m_face1 : edptr->m_face0; + m_faces[i].m_connectedFaces[j] = connectedFace; + } + } +#endif //USE_CONNECTED_FACES + + initialize2(); +} + +void btConvexPolyhedron::initialize2() +{ + m_localCenter.setValue(0, 0, 0); + btScalar TotalArea = 0.0f; + for (int i = 0; i < m_faces.size(); i++) + { + int numVertices = m_faces[i].m_indices.size(); + int NbTris = numVertices - 2; + + const btVector3& p0 = m_vertices[m_faces[i].m_indices[0]]; + for (int j = 1; j <= NbTris; j++) + { + int k = (j + 1) % numVertices; + const btVector3& p1 = m_vertices[m_faces[i].m_indices[j]]; + const btVector3& p2 = m_vertices[m_faces[i].m_indices[k]]; + btScalar Area = ((p0 - p1).cross(p0 - p2)).length() * 0.5f; + btVector3 Center = (p0 + p1 + p2) / 3.0f; + m_localCenter += Area * Center; + TotalArea += Area; + } + } + m_localCenter /= TotalArea; + +#ifdef TEST_INTERNAL_OBJECTS + if (1) + { + m_radius = FLT_MAX; + for (int i = 0; i < m_faces.size(); i++) + { + const btVector3 Normal(m_faces[i].m_plane[0], m_faces[i].m_plane[1], m_faces[i].m_plane[2]); + const btScalar dist = btFabs(m_localCenter.dot(Normal) + m_faces[i].m_plane[3]); + if (dist < m_radius) + m_radius = dist; + } + + btScalar MinX = FLT_MAX; + btScalar MinY = FLT_MAX; + btScalar MinZ = FLT_MAX; + btScalar MaxX = -FLT_MAX; + btScalar MaxY = -FLT_MAX; + btScalar MaxZ = -FLT_MAX; + for (int i = 0; i < m_vertices.size(); i++) + { + const btVector3& pt = m_vertices[i]; + if (pt.x() < MinX) MinX = pt.x(); + if (pt.x() > MaxX) MaxX = pt.x(); + if (pt.y() < MinY) MinY = pt.y(); + if (pt.y() > MaxY) MaxY = pt.y(); + if (pt.z() < MinZ) MinZ = pt.z(); + if (pt.z() > MaxZ) MaxZ = pt.z(); + } + mC.setValue(MaxX + MinX, MaxY + MinY, MaxZ + MinZ); + mE.setValue(MaxX - MinX, MaxY - MinY, MaxZ - MinZ); + + // const btScalar r = m_radius / sqrtf(2.0f); + const btScalar r = m_radius / sqrtf(3.0f); + const int LargestExtent = mE.maxAxis(); + const btScalar Step = (mE[LargestExtent] * 0.5f - r) / 1024.0f; + m_extents[0] = m_extents[1] = m_extents[2] = r; + m_extents[LargestExtent] = mE[LargestExtent] * 0.5f; + bool FoundBox = false; + for (int j = 0; j < 1024; j++) + { + if (testContainment()) + { + FoundBox = true; + break; + } + + m_extents[LargestExtent] -= Step; + } + if (!FoundBox) + { + m_extents[0] = m_extents[1] = m_extents[2] = r; + } + else + { + // Refine the box + const btScalar Step = (m_radius - r) / 1024.0f; + const int e0 = (1 << LargestExtent) & 3; + const int e1 = (1 << e0) & 3; + + for (int j = 0; j < 1024; j++) + { + const btScalar Saved0 = m_extents[e0]; + const btScalar Saved1 = m_extents[e1]; + m_extents[e0] += Step; + m_extents[e1] += Step; + + if (!testContainment()) + { + m_extents[e0] = Saved0; + m_extents[e1] = Saved1; + break; + } + } + } + } +#endif +} +void btConvexPolyhedron::project(const btTransform& trans, const btVector3& dir, btScalar& minProj, btScalar& maxProj, btVector3& witnesPtMin, btVector3& witnesPtMax) const +{ + minProj = FLT_MAX; + maxProj = -FLT_MAX; + int numVerts = m_vertices.size(); + for (int i = 0; i < numVerts; i++) + { + btVector3 pt = trans * m_vertices[i]; + btScalar dp = pt.dot(dir); + if (dp < minProj) + { + minProj = dp; + witnesPtMin = pt; + } + if (dp > maxProj) + { + maxProj = dp; + witnesPtMax = pt; + } + } + if (minProj > maxProj) + { + btSwap(minProj, maxProj); + btSwap(witnesPtMin, witnesPtMax); + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.cpp.i new file mode 100644 index 00000000..33dfd91f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexPolyhedron.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btConvexPolyhedron.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btConvexPolyhedron.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.h new file mode 100644 index 00000000..638aa9b3 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.h @@ -0,0 +1,59 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///This file was written by Erwin Coumans + +#ifndef _BT_POLYHEDRAL_FEATURES_H +#define _BT_POLYHEDRAL_FEATURES_H + +#include "LinearMath/btTransform.h" +#include "LinearMath/btAlignedObjectArray.h" + +#define TEST_INTERNAL_OBJECTS 1 + +struct btFace +{ + btAlignedObjectArray m_indices; + // btAlignedObjectArray m_connectedFaces; + btScalar m_plane[4]; +}; + +ATTRIBUTE_ALIGNED16(class) +btConvexPolyhedron +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btConvexPolyhedron(); + virtual ~btConvexPolyhedron(); + + btAlignedObjectArray m_vertices; + btAlignedObjectArray m_faces; + btAlignedObjectArray m_uniqueEdges; + + btVector3 m_localCenter; + btVector3 m_extents; + btScalar m_radius; + btVector3 mC; + btVector3 mE; + + void initialize(); + void initialize2(); + bool testContainment() const; + + void project(const btTransform& trans, const btVector3& dir, btScalar& minProj, btScalar& maxProj, btVector3& witnesPtMin, btVector3& witnesPtMax) const; +}; + +#endif //_BT_POLYHEDRAL_FEATURES_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.h.i new file mode 100644 index 00000000..95d116d4 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexPolyhedron.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexPolyhedron.h ---------------- + +%include "BulletCollision/CollisionShapes/btConvexPolyhedron.h" + +%{ +#include "BulletCollision/CollisionShapes/btConvexPolyhedron.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.cpp new file mode 100644 index 00000000..f8fb0aa9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.cpp @@ -0,0 +1,458 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#if defined(_WIN32) || defined(__i386__) +#define BT_USE_SSE_IN_API +#endif + +#include "btConvexShape.h" +#include "btTriangleShape.h" +#include "btSphereShape.h" +#include "btCylinderShape.h" +#include "btConeShape.h" +#include "btCapsuleShape.h" +#include "btConvexHullShape.h" +#include "btConvexPointCloudShape.h" + +///not supported on IBM SDK, until we fix the alignment of btVector3 +#if defined(__CELLOS_LV2__) && defined(__SPU__) +#include +static inline vec_float4 vec_dot3(vec_float4 vec0, vec_float4 vec1) +{ + vec_float4 result; + result = spu_mul(vec0, vec1); + result = spu_madd(spu_rlqwbyte(vec0, 4), spu_rlqwbyte(vec1, 4), result); + return spu_madd(spu_rlqwbyte(vec0, 8), spu_rlqwbyte(vec1, 8), result); +} +#endif //__SPU__ + +btConvexShape::btConvexShape() +{ +} + +btConvexShape::~btConvexShape() +{ +} + +void btConvexShape::project(const btTransform& trans, const btVector3& dir, btScalar& min, btScalar& max, btVector3& witnesPtMin, btVector3& witnesPtMax) const +{ + btVector3 localAxis = dir * trans.getBasis(); + btVector3 vtx1 = trans(localGetSupportingVertex(localAxis)); + btVector3 vtx2 = trans(localGetSupportingVertex(-localAxis)); + + min = vtx1.dot(dir); + max = vtx2.dot(dir); + witnesPtMax = vtx2; + witnesPtMin = vtx1; + + if (min > max) + { + btScalar tmp = min; + min = max; + max = tmp; + witnesPtMax = vtx1; + witnesPtMin = vtx2; + } +} + +static btVector3 convexHullSupport(const btVector3& localDirOrg, const btVector3* points, int numPoints, const btVector3& localScaling) +{ + btVector3 vec = localDirOrg * localScaling; + +#if defined(__CELLOS_LV2__) && defined(__SPU__) + + btVector3 localDir = vec; + + vec_float4 v_distMax = {-FLT_MAX, 0, 0, 0}; + vec_int4 v_idxMax = {-999, 0, 0, 0}; + int v = 0; + int numverts = numPoints; + + for (; v < (int)numverts - 4; v += 4) + { + vec_float4 p0 = vec_dot3(points[v].get128(), localDir.get128()); + vec_float4 p1 = vec_dot3(points[v + 1].get128(), localDir.get128()); + vec_float4 p2 = vec_dot3(points[v + 2].get128(), localDir.get128()); + vec_float4 p3 = vec_dot3(points[v + 3].get128(), localDir.get128()); + const vec_int4 i0 = {v, 0, 0, 0}; + const vec_int4 i1 = {v + 1, 0, 0, 0}; + const vec_int4 i2 = {v + 2, 0, 0, 0}; + const vec_int4 i3 = {v + 3, 0, 0, 0}; + vec_uint4 retGt01 = spu_cmpgt(p0, p1); + vec_float4 pmax01 = spu_sel(p1, p0, retGt01); + vec_int4 imax01 = spu_sel(i1, i0, retGt01); + vec_uint4 retGt23 = spu_cmpgt(p2, p3); + vec_float4 pmax23 = spu_sel(p3, p2, retGt23); + vec_int4 imax23 = spu_sel(i3, i2, retGt23); + vec_uint4 retGt0123 = spu_cmpgt(pmax01, pmax23); + vec_float4 pmax0123 = spu_sel(pmax23, pmax01, retGt0123); + vec_int4 imax0123 = spu_sel(imax23, imax01, retGt0123); + vec_uint4 retGtMax = spu_cmpgt(v_distMax, pmax0123); + v_distMax = spu_sel(pmax0123, v_distMax, retGtMax); + v_idxMax = spu_sel(imax0123, v_idxMax, retGtMax); + } + for (; v < (int)numverts; v++) + { + vec_float4 p = vec_dot3(points[v].get128(), localDir.get128()); + const vec_int4 i = {v, 0, 0, 0}; + vec_uint4 retGtMax = spu_cmpgt(v_distMax, p); + v_distMax = spu_sel(p, v_distMax, retGtMax); + v_idxMax = spu_sel(i, v_idxMax, retGtMax); + } + int ptIndex = spu_extract(v_idxMax, 0); + const btVector3& supVec = points[ptIndex] * localScaling; + return supVec; +#else + + btScalar maxDot; + long ptIndex = vec.maxDot(points, numPoints, maxDot); + btAssert(ptIndex >= 0); + if (ptIndex < 0) + { + ptIndex = 0; + } + btVector3 supVec = points[ptIndex] * localScaling; + return supVec; +#endif //__SPU__ +} + +btVector3 btConvexShape::localGetSupportVertexWithoutMarginNonVirtual(const btVector3& localDir) const +{ + switch (m_shapeType) + { + case SPHERE_SHAPE_PROXYTYPE: + { + return btVector3(0, 0, 0); + } + case BOX_SHAPE_PROXYTYPE: + { + btBoxShape* convexShape = (btBoxShape*)this; + const btVector3& halfExtents = convexShape->getImplicitShapeDimensions(); + +#if defined(__APPLE__) && (defined(BT_USE_SSE) || defined(BT_USE_NEON)) +#if defined(BT_USE_SSE) + return btVector3(_mm_xor_ps(_mm_and_ps(localDir.mVec128, (__m128){-0.0f, -0.0f, -0.0f, -0.0f}), halfExtents.mVec128)); +#elif defined(BT_USE_NEON) + return btVector3((float32x4_t)(((uint32x4_t)localDir.mVec128 & (uint32x4_t){0x80000000, 0x80000000, 0x80000000, 0x80000000}) ^ (uint32x4_t)halfExtents.mVec128)); +#else +#error unknown vector arch +#endif +#else + return btVector3(btFsels(localDir.x(), halfExtents.x(), -halfExtents.x()), + btFsels(localDir.y(), halfExtents.y(), -halfExtents.y()), + btFsels(localDir.z(), halfExtents.z(), -halfExtents.z())); +#endif + } + case TRIANGLE_SHAPE_PROXYTYPE: + { + btTriangleShape* triangleShape = (btTriangleShape*)this; + btVector3 dir(localDir.getX(), localDir.getY(), localDir.getZ()); + btVector3* vertices = &triangleShape->m_vertices1[0]; + btVector3 dots = dir.dot3(vertices[0], vertices[1], vertices[2]); + btVector3 sup = vertices[dots.maxAxis()]; + return btVector3(sup.getX(), sup.getY(), sup.getZ()); + } + case CYLINDER_SHAPE_PROXYTYPE: + { + btCylinderShape* cylShape = (btCylinderShape*)this; + //mapping of halfextents/dimension onto radius/height depends on how cylinder local orientation is (upAxis) + + btVector3 halfExtents = cylShape->getImplicitShapeDimensions(); + btVector3 v(localDir.getX(), localDir.getY(), localDir.getZ()); + int cylinderUpAxis = cylShape->getUpAxis(); + int XX(1), YY(0), ZZ(2); + + switch (cylinderUpAxis) + { + case 0: + { + XX = 1; + YY = 0; + ZZ = 2; + } + break; + case 1: + { + XX = 0; + YY = 1; + ZZ = 2; + } + break; + case 2: + { + XX = 0; + YY = 2; + ZZ = 1; + } + break; + default: + btAssert(0); + break; + }; + + btScalar radius = halfExtents[XX]; + btScalar halfHeight = halfExtents[cylinderUpAxis]; + + btVector3 tmp; + btScalar d; + + btScalar s = btSqrt(v[XX] * v[XX] + v[ZZ] * v[ZZ]); + if (s != btScalar(0.0)) + { + d = radius / s; + tmp[XX] = v[XX] * d; + tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight; + tmp[ZZ] = v[ZZ] * d; + return btVector3(tmp.getX(), tmp.getY(), tmp.getZ()); + } + else + { + tmp[XX] = radius; + tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight; + tmp[ZZ] = btScalar(0.0); + return btVector3(tmp.getX(), tmp.getY(), tmp.getZ()); + } + } + case CAPSULE_SHAPE_PROXYTYPE: + { + btVector3 vec0(localDir.getX(), localDir.getY(), localDir.getZ()); + + btCapsuleShape* capsuleShape = (btCapsuleShape*)this; + btScalar halfHeight = capsuleShape->getHalfHeight(); + int capsuleUpAxis = capsuleShape->getUpAxis(); + + btVector3 supVec(0, 0, 0); + + btScalar maxDot(btScalar(-BT_LARGE_FLOAT)); + + btVector3 vec = vec0; + btScalar lenSqr = vec.length2(); + if (lenSqr < SIMD_EPSILON * SIMD_EPSILON) + { + vec.setValue(1, 0, 0); + } + else + { + btScalar rlen = btScalar(1.) / btSqrt(lenSqr); + vec *= rlen; + } + btVector3 vtx; + btScalar newDot; + { + btVector3 pos(0, 0, 0); + pos[capsuleUpAxis] = halfHeight; + + vtx = pos; + newDot = vec.dot(vtx); + + if (newDot > maxDot) + { + maxDot = newDot; + supVec = vtx; + } + } + { + btVector3 pos(0, 0, 0); + pos[capsuleUpAxis] = -halfHeight; + + vtx = pos; + newDot = vec.dot(vtx); + if (newDot > maxDot) + { + maxDot = newDot; + supVec = vtx; + } + } + return btVector3(supVec.getX(), supVec.getY(), supVec.getZ()); + } + case CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE: + { + btConvexPointCloudShape* convexPointCloudShape = (btConvexPointCloudShape*)this; + btVector3* points = convexPointCloudShape->getUnscaledPoints(); + int numPoints = convexPointCloudShape->getNumPoints(); + return convexHullSupport(localDir, points, numPoints, convexPointCloudShape->getLocalScalingNV()); + } + case CONVEX_HULL_SHAPE_PROXYTYPE: + { + btConvexHullShape* convexHullShape = (btConvexHullShape*)this; + btVector3* points = convexHullShape->getUnscaledPoints(); + int numPoints = convexHullShape->getNumPoints(); + return convexHullSupport(localDir, points, numPoints, convexHullShape->getLocalScalingNV()); + } + default: +#ifndef __SPU__ + return this->localGetSupportingVertexWithoutMargin(localDir); +#else + btAssert(0); +#endif + } + + // should never reach here + btAssert(0); + return btVector3(btScalar(0.0f), btScalar(0.0f), btScalar(0.0f)); +} + +btVector3 btConvexShape::localGetSupportVertexNonVirtual(const btVector3& localDir) const +{ + btVector3 localDirNorm = localDir; + if (localDirNorm.length2() < (SIMD_EPSILON * SIMD_EPSILON)) + { + localDirNorm.setValue(btScalar(-1.), btScalar(-1.), btScalar(-1.)); + } + localDirNorm.normalize(); + + return localGetSupportVertexWithoutMarginNonVirtual(localDirNorm) + getMarginNonVirtual() * localDirNorm; +} + +/* TODO: This should be bumped up to btCollisionShape () */ +btScalar btConvexShape::getMarginNonVirtual() const +{ + switch (m_shapeType) + { + case SPHERE_SHAPE_PROXYTYPE: + { + btSphereShape* sphereShape = (btSphereShape*)this; + return sphereShape->getRadius(); + } + case BOX_SHAPE_PROXYTYPE: + { + btBoxShape* convexShape = (btBoxShape*)this; + return convexShape->getMarginNV(); + } + case TRIANGLE_SHAPE_PROXYTYPE: + { + btTriangleShape* triangleShape = (btTriangleShape*)this; + return triangleShape->getMarginNV(); + } + case CYLINDER_SHAPE_PROXYTYPE: + { + btCylinderShape* cylShape = (btCylinderShape*)this; + return cylShape->getMarginNV(); + } + case CONE_SHAPE_PROXYTYPE: + { + btConeShape* conShape = (btConeShape*)this; + return conShape->getMarginNV(); + } + case CAPSULE_SHAPE_PROXYTYPE: + { + btCapsuleShape* capsuleShape = (btCapsuleShape*)this; + return capsuleShape->getMarginNV(); + } + case CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE: + /* fall through */ + case CONVEX_HULL_SHAPE_PROXYTYPE: + { + btPolyhedralConvexShape* convexHullShape = (btPolyhedralConvexShape*)this; + return convexHullShape->getMarginNV(); + } + default: +#ifndef __SPU__ + return this->getMargin(); +#else + btAssert(0); +#endif + } + + // should never reach here + btAssert(0); + return btScalar(0.0f); +} +#ifndef __SPU__ +void btConvexShape::getAabbNonVirtual(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + switch (m_shapeType) + { + case SPHERE_SHAPE_PROXYTYPE: + { + btSphereShape* sphereShape = (btSphereShape*)this; + btScalar radius = sphereShape->getImplicitShapeDimensions().getX(); // * convexShape->getLocalScaling().getX(); + btScalar margin = radius + sphereShape->getMarginNonVirtual(); + const btVector3& center = t.getOrigin(); + btVector3 extent(margin, margin, margin); + aabbMin = center - extent; + aabbMax = center + extent; + } + break; + case CYLINDER_SHAPE_PROXYTYPE: + /* fall through */ + case BOX_SHAPE_PROXYTYPE: + { + btBoxShape* convexShape = (btBoxShape*)this; + btScalar margin = convexShape->getMarginNonVirtual(); + btVector3 halfExtents = convexShape->getImplicitShapeDimensions(); + halfExtents += btVector3(margin, margin, margin); + btMatrix3x3 abs_b = t.getBasis().absolute(); + btVector3 center = t.getOrigin(); + btVector3 extent = halfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]); + + aabbMin = center - extent; + aabbMax = center + extent; + break; + } + case TRIANGLE_SHAPE_PROXYTYPE: + { + btTriangleShape* triangleShape = (btTriangleShape*)this; + btScalar margin = triangleShape->getMarginNonVirtual(); + for (int i = 0; i < 3; i++) + { + btVector3 vec(btScalar(0.), btScalar(0.), btScalar(0.)); + vec[i] = btScalar(1.); + + btVector3 sv = localGetSupportVertexWithoutMarginNonVirtual(vec * t.getBasis()); + + btVector3 tmp = t(sv); + aabbMax[i] = tmp[i] + margin; + vec[i] = btScalar(-1.); + tmp = t(localGetSupportVertexWithoutMarginNonVirtual(vec * t.getBasis())); + aabbMin[i] = tmp[i] - margin; + } + } + break; + case CAPSULE_SHAPE_PROXYTYPE: + { + btCapsuleShape* capsuleShape = (btCapsuleShape*)this; + btVector3 halfExtents(capsuleShape->getRadius(), capsuleShape->getRadius(), capsuleShape->getRadius()); + int m_upAxis = capsuleShape->getUpAxis(); + halfExtents[m_upAxis] = capsuleShape->getRadius() + capsuleShape->getHalfHeight(); + btMatrix3x3 abs_b = t.getBasis().absolute(); + btVector3 center = t.getOrigin(); + btVector3 extent = halfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]); + aabbMin = center - extent; + aabbMax = center + extent; + } + break; + case CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE: + case CONVEX_HULL_SHAPE_PROXYTYPE: + { + btPolyhedralConvexAabbCachingShape* convexHullShape = (btPolyhedralConvexAabbCachingShape*)this; + btScalar margin = convexHullShape->getMarginNonVirtual(); + convexHullShape->getNonvirtualAabb(t, aabbMin, aabbMax, margin); + } + break; + default: +#ifndef __SPU__ + this->getAabb(t, aabbMin, aabbMax); +#else + btAssert(0); +#endif + break; + } + + // should never reach here + btAssert(0); +} + +#endif //__SPU__ diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.cpp.i new file mode 100644 index 00000000..95523e3e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btConvexShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btConvexShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.h new file mode 100644 index 00000000..d3b3ed81 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.h @@ -0,0 +1,75 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_SHAPE_INTERFACE1 +#define BT_CONVEX_SHAPE_INTERFACE1 + +#include "btCollisionShape.h" + +#include "LinearMath/btVector3.h" +#include "LinearMath/btTransform.h" +#include "LinearMath/btMatrix3x3.h" +#include "btCollisionMargin.h" +#include "LinearMath/btAlignedAllocator.h" + +#define MAX_PREFERRED_PENETRATION_DIRECTIONS 10 + +/// The btConvexShape is an abstract shape interface, implemented by all convex shapes such as btBoxShape, btConvexHullShape etc. +/// It describes general convex shapes using the localGetSupportingVertex interface, used by collision detectors such as btGjkPairDetector. +ATTRIBUTE_ALIGNED16(class) +btConvexShape : public btCollisionShape +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btConvexShape(); + + virtual ~btConvexShape(); + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const = 0; + +//////// +#ifndef __SPU__ + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const = 0; +#endif //#ifndef __SPU__ + + btVector3 localGetSupportVertexWithoutMarginNonVirtual(const btVector3& vec) const; + btVector3 localGetSupportVertexNonVirtual(const btVector3& vec) const; + btScalar getMarginNonVirtual() const; + void getAabbNonVirtual(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void project(const btTransform& trans, const btVector3& dir, btScalar& minProj, btScalar& maxProj, btVector3& witnesPtMin, btVector3& witnesPtMax) const; + + //notice that the vectors should be unit length + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const = 0; + + ///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version + void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const = 0; + + virtual void getAabbSlow(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const = 0; + + virtual void setLocalScaling(const btVector3& scaling) = 0; + virtual const btVector3& getLocalScaling() const = 0; + + virtual void setMargin(btScalar margin) = 0; + + virtual btScalar getMargin() const = 0; + + virtual int getNumPreferredPenetrationDirections() const = 0; + + virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const = 0; +}; + +#endif //BT_CONVEX_SHAPE_INTERFACE1 diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.h.i new file mode 100644 index 00000000..5d13275f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btConvexShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btConvexShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp new file mode 100644 index 00000000..f6987cc7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp @@ -0,0 +1,283 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btConvexTriangleMeshShape.h" +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" + +#include "LinearMath/btQuaternion.h" +#include "BulletCollision/CollisionShapes/btStridingMeshInterface.h" + +btConvexTriangleMeshShape ::btConvexTriangleMeshShape(btStridingMeshInterface* meshInterface, bool calcAabb) + : btPolyhedralConvexAabbCachingShape(), m_stridingMesh(meshInterface) +{ + m_shapeType = CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE; + if (calcAabb) + recalcLocalAabb(); +} + +///It's not nice to have all this virtual function overhead, so perhaps we can also gather the points once +///but then we are duplicating +class LocalSupportVertexCallback : public btInternalTriangleIndexCallback +{ + btVector3 m_supportVertexLocal; + +public: + btScalar m_maxDot; + btVector3 m_supportVecLocal; + + LocalSupportVertexCallback(const btVector3& supportVecLocal) + : m_supportVertexLocal(btScalar(0.), btScalar(0.), btScalar(0.)), + m_maxDot(btScalar(-BT_LARGE_FLOAT)), + m_supportVecLocal(supportVecLocal) + { + } + + virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex) + { + (void)triangleIndex; + (void)partId; + + for (int i = 0; i < 3; i++) + { + btScalar dot = m_supportVecLocal.dot(triangle[i]); + if (dot > m_maxDot) + { + m_maxDot = dot; + m_supportVertexLocal = triangle[i]; + } + } + } + + btVector3 GetSupportVertexLocal() + { + return m_supportVertexLocal; + } +}; + +btVector3 btConvexTriangleMeshShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0) const +{ + btVector3 supVec(btScalar(0.), btScalar(0.), btScalar(0.)); + + btVector3 vec = vec0; + btScalar lenSqr = vec.length2(); + if (lenSqr < btScalar(0.0001)) + { + vec.setValue(1, 0, 0); + } + else + { + btScalar rlen = btScalar(1.) / btSqrt(lenSqr); + vec *= rlen; + } + + LocalSupportVertexCallback supportCallback(vec); + btVector3 aabbMax(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + m_stridingMesh->InternalProcessAllTriangles(&supportCallback, -aabbMax, aabbMax); + supVec = supportCallback.GetSupportVertexLocal(); + + return supVec; +} + +void btConvexTriangleMeshShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + //use 'w' component of supportVerticesOut? + { + for (int i = 0; i < numVectors; i++) + { + supportVerticesOut[i][3] = btScalar(-BT_LARGE_FLOAT); + } + } + + ///@todo: could do the batch inside the callback! + + for (int j = 0; j < numVectors; j++) + { + const btVector3& vec = vectors[j]; + LocalSupportVertexCallback supportCallback(vec); + btVector3 aabbMax(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + m_stridingMesh->InternalProcessAllTriangles(&supportCallback, -aabbMax, aabbMax); + supportVerticesOut[j] = supportCallback.GetSupportVertexLocal(); + } +} + +btVector3 btConvexTriangleMeshShape::localGetSupportingVertex(const btVector3& vec) const +{ + btVector3 supVertex = localGetSupportingVertexWithoutMargin(vec); + + if (getMargin() != btScalar(0.)) + { + btVector3 vecnorm = vec; + if (vecnorm.length2() < (SIMD_EPSILON * SIMD_EPSILON)) + { + vecnorm.setValue(btScalar(-1.), btScalar(-1.), btScalar(-1.)); + } + vecnorm.normalize(); + supVertex += getMargin() * vecnorm; + } + return supVertex; +} + +//currently just for debugging (drawing), perhaps future support for algebraic continuous collision detection +//Please note that you can debug-draw btConvexTriangleMeshShape with the Raytracer Demo +int btConvexTriangleMeshShape::getNumVertices() const +{ + //cache this? + return 0; +} + +int btConvexTriangleMeshShape::getNumEdges() const +{ + return 0; +} + +void btConvexTriangleMeshShape::getEdge(int, btVector3&, btVector3&) const +{ + btAssert(0); +} + +void btConvexTriangleMeshShape::getVertex(int, btVector3&) const +{ + btAssert(0); +} + +int btConvexTriangleMeshShape::getNumPlanes() const +{ + return 0; +} + +void btConvexTriangleMeshShape::getPlane(btVector3&, btVector3&, int) const +{ + btAssert(0); +} + +//not yet +bool btConvexTriangleMeshShape::isInside(const btVector3&, btScalar) const +{ + btAssert(0); + return false; +} + +void btConvexTriangleMeshShape::setLocalScaling(const btVector3& scaling) +{ + m_stridingMesh->setScaling(scaling); + + recalcLocalAabb(); +} + +const btVector3& btConvexTriangleMeshShape::getLocalScaling() const +{ + return m_stridingMesh->getScaling(); +} + +void btConvexTriangleMeshShape::calculatePrincipalAxisTransform(btTransform& principal, btVector3& inertia, btScalar& volume) const +{ + class CenterCallback : public btInternalTriangleIndexCallback + { + bool first; + btVector3 ref; + btVector3 sum; + btScalar volume; + + public: + CenterCallback() : first(true), ref(0, 0, 0), sum(0, 0, 0), volume(0) + { + } + + virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex) + { + (void)triangleIndex; + (void)partId; + if (first) + { + ref = triangle[0]; + first = false; + } + else + { + btScalar vol = btFabs((triangle[0] - ref).triple(triangle[1] - ref, triangle[2] - ref)); + sum += (btScalar(0.25) * vol) * ((triangle[0] + triangle[1] + triangle[2] + ref)); + volume += vol; + } + } + + btVector3 getCenter() + { + return (volume > 0) ? sum / volume : ref; + } + + btScalar getVolume() + { + return volume * btScalar(1. / 6); + } + }; + + class InertiaCallback : public btInternalTriangleIndexCallback + { + btMatrix3x3 sum; + btVector3 center; + + public: + InertiaCallback(btVector3& center) : sum(0, 0, 0, 0, 0, 0, 0, 0, 0), center(center) + { + } + + virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex) + { + (void)triangleIndex; + (void)partId; + btMatrix3x3 i; + btVector3 a = triangle[0] - center; + btVector3 b = triangle[1] - center; + btVector3 c = triangle[2] - center; + btScalar volNeg = -btFabs(a.triple(b, c)) * btScalar(1. / 6); + for (int j = 0; j < 3; j++) + { + for (int k = 0; k <= j; k++) + { + i[j][k] = i[k][j] = volNeg * (btScalar(0.1) * (a[j] * a[k] + b[j] * b[k] + c[j] * c[k]) + btScalar(0.05) * (a[j] * b[k] + a[k] * b[j] + a[j] * c[k] + a[k] * c[j] + b[j] * c[k] + b[k] * c[j])); + } + } + btScalar i00 = -i[0][0]; + btScalar i11 = -i[1][1]; + btScalar i22 = -i[2][2]; + i[0][0] = i11 + i22; + i[1][1] = i22 + i00; + i[2][2] = i00 + i11; + sum[0] += i[0]; + sum[1] += i[1]; + sum[2] += i[2]; + } + + btMatrix3x3& getInertia() + { + return sum; + } + }; + + CenterCallback centerCallback; + btVector3 aabbMax(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + m_stridingMesh->InternalProcessAllTriangles(¢erCallback, -aabbMax, aabbMax); + btVector3 center = centerCallback.getCenter(); + principal.setOrigin(center); + volume = centerCallback.getVolume(); + + InertiaCallback inertiaCallback(center); + m_stridingMesh->InternalProcessAllTriangles(&inertiaCallback, -aabbMax, aabbMax); + + btMatrix3x3& i = inertiaCallback.getInertia(); + i.diagonalize(principal.getBasis(), btScalar(0.00001), 20); + inertia.setValue(i[0][0], i[1][1], i[2][2]); + inertia /= volume; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp.i new file mode 100644 index 00000000..947afa82 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h new file mode 100644 index 00000000..6dac9fff --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h @@ -0,0 +1,68 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +#ifndef BT_CONVEX_TRIANGLEMESH_SHAPE_H +#define BT_CONVEX_TRIANGLEMESH_SHAPE_H + +#include "btPolyhedralConvexShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +/// The btConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good as btConvexHullShape. +/// A small benefit of this class is that it uses the btStridingMeshInterface, so you can avoid the duplication of the triangle mesh data. Nevertheless, most users should use the much better performing btConvexHullShape instead. +ATTRIBUTE_ALIGNED16(class) +btConvexTriangleMeshShape : public btPolyhedralConvexAabbCachingShape +{ + class btStridingMeshInterface* m_stridingMesh; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btConvexTriangleMeshShape(btStridingMeshInterface * meshInterface, bool calcAabb = true); + + class btStridingMeshInterface* getMeshInterface() + { + return m_stridingMesh; + } + const class btStridingMeshInterface* getMeshInterface() const + { + return m_stridingMesh; + } + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const; + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + //debugging + virtual const char* getName() const { return "ConvexTrimesh"; } + + virtual int getNumVertices() const; + virtual int getNumEdges() const; + virtual void getEdge(int i, btVector3& pa, btVector3& pb) const; + virtual void getVertex(int i, btVector3& vtx) const; + virtual int getNumPlanes() const; + virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const; + virtual bool isInside(const btVector3& pt, btScalar tolerance) const; + + virtual void setLocalScaling(const btVector3& scaling); + virtual const btVector3& getLocalScaling() const; + + ///computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia + ///and the center of mass to the current coordinate system. A mass of 1 is assumed, for other masses just multiply the computed "inertia" + ///by the mass. The resulting transform "principal" has to be applied inversely to the mesh in order for the local coordinate system of the + ///shape to be centered at the center of mass and to coincide with the principal axes. This also necessitates a correction of the world transform + ///of the collision object by the principal transform. This method also computes the volume of the convex mesh. + void calculatePrincipalAxisTransform(btTransform & principal, btVector3 & inertia, btScalar & volume) const; +}; + +#endif //BT_CONVEX_TRIANGLEMESH_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h.i new file mode 100644 index 00000000..f300d70f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.cpp new file mode 100644 index 00000000..66dbb8e5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.cpp @@ -0,0 +1,253 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btCylinderShape.h" + +btCylinderShape::btCylinderShape(const btVector3& halfExtents) + : btConvexInternalShape(), + m_upAxis(1) +{ + btVector3 margin(getMargin(), getMargin(), getMargin()); + m_implicitShapeDimensions = (halfExtents * m_localScaling) - margin; + + setSafeMargin(halfExtents); + + m_shapeType = CYLINDER_SHAPE_PROXYTYPE; +} + +btCylinderShapeX::btCylinderShapeX(const btVector3& halfExtents) + : btCylinderShape(halfExtents) +{ + m_upAxis = 0; +} + +btCylinderShapeZ::btCylinderShapeZ(const btVector3& halfExtents) + : btCylinderShape(halfExtents) +{ + m_upAxis = 2; +} + +void btCylinderShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + btTransformAabb(getHalfExtentsWithoutMargin(), getMargin(), t, aabbMin, aabbMax); +} + +void btCylinderShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ +//Until Bullet 2.77 a box approximation was used, so uncomment this if you need backwards compatibility +//#define USE_BOX_INERTIA_APPROXIMATION 1 +#ifndef USE_BOX_INERTIA_APPROXIMATION + + /* + cylinder is defined as following: + * + * - principle axis aligned along y by default, radius in x, z-value not used + * - for btCylinderShapeX: principle axis aligned along x, radius in y direction, z-value not used + * - for btCylinderShapeZ: principle axis aligned along z, radius in x direction, y-value not used + * + */ + + btScalar radius2; // square of cylinder radius + btScalar height2; // square of cylinder height + btVector3 halfExtents = getHalfExtentsWithMargin(); // get cylinder dimension + btScalar div12 = mass / 12.f; + btScalar div4 = mass / 4.f; + btScalar div2 = mass / 2.f; + int idxRadius, idxHeight; + + switch (m_upAxis) // get indices of radius and height of cylinder + { + case 0: // cylinder is aligned along x + idxRadius = 1; + idxHeight = 0; + break; + case 2: // cylinder is aligned along z + idxRadius = 0; + idxHeight = 2; + break; + default: // cylinder is aligned along y + idxRadius = 0; + idxHeight = 1; + } + + // calculate squares + radius2 = halfExtents[idxRadius] * halfExtents[idxRadius]; + height2 = btScalar(4.) * halfExtents[idxHeight] * halfExtents[idxHeight]; + + // calculate tensor terms + btScalar t1 = div12 * height2 + div4 * radius2; + btScalar t2 = div2 * radius2; + + switch (m_upAxis) // set diagonal elements of inertia tensor + { + case 0: // cylinder is aligned along x + inertia.setValue(t2, t1, t1); + break; + case 2: // cylinder is aligned along z + inertia.setValue(t1, t1, t2); + break; + default: // cylinder is aligned along y + inertia.setValue(t1, t2, t1); + } +#else //USE_BOX_INERTIA_APPROXIMATION + //approximation of box shape + btVector3 halfExtents = getHalfExtentsWithMargin(); + + btScalar lx = btScalar(2.) * (halfExtents.x()); + btScalar ly = btScalar(2.) * (halfExtents.y()); + btScalar lz = btScalar(2.) * (halfExtents.z()); + + inertia.setValue(mass / (btScalar(12.0)) * (ly * ly + lz * lz), + mass / (btScalar(12.0)) * (lx * lx + lz * lz), + mass / (btScalar(12.0)) * (lx * lx + ly * ly)); +#endif //USE_BOX_INERTIA_APPROXIMATION +} + +SIMD_FORCE_INLINE btVector3 CylinderLocalSupportX(const btVector3& halfExtents, const btVector3& v) +{ + const int cylinderUpAxis = 0; + const int XX = 1; + const int YY = 0; + const int ZZ = 2; + + //mapping depends on how cylinder local orientation is + // extents of the cylinder is: X,Y is for radius, and Z for height + + btScalar radius = halfExtents[XX]; + btScalar halfHeight = halfExtents[cylinderUpAxis]; + + btVector3 tmp; + btScalar d; + + btScalar s = btSqrt(v[XX] * v[XX] + v[ZZ] * v[ZZ]); + if (s != btScalar(0.0)) + { + d = radius / s; + tmp[XX] = v[XX] * d; + tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight; + tmp[ZZ] = v[ZZ] * d; + return tmp; + } + else + { + tmp[XX] = radius; + tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight; + tmp[ZZ] = btScalar(0.0); + return tmp; + } +} + +inline btVector3 CylinderLocalSupportY(const btVector3& halfExtents, const btVector3& v) +{ + const int cylinderUpAxis = 1; + const int XX = 0; + const int YY = 1; + const int ZZ = 2; + + btScalar radius = halfExtents[XX]; + btScalar halfHeight = halfExtents[cylinderUpAxis]; + + btVector3 tmp; + btScalar d; + + btScalar s = btSqrt(v[XX] * v[XX] + v[ZZ] * v[ZZ]); + if (s != btScalar(0.0)) + { + d = radius / s; + tmp[XX] = v[XX] * d; + tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight; + tmp[ZZ] = v[ZZ] * d; + return tmp; + } + else + { + tmp[XX] = radius; + tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight; + tmp[ZZ] = btScalar(0.0); + return tmp; + } +} + +inline btVector3 CylinderLocalSupportZ(const btVector3& halfExtents, const btVector3& v) +{ + const int cylinderUpAxis = 2; + const int XX = 0; + const int YY = 2; + const int ZZ = 1; + + //mapping depends on how cylinder local orientation is + // extents of the cylinder is: X,Y is for radius, and Z for height + + btScalar radius = halfExtents[XX]; + btScalar halfHeight = halfExtents[cylinderUpAxis]; + + btVector3 tmp; + btScalar d; + + btScalar s = btSqrt(v[XX] * v[XX] + v[ZZ] * v[ZZ]); + if (s != btScalar(0.0)) + { + d = radius / s; + tmp[XX] = v[XX] * d; + tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight; + tmp[ZZ] = v[ZZ] * d; + return tmp; + } + else + { + tmp[XX] = radius; + tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight; + tmp[ZZ] = btScalar(0.0); + return tmp; + } +} + +btVector3 btCylinderShapeX::localGetSupportingVertexWithoutMargin(const btVector3& vec) const +{ + return CylinderLocalSupportX(getHalfExtentsWithoutMargin(), vec); +} + +btVector3 btCylinderShapeZ::localGetSupportingVertexWithoutMargin(const btVector3& vec) const +{ + return CylinderLocalSupportZ(getHalfExtentsWithoutMargin(), vec); +} +btVector3 btCylinderShape::localGetSupportingVertexWithoutMargin(const btVector3& vec) const +{ + return CylinderLocalSupportY(getHalfExtentsWithoutMargin(), vec); +} + +void btCylinderShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + for (int i = 0; i < numVectors; i++) + { + supportVerticesOut[i] = CylinderLocalSupportY(getHalfExtentsWithoutMargin(), vectors[i]); + } +} + +void btCylinderShapeZ::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + for (int i = 0; i < numVectors; i++) + { + supportVerticesOut[i] = CylinderLocalSupportZ(getHalfExtentsWithoutMargin(), vectors[i]); + } +} + +void btCylinderShapeX::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + for (int i = 0; i < numVectors; i++) + { + supportVerticesOut[i] = CylinderLocalSupportX(getHalfExtentsWithoutMargin(), vectors[i]); + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.cpp.i new file mode 100644 index 00000000..c7633930 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btCylinderShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btCylinderShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btCylinderShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.h new file mode 100644 index 00000000..d3f64508 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.h @@ -0,0 +1,206 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CYLINDER_MINKOWSKI_H +#define BT_CYLINDER_MINKOWSKI_H + +#include "btBoxShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +#include "LinearMath/btVector3.h" + +/// The btCylinderShape class implements a cylinder shape primitive, centered around the origin. Its central axis aligned with the Y axis. btCylinderShapeX is aligned with the X axis and btCylinderShapeZ around the Z axis. +ATTRIBUTE_ALIGNED16(class) +btCylinderShape : public btConvexInternalShape + +{ +protected: + int m_upAxis; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btVector3 getHalfExtentsWithMargin() const + { + btVector3 halfExtents = getHalfExtentsWithoutMargin(); + btVector3 margin(getMargin(), getMargin(), getMargin()); + halfExtents += margin; + return halfExtents; + } + + const btVector3& getHalfExtentsWithoutMargin() const + { + return m_implicitShapeDimensions; //changed in Bullet 2.63: assume the scaling and margin are included + } + + btCylinderShape(const btVector3& halfExtents); + + void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + virtual void setMargin(btScalar collisionMargin) + { + //correct the m_implicitShapeDimensions for the margin + btVector3 oldMargin(getMargin(), getMargin(), getMargin()); + btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin; + + btConvexInternalShape::setMargin(collisionMargin); + btVector3 newMargin(getMargin(), getMargin(), getMargin()); + m_implicitShapeDimensions = implicitShapeDimensionsWithMargin - newMargin; + } + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const + { + btVector3 supVertex; + supVertex = localGetSupportingVertexWithoutMargin(vec); + + if (getMargin() != btScalar(0.)) + { + btVector3 vecnorm = vec; + if (vecnorm.length2() < (SIMD_EPSILON * SIMD_EPSILON)) + { + vecnorm.setValue(btScalar(-1.), btScalar(-1.), btScalar(-1.)); + } + vecnorm.normalize(); + supVertex += getMargin() * vecnorm; + } + return supVertex; + } + + //use box inertia + // virtual void calculateLocalInertia(btScalar mass,btVector3& inertia) const; + + int getUpAxis() const + { + return m_upAxis; + } + + virtual btVector3 getAnisotropicRollingFrictionDirection() const + { + btVector3 aniDir(0, 0, 0); + aniDir[getUpAxis()] = 1; + return aniDir; + } + + virtual btScalar getRadius() const + { + return getHalfExtentsWithMargin().getX(); + } + + virtual void setLocalScaling(const btVector3& scaling) + { + btVector3 oldMargin(getMargin(), getMargin(), getMargin()); + btVector3 implicitShapeDimensionsWithMargin = m_implicitShapeDimensions + oldMargin; + btVector3 unScaledImplicitShapeDimensionsWithMargin = implicitShapeDimensionsWithMargin / m_localScaling; + + btConvexInternalShape::setLocalScaling(scaling); + + m_implicitShapeDimensions = (unScaledImplicitShapeDimensionsWithMargin * m_localScaling) - oldMargin; + } + + //debugging + virtual const char* getName() const + { + return "CylinderY"; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +class btCylinderShapeX : public btCylinderShape +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btCylinderShapeX(const btVector3& halfExtents); + + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + //debugging + virtual const char* getName() const + { + return "CylinderX"; + } + + virtual btScalar getRadius() const + { + return getHalfExtentsWithMargin().getY(); + } +}; + +class btCylinderShapeZ : public btCylinderShape +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btCylinderShapeZ(const btVector3& halfExtents); + + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + //debugging + virtual const char* getName() const + { + return "CylinderZ"; + } + + virtual btScalar getRadius() const + { + return getHalfExtentsWithMargin().getX(); + } +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btCylinderShapeData +{ + btConvexInternalShapeData m_convexInternalShapeData; + + int m_upAxis; + + char m_padding[4]; +}; + +SIMD_FORCE_INLINE int btCylinderShape::calculateSerializeBufferSize() const +{ + return sizeof(btCylinderShapeData); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btCylinderShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btCylinderShapeData* shapeData = (btCylinderShapeData*)dataBuffer; + + btConvexInternalShape::serialize(&shapeData->m_convexInternalShapeData, serializer); + + shapeData->m_upAxis = m_upAxis; + + // Fill padding with zeros to appease msan. + shapeData->m_padding[0] = 0; + shapeData->m_padding[1] = 0; + shapeData->m_padding[2] = 0; + shapeData->m_padding[3] = 0; + + return "btCylinderShapeData"; +} + +#endif //BT_CYLINDER_MINKOWSKI_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.h.i new file mode 100644 index 00000000..5ec678f3 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btCylinderShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btCylinderShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btCylinderShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btCylinderShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.cpp new file mode 100644 index 00000000..4699555b --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.cpp @@ -0,0 +1,42 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btEmptyShape.h" + +#include "btCollisionShape.h" + +btEmptyShape::btEmptyShape() : btConcaveShape() +{ + m_shapeType = EMPTY_SHAPE_PROXYTYPE; +} + +btEmptyShape::~btEmptyShape() +{ +} + +///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version +void btEmptyShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + btVector3 margin(getMargin(), getMargin(), getMargin()); + + aabbMin = t.getOrigin() - margin; + + aabbMax = t.getOrigin() + margin; +} + +void btEmptyShape::calculateLocalInertia(btScalar, btVector3&) const +{ + btAssert(0); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.cpp.i new file mode 100644 index 00000000..27ef2b72 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btEmptyShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btEmptyShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btEmptyShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.h new file mode 100644 index 00000000..d2e21173 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.h @@ -0,0 +1,65 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_EMPTY_SHAPE_H +#define BT_EMPTY_SHAPE_H + +#include "btConcaveShape.h" + +#include "LinearMath/btVector3.h" +#include "LinearMath/btTransform.h" +#include "LinearMath/btMatrix3x3.h" +#include "btCollisionMargin.h" + +/// The btEmptyShape is a collision shape without actual collision detection shape, so most users should ignore this class. +/// It can be replaced by another shape during runtime, but the inertia tensor should be recomputed. +ATTRIBUTE_ALIGNED16(class) +btEmptyShape : public btConcaveShape +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btEmptyShape(); + + virtual ~btEmptyShape(); + + ///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version + void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void setLocalScaling(const btVector3& scaling) + { + m_localScaling = scaling; + } + virtual const btVector3& getLocalScaling() const + { + return m_localScaling; + } + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + virtual const char* getName() const + { + return "Empty"; + } + + virtual void processAllTriangles(btTriangleCallback*, const btVector3&, const btVector3&) const + { + } + +protected: + btVector3 m_localScaling; +}; + +#endif //BT_EMPTY_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.h.i new file mode 100644 index 00000000..f81a928f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btEmptyShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btEmptyShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btEmptyShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btEmptyShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp new file mode 100644 index 00000000..5b1c23d6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp @@ -0,0 +1,951 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btHeightfieldTerrainShape.h" + +#include "LinearMath/btTransformUtil.h" + +btHeightfieldTerrainShape::btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + const float* heightfieldData, btScalar minHeight, btScalar maxHeight, + int upAxis, bool flipQuadEdges) + : m_userValue3(0), m_triangleInfoMap(0) +{ + initialize(heightStickWidth, heightStickLength, heightfieldData, + /*heightScale=*/1, minHeight, maxHeight, upAxis, PHY_FLOAT, + flipQuadEdges); +} + +btHeightfieldTerrainShape::btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, const double* heightfieldData, + btScalar minHeight, btScalar maxHeight, int upAxis, bool flipQuadEdges) + : m_userValue3(0), m_triangleInfoMap(0) +{ + initialize(heightStickWidth, heightStickLength, heightfieldData, + /*heightScale=*/1, minHeight, maxHeight, upAxis, PHY_DOUBLE, + flipQuadEdges); +} + +btHeightfieldTerrainShape::btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, const short* heightfieldData, btScalar heightScale, + btScalar minHeight, btScalar maxHeight, int upAxis, bool flipQuadEdges) + : m_userValue3(0), m_triangleInfoMap(0) +{ + initialize(heightStickWidth, heightStickLength, heightfieldData, + heightScale, minHeight, maxHeight, upAxis, PHY_SHORT, + flipQuadEdges); +} + +btHeightfieldTerrainShape::btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, const unsigned char* heightfieldData, btScalar heightScale, + btScalar minHeight, btScalar maxHeight, int upAxis, bool flipQuadEdges) + : m_userValue3(0), m_triangleInfoMap(0) +{ + initialize(heightStickWidth, heightStickLength, heightfieldData, + heightScale, minHeight, maxHeight, upAxis, PHY_UCHAR, + flipQuadEdges); +} + +btHeightfieldTerrainShape::btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, const void* heightfieldData, + btScalar heightScale, btScalar minHeight, btScalar maxHeight, int upAxis, + PHY_ScalarType hdt, bool flipQuadEdges) + :m_userValue3(0), + m_triangleInfoMap(0) +{ + // legacy constructor: Assumes PHY_FLOAT means btScalar. +#ifdef BT_USE_DOUBLE_PRECISION + if (hdt == PHY_FLOAT) hdt = PHY_DOUBLE; +#endif + initialize(heightStickWidth, heightStickLength, heightfieldData, + heightScale, minHeight, maxHeight, upAxis, hdt, + flipQuadEdges); +} + +btHeightfieldTerrainShape::btHeightfieldTerrainShape(int heightStickWidth, int heightStickLength, const void* heightfieldData, btScalar maxHeight, int upAxis, bool useFloatData, bool flipQuadEdges) + : m_userValue3(0), + m_triangleInfoMap(0) +{ + // legacy constructor: support only btScalar or unsigned char data, + // and min height is zero. + PHY_ScalarType hdt = (useFloatData) ? PHY_FLOAT : PHY_UCHAR; +#ifdef BT_USE_DOUBLE_PRECISION + if (hdt == PHY_FLOAT) hdt = PHY_DOUBLE; +#endif + btScalar minHeight = 0.0f; + + // previously, height = uchar * maxHeight / 65535. + // So to preserve legacy behavior, heightScale = maxHeight / 65535 + btScalar heightScale = maxHeight / 65535; + + initialize(heightStickWidth, heightStickLength, heightfieldData, + heightScale, minHeight, maxHeight, upAxis, hdt, + flipQuadEdges); +} + +void btHeightfieldTerrainShape::initialize( + int heightStickWidth, int heightStickLength, const void* heightfieldData, + btScalar heightScale, btScalar minHeight, btScalar maxHeight, int upAxis, + PHY_ScalarType hdt, bool flipQuadEdges) +{ + // validation + btAssert(heightStickWidth > 1); // && "bad width"); + btAssert(heightStickLength > 1); // && "bad length"); + btAssert(heightfieldData); // && "null heightfield data"); + // btAssert(heightScale) -- do we care? Trust caller here + btAssert(minHeight <= maxHeight); // && "bad min/max height"); + btAssert(upAxis >= 0 && upAxis < 3); // && "bad upAxis--should be in range [0,2]"); + btAssert(hdt != PHY_UCHAR || hdt != PHY_FLOAT || hdt != PHY_DOUBLE || hdt != PHY_SHORT); // && "Bad height data type enum"); + + // initialize member variables + m_shapeType = TERRAIN_SHAPE_PROXYTYPE; + m_heightStickWidth = heightStickWidth; + m_heightStickLength = heightStickLength; + m_minHeight = minHeight; + m_maxHeight = maxHeight; + m_width = (btScalar)(heightStickWidth - 1); + m_length = (btScalar)(heightStickLength - 1); + m_heightScale = heightScale; + m_heightfieldDataUnknown = heightfieldData; + m_heightDataType = hdt; + m_flipQuadEdges = flipQuadEdges; + m_useDiamondSubdivision = false; + m_useZigzagSubdivision = false; + m_flipTriangleWinding = false; + m_upAxis = upAxis; + m_localScaling.setValue(btScalar(1.), btScalar(1.), btScalar(1.)); + + m_vboundsChunkSize = 0; + m_vboundsGridWidth = 0; + m_vboundsGridLength = 0; + + // determine min/max axis-aligned bounding box (aabb) values + switch (m_upAxis) + { + case 0: + { + m_localAabbMin.setValue(m_minHeight, 0, 0); + m_localAabbMax.setValue(m_maxHeight, m_width, m_length); + break; + } + case 1: + { + m_localAabbMin.setValue(0, m_minHeight, 0); + m_localAabbMax.setValue(m_width, m_maxHeight, m_length); + break; + }; + case 2: + { + m_localAabbMin.setValue(0, 0, m_minHeight); + m_localAabbMax.setValue(m_width, m_length, m_maxHeight); + break; + } + default: + { + //need to get valid m_upAxis + btAssert(0); // && "Bad m_upAxis"); + } + } + + // remember origin (defined as exact middle of aabb) + m_localOrigin = btScalar(0.5) * (m_localAabbMin + m_localAabbMax); +} + +btHeightfieldTerrainShape::~btHeightfieldTerrainShape() +{ + clearAccelerator(); +} + +void btHeightfieldTerrainShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + btVector3 halfExtents = (m_localAabbMax - m_localAabbMin) * m_localScaling * btScalar(0.5); + + btVector3 localOrigin(0, 0, 0); + localOrigin[m_upAxis] = (m_minHeight + m_maxHeight) * btScalar(0.5); + localOrigin *= m_localScaling; + + btMatrix3x3 abs_b = t.getBasis().absolute(); + btVector3 center = t.getOrigin(); + btVector3 extent = halfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]); + extent += btVector3(getMargin(), getMargin(), getMargin()); + + aabbMin = center - extent; + aabbMax = center + extent; +} + +/// This returns the "raw" (user's initial) height, not the actual height. +/// The actual height needs to be adjusted to be relative to the center +/// of the heightfield's AABB. +btScalar +btHeightfieldTerrainShape::getRawHeightFieldValue(int x, int y) const +{ + btScalar val = 0.f; + switch (m_heightDataType) + { + case PHY_FLOAT: + { + val = m_heightfieldDataFloat[(y * m_heightStickWidth) + x]; + break; + } + + case PHY_DOUBLE: + { + val = m_heightfieldDataDouble[(y * m_heightStickWidth) + x]; + break; + } + + case PHY_UCHAR: + { + unsigned char heightFieldValue = m_heightfieldDataUnsignedChar[(y * m_heightStickWidth) + x]; + val = heightFieldValue * m_heightScale; + break; + } + + case PHY_SHORT: + { + short hfValue = m_heightfieldDataShort[(y * m_heightStickWidth) + x]; + val = hfValue * m_heightScale; + break; + } + + default: + { + btAssert(!"Bad m_heightDataType"); + } + } + + return val; +} + +/// this returns the vertex in bullet-local coordinates +void btHeightfieldTerrainShape::getVertex(int x, int y, btVector3& vertex) const +{ + btAssert(x >= 0); + btAssert(y >= 0); + btAssert(x < m_heightStickWidth); + btAssert(y < m_heightStickLength); + + btScalar height = getRawHeightFieldValue(x, y); + + switch (m_upAxis) + { + case 0: + { + vertex.setValue( + height - m_localOrigin.getX(), + (-m_width / btScalar(2.0)) + x, + (-m_length / btScalar(2.0)) + y); + break; + } + case 1: + { + vertex.setValue( + (-m_width / btScalar(2.0)) + x, + height - m_localOrigin.getY(), + (-m_length / btScalar(2.0)) + y); + break; + }; + case 2: + { + vertex.setValue( + (-m_width / btScalar(2.0)) + x, + (-m_length / btScalar(2.0)) + y, + height - m_localOrigin.getZ()); + break; + } + default: + { + //need to get valid m_upAxis + btAssert(0); + } + } + + vertex *= m_localScaling; +} + +static inline int +getQuantized( + btScalar x) +{ + if (x < 0.0) + { + return (int)(x - 0.5); + } + return (int)(x + 0.5); +} + +// Equivalent to std::minmax({a, b, c}). +// Performs at most 3 comparisons. +static btHeightfieldTerrainShape::Range minmaxRange(btScalar a, btScalar b, btScalar c) +{ + if (a > b) + { + if (b > c) + return btHeightfieldTerrainShape::Range(c, a); + else if (a > c) + return btHeightfieldTerrainShape::Range(b, a); + else + return btHeightfieldTerrainShape::Range(b, c); + } + else + { + if (a > c) + return btHeightfieldTerrainShape::Range(c, b); + else if (b > c) + return btHeightfieldTerrainShape::Range(a, b); + else + return btHeightfieldTerrainShape::Range(a, c); + } +} + +/// given input vector, return quantized version +/** + This routine is basically determining the gridpoint indices for a given + input vector, answering the question: "which gridpoint is closest to the + provided point?". + + "with clamp" means that we restrict the point to be in the heightfield's + axis-aligned bounding box. + */ +void btHeightfieldTerrainShape::quantizeWithClamp(int* out, const btVector3& point, int /*isMax*/) const +{ + btVector3 clampedPoint(point); + clampedPoint.setMax(m_localAabbMin); + clampedPoint.setMin(m_localAabbMax); + + out[0] = getQuantized(clampedPoint.getX()); + out[1] = getQuantized(clampedPoint.getY()); + out[2] = getQuantized(clampedPoint.getZ()); +} + +/// process all triangles within the provided axis-aligned bounding box +/** + basic algorithm: + - convert input aabb to local coordinates (scale down and shift for local origin) + - convert input aabb to a range of heightfield grid points (quantize) + - iterate over all triangles in that subset of the grid + */ +void btHeightfieldTerrainShape::processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const +{ + // scale down the input aabb's so they are in local (non-scaled) coordinates + btVector3 localAabbMin = aabbMin * btVector3(1.f / m_localScaling[0], 1.f / m_localScaling[1], 1.f / m_localScaling[2]); + btVector3 localAabbMax = aabbMax * btVector3(1.f / m_localScaling[0], 1.f / m_localScaling[1], 1.f / m_localScaling[2]); + + // account for local origin + localAabbMin += m_localOrigin; + localAabbMax += m_localOrigin; + + //quantize the aabbMin and aabbMax, and adjust the start/end ranges + int quantizedAabbMin[3]; + int quantizedAabbMax[3]; + quantizeWithClamp(quantizedAabbMin, localAabbMin, 0); + quantizeWithClamp(quantizedAabbMax, localAabbMax, 1); + + // expand the min/max quantized values + // this is to catch the case where the input aabb falls between grid points! + for (int i = 0; i < 3; ++i) + { + quantizedAabbMin[i]--; + quantizedAabbMax[i]++; + } + + int startX = 0; + int endX = m_heightStickWidth - 1; + int startJ = 0; + int endJ = m_heightStickLength - 1; + + switch (m_upAxis) + { + case 0: + { + if (quantizedAabbMin[1] > startX) + startX = quantizedAabbMin[1]; + if (quantizedAabbMax[1] < endX) + endX = quantizedAabbMax[1]; + if (quantizedAabbMin[2] > startJ) + startJ = quantizedAabbMin[2]; + if (quantizedAabbMax[2] < endJ) + endJ = quantizedAabbMax[2]; + break; + } + case 1: + { + if (quantizedAabbMin[0] > startX) + startX = quantizedAabbMin[0]; + if (quantizedAabbMax[0] < endX) + endX = quantizedAabbMax[0]; + if (quantizedAabbMin[2] > startJ) + startJ = quantizedAabbMin[2]; + if (quantizedAabbMax[2] < endJ) + endJ = quantizedAabbMax[2]; + break; + }; + case 2: + { + if (quantizedAabbMin[0] > startX) + startX = quantizedAabbMin[0]; + if (quantizedAabbMax[0] < endX) + endX = quantizedAabbMax[0]; + if (quantizedAabbMin[1] > startJ) + startJ = quantizedAabbMin[1]; + if (quantizedAabbMax[1] < endJ) + endJ = quantizedAabbMax[1]; + break; + } + default: + { + //need to get valid m_upAxis + btAssert(0); + } + } + + // TODO If m_vboundsGrid is available, use it to determine if we really need to process this area + + const Range aabbUpRange(aabbMin[m_upAxis], aabbMax[m_upAxis]); + for (int j = startJ; j < endJ; j++) + { + for (int x = startX; x < endX; x++) + { + btVector3 vertices[3]; + int indices[3] = { 0, 1, 2 }; + if (m_flipTriangleWinding) + { + indices[0] = 2; + indices[2] = 0; + } + + if (m_flipQuadEdges || (m_useDiamondSubdivision && !((j + x) & 1)) || (m_useZigzagSubdivision && !(j & 1))) + { + getVertex(x, j, vertices[indices[0]]); + getVertex(x, j + 1, vertices[indices[1]]); + getVertex(x + 1, j + 1, vertices[indices[2]]); + + // Skip triangle processing if the triangle is out-of-AABB. + Range upRange = minmaxRange(vertices[0][m_upAxis], vertices[1][m_upAxis], vertices[2][m_upAxis]); + + if (upRange.overlaps(aabbUpRange)) + callback->processTriangle(vertices, 2 * x, j); + + // already set: getVertex(x, j, vertices[indices[0]]) + + // equivalent to: getVertex(x + 1, j + 1, vertices[indices[1]]); + vertices[indices[1]] = vertices[indices[2]]; + + getVertex(x + 1, j, vertices[indices[2]]); + upRange.min = btMin(upRange.min, vertices[indices[2]][m_upAxis]); + upRange.max = btMax(upRange.max, vertices[indices[2]][m_upAxis]); + + if (upRange.overlaps(aabbUpRange)) + callback->processTriangle(vertices, 2 * x + 1, j); + } + else + { + getVertex(x, j, vertices[indices[0]]); + getVertex(x, j + 1, vertices[indices[1]]); + getVertex(x + 1, j, vertices[indices[2]]); + + // Skip triangle processing if the triangle is out-of-AABB. + Range upRange = minmaxRange(vertices[0][m_upAxis], vertices[1][m_upAxis], vertices[2][m_upAxis]); + + if (upRange.overlaps(aabbUpRange)) + callback->processTriangle(vertices, 2 * x, j); + + // already set: getVertex(x, j + 1, vertices[indices[1]]); + + // equivalent to: getVertex(x + 1, j, vertices[indices[0]]); + vertices[indices[0]] = vertices[indices[2]]; + + getVertex(x + 1, j + 1, vertices[indices[2]]); + upRange.min = btMin(upRange.min, vertices[indices[2]][m_upAxis]); + upRange.max = btMax(upRange.max, vertices[indices[2]][m_upAxis]); + + if (upRange.overlaps(aabbUpRange)) + callback->processTriangle(vertices, 2 * x + 1, j); + } + } + } +} + +void btHeightfieldTerrainShape::calculateLocalInertia(btScalar, btVector3& inertia) const +{ + //moving concave objects not supported + + inertia.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); +} + +void btHeightfieldTerrainShape::setLocalScaling(const btVector3& scaling) +{ + m_localScaling = scaling; +} +const btVector3& btHeightfieldTerrainShape::getLocalScaling() const +{ + return m_localScaling; +} + +namespace +{ + struct GridRaycastState + { + int x; // Next quad coords + int z; + int prev_x; // Previous quad coords + int prev_z; + btScalar param; // Exit param for previous quad + btScalar prevParam; // Enter param for previous quad + btScalar maxDistanceFlat; + btScalar maxDistance3d; + }; +} + +// TODO Does it really need to take 3D vectors? +/// Iterates through a virtual 2D grid of unit-sized square cells, +/// and executes an action on each cell intersecting the given segment, ordered from begin to end. +/// Initially inspired by http://www.cse.yorku.ca/~amana/research/grid.pdf +template +void gridRaycast(Action_T& quadAction, const btVector3& beginPos, const btVector3& endPos, int indices[3]) +{ + GridRaycastState rs; + rs.maxDistance3d = beginPos.distance(endPos); + if (rs.maxDistance3d < 0.0001) + { + // Consider the ray is too small to hit anything + return; + } + + + btScalar rayDirectionFlatX = endPos[indices[0]] - beginPos[indices[0]]; + btScalar rayDirectionFlatZ = endPos[indices[2]] - beginPos[indices[2]]; + rs.maxDistanceFlat = btSqrt(rayDirectionFlatX * rayDirectionFlatX + rayDirectionFlatZ * rayDirectionFlatZ); + + if (rs.maxDistanceFlat < 0.0001) + { + // Consider the ray vertical + rayDirectionFlatX = 0; + rayDirectionFlatZ = 0; + } + else + { + rayDirectionFlatX /= rs.maxDistanceFlat; + rayDirectionFlatZ /= rs.maxDistanceFlat; + } + + const int xiStep = rayDirectionFlatX > 0 ? 1 : rayDirectionFlatX < 0 ? -1 : 0; + const int ziStep = rayDirectionFlatZ > 0 ? 1 : rayDirectionFlatZ < 0 ? -1 : 0; + + const float infinite = 9999999; + const btScalar paramDeltaX = xiStep != 0 ? 1.f / btFabs(rayDirectionFlatX) : infinite; + const btScalar paramDeltaZ = ziStep != 0 ? 1.f / btFabs(rayDirectionFlatZ) : infinite; + + // pos = param * dir + btScalar paramCrossX; // At which value of `param` we will cross a x-axis lane? + btScalar paramCrossZ; // At which value of `param` we will cross a z-axis lane? + + // paramCrossX and paramCrossZ are initialized as being the first cross + // X initialization + if (xiStep != 0) + { + if (xiStep == 1) + { + paramCrossX = (ceil(beginPos[indices[0]]) - beginPos[indices[0]]) * paramDeltaX; + } + else + { + paramCrossX = (beginPos[indices[0]] - floor(beginPos[indices[0]])) * paramDeltaX; + } + } + else + { + paramCrossX = infinite; // Will never cross on X + } + + // Z initialization + if (ziStep != 0) + { + if (ziStep == 1) + { + paramCrossZ = (ceil(beginPos[indices[2]]) - beginPos[indices[2]]) * paramDeltaZ; + } + else + { + paramCrossZ = (beginPos[indices[2]] - floor(beginPos[indices[2]])) * paramDeltaZ; + } + } + else + { + paramCrossZ = infinite; // Will never cross on Z + } + + rs.x = static_cast(floor(beginPos[indices[0]])); + rs.z = static_cast(floor(beginPos[indices[2]])); + + // Workaround cases where the ray starts at an integer position + if (paramCrossX == 0.0) + { + paramCrossX += paramDeltaX; + // If going backwards, we should ignore the position we would get by the above flooring, + // because the ray is not heading in that direction + if (xiStep == -1) + { + rs.x -= 1; + } + } + + if (paramCrossZ == 0.0) + { + paramCrossZ += paramDeltaZ; + if (ziStep == -1) + rs.z -= 1; + } + + rs.prev_x = rs.x; + rs.prev_z = rs.z; + rs.param = 0; + + while (true) + { + rs.prev_x = rs.x; + rs.prev_z = rs.z; + rs.prevParam = rs.param; + + if (paramCrossX < paramCrossZ) + { + // X lane + rs.x += xiStep; + // Assign before advancing the param, + // to be in sync with the initialization step + rs.param = paramCrossX; + paramCrossX += paramDeltaX; + } + else + { + // Z lane + rs.z += ziStep; + rs.param = paramCrossZ; + paramCrossZ += paramDeltaZ; + } + + if (rs.param > rs.maxDistanceFlat) + { + rs.param = rs.maxDistanceFlat; + quadAction(rs); + break; + } + else + { + quadAction(rs); + } + } +} + +struct ProcessTrianglesAction +{ + const btHeightfieldTerrainShape* shape; + bool flipQuadEdges; + bool useDiamondSubdivision; + int width; + int length; + btTriangleCallback* callback; + + void exec(int x, int z) const + { + if (x < 0 || z < 0 || x >= width || z >= length) + { + return; + } + + btVector3 vertices[3]; + + // TODO Since this is for raycasts, we could greatly benefit from an early exit on the first hit + + // Check quad + if (flipQuadEdges || (useDiamondSubdivision && (((z + x) & 1) > 0))) + { + // First triangle + shape->getVertex(x, z, vertices[0]); + shape->getVertex(x + 1, z, vertices[1]); + shape->getVertex(x + 1, z + 1, vertices[2]); + callback->processTriangle(vertices, x, z); + + // Second triangle + shape->getVertex(x, z, vertices[0]); + shape->getVertex(x + 1, z + 1, vertices[1]); + shape->getVertex(x, z + 1, vertices[2]); + callback->processTriangle(vertices, x, z); + } + else + { + // First triangle + shape->getVertex(x, z, vertices[0]); + shape->getVertex(x, z + 1, vertices[1]); + shape->getVertex(x + 1, z, vertices[2]); + callback->processTriangle(vertices, x, z); + + // Second triangle + shape->getVertex(x + 1, z, vertices[0]); + shape->getVertex(x, z + 1, vertices[1]); + shape->getVertex(x + 1, z + 1, vertices[2]); + callback->processTriangle(vertices, x, z); + } + } + + void operator()(const GridRaycastState& bs) const + { + exec(bs.prev_x, bs.prev_z); + } +}; + +struct ProcessVBoundsAction +{ + const btAlignedObjectArray& vbounds; + int width; + int length; + int chunkSize; + + btVector3 rayBegin; + btVector3 rayEnd; + btVector3 rayDir; + + int* m_indices; + ProcessTrianglesAction processTriangles; + + ProcessVBoundsAction(const btAlignedObjectArray& bnd, int* indices) + : vbounds(bnd), + m_indices(indices) + { + } + void operator()(const GridRaycastState& rs) const + { + int x = rs.prev_x; + int z = rs.prev_z; + + if (x < 0 || z < 0 || x >= width || z >= length) + { + return; + } + + const btHeightfieldTerrainShape::Range chunk = vbounds[x + z * width]; + + btVector3 enterPos; + btVector3 exitPos; + + if (rs.maxDistanceFlat > 0.0001) + { + btScalar flatTo3d = chunkSize * rs.maxDistance3d / rs.maxDistanceFlat; + btScalar enterParam3d = rs.prevParam * flatTo3d; + btScalar exitParam3d = rs.param * flatTo3d; + enterPos = rayBegin + rayDir * enterParam3d; + exitPos = rayBegin + rayDir * exitParam3d; + + // We did enter the flat projection of the AABB, + // but we have to check if we intersect it on the vertical axis + if (enterPos[1] > chunk.max && exitPos[m_indices[1]] > chunk.max) + { + return; + } + if (enterPos[1] < chunk.min && exitPos[m_indices[1]] < chunk.min) + { + return; + } + } + else + { + // Consider the ray vertical + // (though we shouldn't reach this often because there is an early check up-front) + enterPos = rayBegin; + exitPos = rayEnd; + } + + gridRaycast(processTriangles, enterPos, exitPos, m_indices); + // Note: it could be possible to have more than one grid at different levels, + // to do this there would be a branch using a pointer to another ProcessVBoundsAction + } +}; + +// TODO How do I interrupt the ray when there is a hit? `callback` does not return any result +/// Performs a raycast using a hierarchical Bresenham algorithm. +/// Does not allocate any memory by itself. +void btHeightfieldTerrainShape::performRaycast(btTriangleCallback* callback, const btVector3& raySource, const btVector3& rayTarget) const +{ + // Transform to cell-local + btVector3 beginPos = raySource / m_localScaling; + btVector3 endPos = rayTarget / m_localScaling; + beginPos += m_localOrigin; + endPos += m_localOrigin; + + ProcessTrianglesAction processTriangles; + processTriangles.shape = this; + processTriangles.flipQuadEdges = m_flipQuadEdges; + processTriangles.useDiamondSubdivision = m_useDiamondSubdivision; + processTriangles.callback = callback; + processTriangles.width = m_heightStickWidth - 1; + processTriangles.length = m_heightStickLength - 1; + + // TODO Transform vectors to account for m_upAxis + int indices[3] = { 0, 1, 2 }; + if (m_upAxis == 2) + { + indices[1] = 2; + indices[2] = 1; + } + int iBeginX = static_cast(floor(beginPos[indices[0]])); + int iBeginZ = static_cast(floor(beginPos[indices[2]])); + int iEndX = static_cast(floor(endPos[indices[0]])); + int iEndZ = static_cast(floor(endPos[indices[2]])); + + if (iBeginX == iEndX && iBeginZ == iEndZ) + { + // The ray will never cross quads within the plane, + // so directly process triangles within one quad + // (typically, vertical rays should end up here) + processTriangles.exec(iBeginX, iEndZ); + return; + } + + + + if (m_vboundsGrid.size()==0) + { + // Process all quads intersecting the flat projection of the ray + gridRaycast(processTriangles, beginPos, endPos, &indices[0]); + } + else + { + btVector3 rayDiff = endPos - beginPos; + btScalar flatDistance2 = rayDiff[indices[0]] * rayDiff[indices[0]] + rayDiff[indices[2]] * rayDiff[indices[2]]; + if (flatDistance2 < m_vboundsChunkSize * m_vboundsChunkSize) + { + // Don't use chunks, the ray is too short in the plane + gridRaycast(processTriangles, beginPos, endPos, &indices[0]); + return; + } + + ProcessVBoundsAction processVBounds(m_vboundsGrid, &indices[0]); + processVBounds.width = m_vboundsGridWidth; + processVBounds.length = m_vboundsGridLength; + processVBounds.rayBegin = beginPos; + processVBounds.rayEnd = endPos; + processVBounds.rayDir = rayDiff.normalized(); + processVBounds.processTriangles = processTriangles; + processVBounds.chunkSize = m_vboundsChunkSize; + // The ray is long, run raycast on a higher-level grid + gridRaycast(processVBounds, beginPos / m_vboundsChunkSize, endPos / m_vboundsChunkSize, indices); + } +} + +/// Builds a grid data structure storing the min and max heights of the terrain in chunks. +/// if chunkSize is zero, that accelerator is removed. +/// If you modify the heights, you need to rebuild this accelerator. +void btHeightfieldTerrainShape::buildAccelerator(int chunkSize) +{ + if (chunkSize <= 0) + { + clearAccelerator(); + return; + } + + m_vboundsChunkSize = chunkSize; + int nChunksX = m_heightStickWidth / chunkSize; + int nChunksZ = m_heightStickLength / chunkSize; + + if (m_heightStickWidth % chunkSize > 0) + { + ++nChunksX; // In case terrain size isn't dividable by chunk size + } + if (m_heightStickLength % chunkSize > 0) + { + ++nChunksZ; + } + + if (m_vboundsGridWidth != nChunksX || m_vboundsGridLength != nChunksZ) + { + clearAccelerator(); + m_vboundsGridWidth = nChunksX; + m_vboundsGridLength = nChunksZ; + } + + if (nChunksX == 0 || nChunksZ == 0) + { + return; + } + + // This data structure is only reallocated if the required size changed + m_vboundsGrid.resize(nChunksX * nChunksZ); + + // Compute min and max height for all chunks + for (int cz = 0; cz < nChunksZ; ++cz) + { + int z0 = cz * chunkSize; + + for (int cx = 0; cx < nChunksX; ++cx) + { + int x0 = cx * chunkSize; + + Range r; + + r.min = getRawHeightFieldValue(x0, z0); + r.max = r.min; + + // Compute min and max height for this chunk. + // We have to include one extra cell to account for neighbors. + // Here is why: + // Say we have a flat terrain, and a plateau that fits a chunk perfectly. + // + // Left Right + // 0---0---0---1---1---1 + // | | | | | | + // 0---0---0---1---1---1 + // | | | | | | + // 0---0---0---1---1---1 + // x + // + // If the AABB for the Left chunk did not share vertices with the Right, + // then we would fail collision tests at x due to a gap. + // + for (int z = z0; z < z0 + chunkSize + 1; ++z) + { + if (z >= m_heightStickLength) + { + continue; + } + + for (int x = x0; x < x0 + chunkSize + 1; ++x) + { + if (x >= m_heightStickWidth) + { + continue; + } + + btScalar height = getRawHeightFieldValue(x, z); + + if (height < r.min) + { + r.min = height; + } + else if (height > r.max) + { + r.max = height; + } + } + } + + m_vboundsGrid[cx + cz * nChunksX] = r; + } + } +} + +void btHeightfieldTerrainShape::clearAccelerator() +{ + m_vboundsGrid.clear(); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp.i new file mode 100644 index 00000000..40d7ce95 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h new file mode 100644 index 00000000..7e251fa7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h @@ -0,0 +1,250 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_HEIGHTFIELD_TERRAIN_SHAPE_H +#define BT_HEIGHTFIELD_TERRAIN_SHAPE_H + +#include "btConcaveShape.h" +#include "LinearMath/btAlignedObjectArray.h" + +///btHeightfieldTerrainShape simulates a 2D heightfield terrain +/** + The caller is responsible for maintaining the heightfield array; this + class does not make a copy. + + The heightfield can be dynamic so long as the min/max height values + capture the extremes (heights must always be in that range). + + The local origin of the heightfield is assumed to be the exact + center (as determined by width and length and height, with each + axis multiplied by the localScaling). + + \b NOTE: be careful with coordinates. If you have a heightfield with a local + min height of -100m, and a max height of +500m, you may be tempted to place it + at the origin (0,0) and expect the heights in world coordinates to be + -100 to +500 meters. + Actually, the heights will be -300 to +300m, because bullet will re-center + the heightfield based on its AABB (which is determined by the min/max + heights). So keep in mind that once you create a btHeightfieldTerrainShape + object, the heights will be adjusted relative to the center of the AABB. This + is different to the behavior of many rendering engines, but is useful for + physics engines. + + Most (but not all) rendering and heightfield libraries assume upAxis = 1 + (that is, the y-axis is "up"). This class allows any of the 3 coordinates + to be "up". Make sure your choice of axis is consistent with your rendering + system. + + The heightfield heights are determined from the data type used for the + heightfieldData array. + + - unsigned char: height at a point is the uchar value at the + grid point, multipled by heightScale. uchar isn't recommended + because of its inability to deal with negative values, and + low resolution (8-bit). + + - short: height at a point is the short int value at that grid + point, multipled by heightScale. + + - float or dobule: height at a point is the value at that grid point. + + Whatever the caller specifies as minHeight and maxHeight will be honored. + The class will not inspect the heightfield to discover the actual minimum + or maximum heights. These values are used to determine the heightfield's + axis-aligned bounding box, multiplied by localScaling. + + For usage and testing see the TerrainDemo. + */ +ATTRIBUTE_ALIGNED16(class) +btHeightfieldTerrainShape : public btConcaveShape +{ +public: + struct Range + { + Range() {} + Range(btScalar min, btScalar max) : min(min), max(max) {} + + bool overlaps(const Range& other) const + { + return !(min > other.max || max < other.min); + } + + btScalar min; + btScalar max; + }; + +protected: + btVector3 m_localAabbMin; + btVector3 m_localAabbMax; + btVector3 m_localOrigin; + + ///terrain data + int m_heightStickWidth; + int m_heightStickLength; + btScalar m_minHeight; + btScalar m_maxHeight; + btScalar m_width; + btScalar m_length; + btScalar m_heightScale; + union { + const unsigned char* m_heightfieldDataUnsignedChar; + const short* m_heightfieldDataShort; + const float* m_heightfieldDataFloat; + const double* m_heightfieldDataDouble; + const void* m_heightfieldDataUnknown; + }; + + PHY_ScalarType m_heightDataType; + bool m_flipQuadEdges; + bool m_useDiamondSubdivision; + bool m_useZigzagSubdivision; + bool m_flipTriangleWinding; + int m_upAxis; + + btVector3 m_localScaling; + + // Accelerator + btAlignedObjectArray m_vboundsGrid; + int m_vboundsGridWidth; + int m_vboundsGridLength; + int m_vboundsChunkSize; + + + btScalar m_userValue3; + + struct btTriangleInfoMap* m_triangleInfoMap; + + virtual btScalar getRawHeightFieldValue(int x, int y) const; + void quantizeWithClamp(int* out, const btVector3& point, int isMax) const; + + /// protected initialization + /** + Handles the work of constructors so that public constructors can be + backwards-compatible without a lot of copy/paste. + */ + void initialize(int heightStickWidth, int heightStickLength, + const void* heightfieldData, btScalar heightScale, + btScalar minHeight, btScalar maxHeight, int upAxis, + PHY_ScalarType heightDataType, bool flipQuadEdges); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + /// preferred constructors + btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + const float* heightfieldData, btScalar minHeight, btScalar maxHeight, + int upAxis, bool flipQuadEdges); + btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + const double* heightfieldData, btScalar minHeight, btScalar maxHeight, + int upAxis, bool flipQuadEdges); + btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + const short* heightfieldData, btScalar heightScale, btScalar minHeight, btScalar maxHeight, + int upAxis, bool flipQuadEdges); + btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + const unsigned char* heightfieldData, btScalar heightScale, btScalar minHeight, btScalar maxHeight, + int upAxis, bool flipQuadEdges); + + /// legacy constructor + /** + This constructor supports a range of heightfield + data types, and allows for a non-zero minimum height value. + heightScale is needed for any integer-based heightfield data types. + + This legacy constructor considers `PHY_FLOAT` to mean `btScalar`. + With `BT_USE_DOUBLE_PRECISION`, it will expect `heightfieldData` + to be double-precision. + */ + btHeightfieldTerrainShape(int heightStickWidth, int heightStickLength, + const void* heightfieldData, btScalar heightScale, + btScalar minHeight, btScalar maxHeight, + int upAxis, PHY_ScalarType heightDataType, + bool flipQuadEdges); + + /// legacy constructor + /** + The legacy constructor assumes the heightfield has a minimum height + of zero. Only unsigned char or btScalar data are supported. For legacy + compatibility reasons, heightScale is calculated as maxHeight / 65535 + (and is only used when useFloatData = false). + */ + btHeightfieldTerrainShape(int heightStickWidth, int heightStickLength, const void* heightfieldData, btScalar maxHeight, int upAxis, bool useFloatData, bool flipQuadEdges); + + virtual ~btHeightfieldTerrainShape(); + + void setUseDiamondSubdivision(bool useDiamondSubdivision = true) { m_useDiamondSubdivision = useDiamondSubdivision; } + + ///could help compatibility with Ogre heightfields. See https://code.google.com/p/bullet/issues/detail?id=625 + void setUseZigzagSubdivision(bool useZigzagSubdivision = true) { m_useZigzagSubdivision = useZigzagSubdivision; } + + void setFlipTriangleWinding(bool flipTriangleWinding) + { + m_flipTriangleWinding = flipTriangleWinding; + } + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const; + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + virtual void setLocalScaling(const btVector3& scaling); + + virtual const btVector3& getLocalScaling() const; + + void getVertex(int x, int y, btVector3& vertex) const; + + void performRaycast(btTriangleCallback * callback, const btVector3& raySource, const btVector3& rayTarget) const; + + void buildAccelerator(int chunkSize = 16); + void clearAccelerator(); + + int getUpAxis() const + { + return m_upAxis; + } + //debugging + virtual const char* getName() const { return "HEIGHTFIELD"; } + + + void setUserValue3(btScalar value) + { + m_userValue3 = value; + } + btScalar getUserValue3() const + { + return m_userValue3; + } + const struct btTriangleInfoMap* getTriangleInfoMap() const + { + return m_triangleInfoMap; + } + struct btTriangleInfoMap* getTriangleInfoMap() + { + return m_triangleInfoMap; + } + void setTriangleInfoMap(btTriangleInfoMap* map) + { + m_triangleInfoMap = map; + } + const unsigned char* getHeightfieldRawData() const + { + return m_heightfieldDataUnsignedChar; + } +}; + +#endif //BT_HEIGHTFIELD_TERRAIN_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h.i new file mode 100644 index 00000000..7d416fbf --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMaterial.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMaterial.h new file mode 100644 index 00000000..c9a436bf --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMaterial.h @@ -0,0 +1,38 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/// This file was created by Alex Silverman + +#ifndef BT_MATERIAL_H +#define BT_MATERIAL_H + +// Material class to be used by btMultimaterialTriangleMeshShape to store triangle properties +class btMaterial +{ + // public members so that materials can change due to world events +public: + btScalar m_friction; + btScalar m_restitution; + int pad[2]; + + btMaterial() {} + btMaterial(btScalar fric, btScalar rest) + { + m_friction = fric; + m_restitution = rest; + } +}; + +#endif // BT_MATERIAL_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMaterial.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMaterial.h.i new file mode 100644 index 00000000..bb9b07ad --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMaterial.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btMaterial.h ---------------- + +%include "BulletCollision/CollisionShapes/btMaterial.h" + +%{ +#include "BulletCollision/CollisionShapes/btMaterial.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.cpp new file mode 100644 index 00000000..13c0a343 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.cpp @@ -0,0 +1,522 @@ +#include "btMiniSDF.h" + +// +//Based on code from DiscreGrid, https://github.com/InteractiveComputerGraphics/Discregrid +//example: +//GenerateSDF.exe -r "32 32 32" -d "-1.6 -1.6 -.6 1.6 1.6 .6" concave_box.obj +//The MIT License (MIT) +// +//Copyright (c) 2017 Dan Koschier +// + +#include +#include //memcpy + +struct btSdfDataStream +{ + const char* m_data; + int m_size; + + int m_currentOffset; + + btSdfDataStream(const char* data, int size) + : m_data(data), + m_size(size), + m_currentOffset(0) + { + } + + template + bool read(T& val) + { + int bytes = sizeof(T); + if (m_currentOffset + bytes <= m_size) + { + char* dest = (char*)&val; + memcpy(dest, &m_data[m_currentOffset], bytes); + m_currentOffset += bytes; + return true; + } + btAssert(0); + return false; + } +}; + +bool btMiniSDF::load(const char* data, int size) +{ + int fileSize = -1; + + btSdfDataStream ds(data, size); + { + double buf[6]; + ds.read(buf); + m_domain.m_min[0] = buf[0]; + m_domain.m_min[1] = buf[1]; + m_domain.m_min[2] = buf[2]; + m_domain.m_min[3] = 0; + m_domain.m_max[0] = buf[3]; + m_domain.m_max[1] = buf[4]; + m_domain.m_max[2] = buf[5]; + m_domain.m_max[3] = 0; + } + { + unsigned int buf2[3]; + ds.read(buf2); + m_resolution[0] = buf2[0]; + m_resolution[1] = buf2[1]; + m_resolution[2] = buf2[2]; + } + { + double buf[3]; + ds.read(buf); + m_cell_size[0] = buf[0]; + m_cell_size[1] = buf[1]; + m_cell_size[2] = buf[2]; + } + { + double buf[3]; + ds.read(buf); + m_inv_cell_size[0] = buf[0]; + m_inv_cell_size[1] = buf[1]; + m_inv_cell_size[2] = buf[2]; + } + { + unsigned long long int cells; + ds.read(cells); + m_n_cells = cells; + } + { + unsigned long long int fields; + ds.read(fields); + m_n_fields = fields; + } + + unsigned long long int nodes0; + std::size_t n_nodes0; + ds.read(nodes0); + n_nodes0 = nodes0; + if (n_nodes0 > 1024 * 1024 * 1024) + { + return m_isValid; + } + m_nodes.resize(n_nodes0); + for (unsigned int i = 0; i < n_nodes0; i++) + { + unsigned long long int n_nodes1; + ds.read(n_nodes1); + btAlignedObjectArray& nodes = m_nodes[i]; + nodes.resize(n_nodes1); + for (int j = 0; j < nodes.size(); j++) + { + double& node = nodes[j]; + ds.read(node); + } + } + + unsigned long long int n_cells0; + ds.read(n_cells0); + m_cells.resize(n_cells0); + for (int i = 0; i < n_cells0; i++) + { + unsigned long long int n_cells1; + btAlignedObjectArray& cells = m_cells[i]; + ds.read(n_cells1); + cells.resize(n_cells1); + for (int j = 0; j < n_cells1; j++) + { + btCell32& cell = cells[j]; + ds.read(cell); + } + } + + { + unsigned long long int n_cell_maps0; + ds.read(n_cell_maps0); + + m_cell_map.resize(n_cell_maps0); + for (int i = 0; i < n_cell_maps0; i++) + { + unsigned long long int n_cell_maps1; + btAlignedObjectArray& cell_maps = m_cell_map[i]; + ds.read(n_cell_maps1); + cell_maps.resize(n_cell_maps1); + for (int j = 0; j < n_cell_maps1; j++) + { + unsigned int& cell_map = cell_maps[j]; + ds.read(cell_map); + } + } + } + + m_isValid = (ds.m_currentOffset == ds.m_size); + return m_isValid; +} + +unsigned int btMiniSDF::multiToSingleIndex(btMultiIndex const& ijk) const +{ + return m_resolution[1] * m_resolution[0] * ijk.ijk[2] + m_resolution[0] * ijk.ijk[1] + ijk.ijk[0]; +} + +btAlignedBox3d +btMiniSDF::subdomain(btMultiIndex const& ijk) const +{ + btAssert(m_isValid); + btVector3 tmp; + tmp.m_floats[0] = m_cell_size[0] * (double)ijk.ijk[0]; + tmp.m_floats[1] = m_cell_size[1] * (double)ijk.ijk[1]; + tmp.m_floats[2] = m_cell_size[2] * (double)ijk.ijk[2]; + + btVector3 origin = m_domain.min() + tmp; + + btAlignedBox3d box = btAlignedBox3d(origin, origin + m_cell_size); + return box; +} + +btMultiIndex +btMiniSDF::singleToMultiIndex(unsigned int l) const +{ + btAssert(m_isValid); + unsigned int n01 = m_resolution[0] * m_resolution[1]; + unsigned int k = l / n01; + unsigned int temp = l % n01; + unsigned int j = temp / m_resolution[0]; + unsigned int i = temp % m_resolution[0]; + btMultiIndex mi; + mi.ijk[0] = i; + mi.ijk[1] = j; + mi.ijk[2] = k; + return mi; +} + +btAlignedBox3d +btMiniSDF::subdomain(unsigned int l) const +{ + btAssert(m_isValid); + return subdomain(singleToMultiIndex(l)); +} + +btShapeMatrix +btMiniSDF::shape_function_(btVector3 const& xi, btShapeGradients* gradient) const +{ + btAssert(m_isValid); + btShapeMatrix res; + + btScalar x = xi[0]; + btScalar y = xi[1]; + btScalar z = xi[2]; + + btScalar x2 = x * x; + btScalar y2 = y * y; + btScalar z2 = z * z; + + btScalar _1mx = 1.0 - x; + btScalar _1my = 1.0 - y; + btScalar _1mz = 1.0 - z; + + btScalar _1px = 1.0 + x; + btScalar _1py = 1.0 + y; + btScalar _1pz = 1.0 + z; + + btScalar _1m3x = 1.0 - 3.0 * x; + btScalar _1m3y = 1.0 - 3.0 * y; + btScalar _1m3z = 1.0 - 3.0 * z; + + btScalar _1p3x = 1.0 + 3.0 * x; + btScalar _1p3y = 1.0 + 3.0 * y; + btScalar _1p3z = 1.0 + 3.0 * z; + + btScalar _1mxt1my = _1mx * _1my; + btScalar _1mxt1py = _1mx * _1py; + btScalar _1pxt1my = _1px * _1my; + btScalar _1pxt1py = _1px * _1py; + + btScalar _1mxt1mz = _1mx * _1mz; + btScalar _1mxt1pz = _1mx * _1pz; + btScalar _1pxt1mz = _1px * _1mz; + btScalar _1pxt1pz = _1px * _1pz; + + btScalar _1myt1mz = _1my * _1mz; + btScalar _1myt1pz = _1my * _1pz; + btScalar _1pyt1mz = _1py * _1mz; + btScalar _1pyt1pz = _1py * _1pz; + + btScalar _1mx2 = 1.0 - x2; + btScalar _1my2 = 1.0 - y2; + btScalar _1mz2 = 1.0 - z2; + + // Corner nodes. + btScalar fac = 1.0 / 64.0 * (9.0 * (x2 + y2 + z2) - 19.0); + res[0] = fac * _1mxt1my * _1mz; + res[1] = fac * _1pxt1my * _1mz; + res[2] = fac * _1mxt1py * _1mz; + res[3] = fac * _1pxt1py * _1mz; + res[4] = fac * _1mxt1my * _1pz; + res[5] = fac * _1pxt1my * _1pz; + res[6] = fac * _1mxt1py * _1pz; + res[7] = fac * _1pxt1py * _1pz; + + // Edge nodes. + + fac = 9.0 / 64.0 * _1mx2; + btScalar fact1m3x = fac * _1m3x; + btScalar fact1p3x = fac * _1p3x; + res[8] = fact1m3x * _1myt1mz; + res[9] = fact1p3x * _1myt1mz; + res[10] = fact1m3x * _1myt1pz; + res[11] = fact1p3x * _1myt1pz; + res[12] = fact1m3x * _1pyt1mz; + res[13] = fact1p3x * _1pyt1mz; + res[14] = fact1m3x * _1pyt1pz; + res[15] = fact1p3x * _1pyt1pz; + + fac = 9.0 / 64.0 * _1my2; + btScalar fact1m3y = fac * _1m3y; + btScalar fact1p3y = fac * _1p3y; + res[16] = fact1m3y * _1mxt1mz; + res[17] = fact1p3y * _1mxt1mz; + res[18] = fact1m3y * _1pxt1mz; + res[19] = fact1p3y * _1pxt1mz; + res[20] = fact1m3y * _1mxt1pz; + res[21] = fact1p3y * _1mxt1pz; + res[22] = fact1m3y * _1pxt1pz; + res[23] = fact1p3y * _1pxt1pz; + + fac = 9.0 / 64.0 * _1mz2; + btScalar fact1m3z = fac * _1m3z; + btScalar fact1p3z = fac * _1p3z; + res[24] = fact1m3z * _1mxt1my; + res[25] = fact1p3z * _1mxt1my; + res[26] = fact1m3z * _1mxt1py; + res[27] = fact1p3z * _1mxt1py; + res[28] = fact1m3z * _1pxt1my; + res[29] = fact1p3z * _1pxt1my; + res[30] = fact1m3z * _1pxt1py; + res[31] = fact1p3z * _1pxt1py; + + if (gradient) + { + btShapeGradients& dN = *gradient; + + btScalar _9t3x2py2pz2m19 = 9.0 * (3.0 * x2 + y2 + z2) - 19.0; + btScalar _9tx2p3y2pz2m19 = 9.0 * (x2 + 3.0 * y2 + z2) - 19.0; + btScalar _9tx2py2p3z2m19 = 9.0 * (x2 + y2 + 3.0 * z2) - 19.0; + btScalar _18x = 18.0 * x; + btScalar _18y = 18.0 * y; + btScalar _18z = 18.0 * z; + + btScalar _3m9x2 = 3.0 - 9.0 * x2; + btScalar _3m9y2 = 3.0 - 9.0 * y2; + btScalar _3m9z2 = 3.0 - 9.0 * z2; + + btScalar _2x = 2.0 * x; + btScalar _2y = 2.0 * y; + btScalar _2z = 2.0 * z; + + btScalar _18xm9t3x2py2pz2m19 = _18x - _9t3x2py2pz2m19; + btScalar _18xp9t3x2py2pz2m19 = _18x + _9t3x2py2pz2m19; + btScalar _18ym9tx2p3y2pz2m19 = _18y - _9tx2p3y2pz2m19; + btScalar _18yp9tx2p3y2pz2m19 = _18y + _9tx2p3y2pz2m19; + btScalar _18zm9tx2py2p3z2m19 = _18z - _9tx2py2p3z2m19; + btScalar _18zp9tx2py2p3z2m19 = _18z + _9tx2py2p3z2m19; + + dN(0, 0) = _18xm9t3x2py2pz2m19 * _1myt1mz; + dN(0, 1) = _1mxt1mz * _18ym9tx2p3y2pz2m19; + dN(0, 2) = _1mxt1my * _18zm9tx2py2p3z2m19; + dN(1, 0) = _18xp9t3x2py2pz2m19 * _1myt1mz; + dN(1, 1) = _1pxt1mz * _18ym9tx2p3y2pz2m19; + dN(1, 2) = _1pxt1my * _18zm9tx2py2p3z2m19; + dN(2, 0) = _18xm9t3x2py2pz2m19 * _1pyt1mz; + dN(2, 1) = _1mxt1mz * _18yp9tx2p3y2pz2m19; + dN(2, 2) = _1mxt1py * _18zm9tx2py2p3z2m19; + dN(3, 0) = _18xp9t3x2py2pz2m19 * _1pyt1mz; + dN(3, 1) = _1pxt1mz * _18yp9tx2p3y2pz2m19; + dN(3, 2) = _1pxt1py * _18zm9tx2py2p3z2m19; + dN(4, 0) = _18xm9t3x2py2pz2m19 * _1myt1pz; + dN(4, 1) = _1mxt1pz * _18ym9tx2p3y2pz2m19; + dN(4, 2) = _1mxt1my * _18zp9tx2py2p3z2m19; + dN(5, 0) = _18xp9t3x2py2pz2m19 * _1myt1pz; + dN(5, 1) = _1pxt1pz * _18ym9tx2p3y2pz2m19; + dN(5, 2) = _1pxt1my * _18zp9tx2py2p3z2m19; + dN(6, 0) = _18xm9t3x2py2pz2m19 * _1pyt1pz; + dN(6, 1) = _1mxt1pz * _18yp9tx2p3y2pz2m19; + dN(6, 2) = _1mxt1py * _18zp9tx2py2p3z2m19; + dN(7, 0) = _18xp9t3x2py2pz2m19 * _1pyt1pz; + dN(7, 1) = _1pxt1pz * _18yp9tx2p3y2pz2m19; + dN(7, 2) = _1pxt1py * _18zp9tx2py2p3z2m19; + + dN.topRowsDivide(8, 64.0); + + btScalar _m3m9x2m2x = -_3m9x2 - _2x; + btScalar _p3m9x2m2x = _3m9x2 - _2x; + btScalar _1mx2t1m3x = _1mx2 * _1m3x; + btScalar _1mx2t1p3x = _1mx2 * _1p3x; + dN(8, 0) = _m3m9x2m2x * _1myt1mz, + dN(8, 1) = -_1mx2t1m3x * _1mz, + dN(8, 2) = -_1mx2t1m3x * _1my; + dN(9, 0) = _p3m9x2m2x * _1myt1mz, + dN(9, 1) = -_1mx2t1p3x * _1mz, + dN(9, 2) = -_1mx2t1p3x * _1my; + dN(10, 0) = _m3m9x2m2x * _1myt1pz, + dN(10, 1) = -_1mx2t1m3x * _1pz, + dN(10, 2) = _1mx2t1m3x * _1my; + dN(11, 0) = _p3m9x2m2x * _1myt1pz, + dN(11, 1) = -_1mx2t1p3x * _1pz, + dN(11, 2) = _1mx2t1p3x * _1my; + dN(12, 0) = _m3m9x2m2x * _1pyt1mz, + dN(12, 1) = _1mx2t1m3x * _1mz, + dN(12, 2) = -_1mx2t1m3x * _1py; + dN(13, 0) = _p3m9x2m2x * _1pyt1mz, + dN(13, 1) = _1mx2t1p3x * _1mz, + dN(13, 2) = -_1mx2t1p3x * _1py; + dN(14, 0) = _m3m9x2m2x * _1pyt1pz, + dN(14, 1) = _1mx2t1m3x * _1pz, + dN(14, 2) = _1mx2t1m3x * _1py; + dN(15, 0) = _p3m9x2m2x * _1pyt1pz, + dN(15, 1) = _1mx2t1p3x * _1pz, + dN(15, 2) = _1mx2t1p3x * _1py; + + btScalar _m3m9y2m2y = -_3m9y2 - _2y; + btScalar _p3m9y2m2y = _3m9y2 - _2y; + btScalar _1my2t1m3y = _1my2 * _1m3y; + btScalar _1my2t1p3y = _1my2 * _1p3y; + dN(16, 0) = -_1my2t1m3y * _1mz, + dN(16, 1) = _m3m9y2m2y * _1mxt1mz, + dN(16, 2) = -_1my2t1m3y * _1mx; + dN(17, 0) = -_1my2t1p3y * _1mz, + dN(17, 1) = _p3m9y2m2y * _1mxt1mz, + dN(17, 2) = -_1my2t1p3y * _1mx; + dN(18, 0) = _1my2t1m3y * _1mz, + dN(18, 1) = _m3m9y2m2y * _1pxt1mz, + dN(18, 2) = -_1my2t1m3y * _1px; + dN(19, 0) = _1my2t1p3y * _1mz, + dN(19, 1) = _p3m9y2m2y * _1pxt1mz, + dN(19, 2) = -_1my2t1p3y * _1px; + dN(20, 0) = -_1my2t1m3y * _1pz, + dN(20, 1) = _m3m9y2m2y * _1mxt1pz, + dN(20, 2) = _1my2t1m3y * _1mx; + dN(21, 0) = -_1my2t1p3y * _1pz, + dN(21, 1) = _p3m9y2m2y * _1mxt1pz, + dN(21, 2) = _1my2t1p3y * _1mx; + dN(22, 0) = _1my2t1m3y * _1pz, + dN(22, 1) = _m3m9y2m2y * _1pxt1pz, + dN(22, 2) = _1my2t1m3y * _1px; + dN(23, 0) = _1my2t1p3y * _1pz, + dN(23, 1) = _p3m9y2m2y * _1pxt1pz, + dN(23, 2) = _1my2t1p3y * _1px; + + btScalar _m3m9z2m2z = -_3m9z2 - _2z; + btScalar _p3m9z2m2z = _3m9z2 - _2z; + btScalar _1mz2t1m3z = _1mz2 * _1m3z; + btScalar _1mz2t1p3z = _1mz2 * _1p3z; + dN(24, 0) = -_1mz2t1m3z * _1my, + dN(24, 1) = -_1mz2t1m3z * _1mx, + dN(24, 2) = _m3m9z2m2z * _1mxt1my; + dN(25, 0) = -_1mz2t1p3z * _1my, + dN(25, 1) = -_1mz2t1p3z * _1mx, + dN(25, 2) = _p3m9z2m2z * _1mxt1my; + dN(26, 0) = -_1mz2t1m3z * _1py, + dN(26, 1) = _1mz2t1m3z * _1mx, + dN(26, 2) = _m3m9z2m2z * _1mxt1py; + dN(27, 0) = -_1mz2t1p3z * _1py, + dN(27, 1) = _1mz2t1p3z * _1mx, + dN(27, 2) = _p3m9z2m2z * _1mxt1py; + dN(28, 0) = _1mz2t1m3z * _1my, + dN(28, 1) = -_1mz2t1m3z * _1px, + dN(28, 2) = _m3m9z2m2z * _1pxt1my; + dN(29, 0) = _1mz2t1p3z * _1my, + dN(29, 1) = -_1mz2t1p3z * _1px, + dN(29, 2) = _p3m9z2m2z * _1pxt1my; + dN(30, 0) = _1mz2t1m3z * _1py, + dN(30, 1) = _1mz2t1m3z * _1px, + dN(30, 2) = _m3m9z2m2z * _1pxt1py; + dN(31, 0) = _1mz2t1p3z * _1py, + dN(31, 1) = _1mz2t1p3z * _1px, + dN(31, 2) = _p3m9z2m2z * _1pxt1py; + + dN.bottomRowsMul(32u - 8u, 9.0 / 64.0); + } + + return res; +} + +bool btMiniSDF::interpolate(unsigned int field_id, double& dist, btVector3 const& x, + btVector3* gradient) const +{ + btAssert(m_isValid); + if (!m_isValid) + return false; + + if (!m_domain.contains(x)) + return false; + + btVector3 tmpmi = ((x - m_domain.min()) * (m_inv_cell_size)); //.cast().eval(); + unsigned int mi[3] = {(unsigned int)tmpmi[0], (unsigned int)tmpmi[1], (unsigned int)tmpmi[2]}; + if (mi[0] >= m_resolution[0]) + mi[0] = m_resolution[0] - 1; + if (mi[1] >= m_resolution[1]) + mi[1] = m_resolution[1] - 1; + if (mi[2] >= m_resolution[2]) + mi[2] = m_resolution[2] - 1; + btMultiIndex mui; + mui.ijk[0] = mi[0]; + mui.ijk[1] = mi[1]; + mui.ijk[2] = mi[2]; + int i = multiToSingleIndex(mui); + unsigned int i_ = m_cell_map[field_id][i]; + if (i_ == UINT_MAX) + return false; + + btAlignedBox3d sd = subdomain(i); + i = i_; + btVector3 d = sd.m_max - sd.m_min; //.diagonal().eval(); + + btVector3 denom = (sd.max() - sd.min()); + btVector3 c0 = btVector3(2.0, 2.0, 2.0) / denom; + btVector3 c1 = (sd.max() + sd.min()) / denom; + btVector3 xi = (c0 * x - c1); + + btCell32 const& cell = m_cells[field_id][i]; + if (!gradient) + { + //auto phi = m_coefficients[field_id][i].dot(shape_function_(xi, 0)); + double phi = 0.0; + btShapeMatrix N = shape_function_(xi, 0); + for (unsigned int j = 0u; j < 32u; ++j) + { + unsigned int v = cell.m_cells[j]; + double c = m_nodes[field_id][v]; + if (c == DBL_MAX) + { + return false; + ; + } + phi += c * N[j]; + } + + dist = phi; + return true; + } + + btShapeGradients dN; + btShapeMatrix N = shape_function_(xi, &dN); + + double phi = 0.0; + gradient->setZero(); + for (unsigned int j = 0u; j < 32u; ++j) + { + unsigned int v = cell.m_cells[j]; + double c = m_nodes[field_id][v]; + if (c == DBL_MAX) + { + gradient->setZero(); + return false; + } + phi += c * N[j]; + (*gradient)[0] += c * dN(j, 0); + (*gradient)[1] += c * dN(j, 1); + (*gradient)[2] += c * dN(j, 2); + } + (*gradient) *= c0; + dist = phi; + return true; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.cpp.i new file mode 100644 index 00000000..8c99e9ef --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btMiniSDF.cpp ---------------- + +// %include "BulletCollision/CollisionShapes/btMiniSDF.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btMiniSDF.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.h new file mode 100644 index 00000000..b60fd102 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.h @@ -0,0 +1,127 @@ +#ifndef MINISDF_H +#define MINISDF_H + +#include "LinearMath/btVector3.h" +#include "LinearMath/btAabbUtil2.h" +#include "LinearMath/btAlignedObjectArray.h" + +struct btMultiIndex +{ + unsigned int ijk[3]; +}; + +struct btAlignedBox3d +{ + btVector3 m_min; + btVector3 m_max; + + const btVector3& min() const + { + return m_min; + } + + const btVector3& max() const + { + return m_max; + } + + bool contains(const btVector3& x) const + { + return TestPointAgainstAabb2(m_min, m_max, x); + } + + btAlignedBox3d(const btVector3& mn, const btVector3& mx) + : m_min(mn), + m_max(mx) + { + } + + btAlignedBox3d() + { + } +}; + +struct btShapeMatrix +{ + double m_vec[32]; + + inline double& operator[](int i) + { + return m_vec[i]; + } + + inline const double& operator[](int i) const + { + return m_vec[i]; + } +}; + +struct btShapeGradients +{ + btVector3 m_vec[32]; + + void topRowsDivide(int row, double denom) + { + for (int i = 0; i < row; i++) + { + m_vec[i] /= denom; + } + } + + void bottomRowsMul(int row, double val) + { + for (int i = 32 - row; i < 32; i++) + { + m_vec[i] *= val; + } + } + + inline btScalar& operator()(int i, int j) + { + return m_vec[i][j]; + } +}; + +struct btCell32 +{ + unsigned int m_cells[32]; +}; + +struct btMiniSDF +{ + btAlignedBox3d m_domain; + unsigned int m_resolution[3]; + btVector3 m_cell_size; + btVector3 m_inv_cell_size; + std::size_t m_n_cells; + std::size_t m_n_fields; + bool m_isValid; + + btAlignedObjectArray > m_nodes; + btAlignedObjectArray > m_cells; + btAlignedObjectArray > m_cell_map; + + btMiniSDF() + : m_isValid(false) + { + } + bool load(const char* data, int size); + bool isValid() const + { + return m_isValid; + } + unsigned int multiToSingleIndex(btMultiIndex const& ijk) const; + + btAlignedBox3d subdomain(btMultiIndex const& ijk) const; + + btMultiIndex singleToMultiIndex(unsigned int l) const; + + btAlignedBox3d subdomain(unsigned int l) const; + + btShapeMatrix + shape_function_(btVector3 const& xi, btShapeGradients* gradient = 0) const; + + bool interpolate(unsigned int field_id, double& dist, btVector3 const& x, btVector3* gradient) const; +}; + +#endif //MINISDF_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.h.i new file mode 100644 index 00000000..7fb864da --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMiniSDF.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btMiniSDF.h ---------------- + +%include "BulletCollision/CollisionShapes/btMiniSDF.h" + +%{ +#include "BulletCollision/CollisionShapes/btMiniSDF.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp new file mode 100644 index 00000000..d4b6a651 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp @@ -0,0 +1,71 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btMinkowskiSumShape.h" + +btMinkowskiSumShape::btMinkowskiSumShape(const btConvexShape* shapeA, const btConvexShape* shapeB) + : btConvexInternalShape(), + m_shapeA(shapeA), + m_shapeB(shapeB) +{ + m_shapeType = MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE; + m_transA.setIdentity(); + m_transB.setIdentity(); +} + +btVector3 btMinkowskiSumShape::localGetSupportingVertexWithoutMargin(const btVector3& vec) const +{ + btVector3 supVertexA = m_transA(m_shapeA->localGetSupportingVertexWithoutMargin(vec * m_transA.getBasis())); + btVector3 supVertexB = m_transB(m_shapeB->localGetSupportingVertexWithoutMargin(-vec * m_transB.getBasis())); + return supVertexA - supVertexB; +} + +void btMinkowskiSumShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + ///@todo: could make recursive use of batching. probably this shape is not used frequently. + for (int i = 0; i < numVectors; i++) + { + supportVerticesOut[i] = localGetSupportingVertexWithoutMargin(vectors[i]); + } +} + +btScalar btMinkowskiSumShape::getMargin() const +{ + return m_shapeA->getMargin() + m_shapeB->getMargin(); +} + +void btMinkowskiSumShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + (void)mass; + //inertia of the AABB of the Minkowski sum + btTransform identity; + identity.setIdentity(); + btVector3 aabbMin, aabbMax; + getAabb(identity, aabbMin, aabbMax); + + btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5); + + btScalar margin = getMargin(); + + btScalar lx = btScalar(2.) * (halfExtents.x() + margin); + btScalar ly = btScalar(2.) * (halfExtents.y() + margin); + btScalar lz = btScalar(2.) * (halfExtents.z() + margin); + const btScalar x2 = lx * lx; + const btScalar y2 = ly * ly; + const btScalar z2 = lz * lz; + const btScalar scaledmass = mass * btScalar(0.08333333); + + inertia = scaledmass * (btVector3(y2 + z2, x2 + z2, x2 + y2)); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp.i new file mode 100644 index 00000000..a7643db2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.h new file mode 100644 index 00000000..f5763f69 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.h @@ -0,0 +1,62 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_MINKOWSKI_SUM_SHAPE_H +#define BT_MINKOWSKI_SUM_SHAPE_H + +#include "btConvexInternalShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +/// The btMinkowskiSumShape is only for advanced users. This shape represents implicit based minkowski sum of two convex implicit shapes. +ATTRIBUTE_ALIGNED16(class) +btMinkowskiSumShape : public btConvexInternalShape +{ + btTransform m_transA; + btTransform m_transB; + const btConvexShape* m_shapeA; + const btConvexShape* m_shapeB; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btMinkowskiSumShape(const btConvexShape* shapeA, const btConvexShape* shapeB); + + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + void setTransformA(const btTransform& transA) { m_transA = transA; } + void setTransformB(const btTransform& transB) { m_transB = transB; } + + const btTransform& getTransformA() const { return m_transA; } + const btTransform& getTransformB() const { return m_transB; } + + // keep this for backward compatibility + const btTransform& GetTransformB() const { return m_transB; } + + virtual btScalar getMargin() const; + + const btConvexShape* getShapeA() const { return m_shapeA; } + const btConvexShape* getShapeB() const { return m_shapeB; } + + virtual const char* getName() const + { + return "MinkowskiSum"; + } +}; + +#endif //BT_MINKOWSKI_SUM_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.h.i new file mode 100644 index 00000000..ac4066c8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMinkowskiSumShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btMinkowskiSumShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btMinkowskiSumShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btMinkowskiSumShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.cpp new file mode 100644 index 00000000..c0cc55df --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.cpp @@ -0,0 +1,169 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#if defined(_WIN32) || defined(__i386__) +#define BT_USE_SSE_IN_API +#endif + +#include "btMultiSphereShape.h" +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" +#include "LinearMath/btQuaternion.h" +#include "LinearMath/btSerializer.h" + +btMultiSphereShape::btMultiSphereShape(const btVector3* positions, const btScalar* radi, int numSpheres) + : btConvexInternalAabbCachingShape() +{ + m_shapeType = MULTI_SPHERE_SHAPE_PROXYTYPE; + //btScalar startMargin = btScalar(BT_LARGE_FLOAT); + + m_localPositionArray.resize(numSpheres); + m_radiArray.resize(numSpheres); + for (int i = 0; i < numSpheres; i++) + { + m_localPositionArray[i] = positions[i]; + m_radiArray[i] = radi[i]; + } + + recalcLocalAabb(); +} + +#ifndef MIN +#define MIN(_a, _b) ((_a) < (_b) ? (_a) : (_b)) +#endif +btVector3 btMultiSphereShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0) const +{ + btVector3 supVec(0, 0, 0); + + btScalar maxDot(btScalar(-BT_LARGE_FLOAT)); + + btVector3 vec = vec0; + btScalar lenSqr = vec.length2(); + if (lenSqr < (SIMD_EPSILON * SIMD_EPSILON)) + { + vec.setValue(1, 0, 0); + } + else + { + btScalar rlen = btScalar(1.) / btSqrt(lenSqr); + vec *= rlen; + } + + btVector3 vtx; + btScalar newDot; + + const btVector3* pos = &m_localPositionArray[0]; + const btScalar* rad = &m_radiArray[0]; + int numSpheres = m_localPositionArray.size(); + + for (int k = 0; k < numSpheres; k += 128) + { + btVector3 temp[128]; + int inner_count = MIN(numSpheres - k, 128); + for (long i = 0; i < inner_count; i++) + { + temp[i] = (*pos) * m_localScaling + vec * m_localScaling * (*rad) - vec * getMargin(); + pos++; + rad++; + } + long i = vec.maxDot(temp, inner_count, newDot); + if (newDot > maxDot) + { + maxDot = newDot; + supVec = temp[i]; + } + } + + return supVec; +} + +void btMultiSphereShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + for (int j = 0; j < numVectors; j++) + { + btScalar maxDot(btScalar(-BT_LARGE_FLOAT)); + + const btVector3& vec = vectors[j]; + + btVector3 vtx; + btScalar newDot; + + const btVector3* pos = &m_localPositionArray[0]; + const btScalar* rad = &m_radiArray[0]; + int numSpheres = m_localPositionArray.size(); + + for (int k = 0; k < numSpheres; k += 128) + { + btVector3 temp[128]; + int inner_count = MIN(numSpheres - k, 128); + for (long i = 0; i < inner_count; i++) + { + temp[i] = (*pos) * m_localScaling + vec * m_localScaling * (*rad) - vec * getMargin(); + pos++; + rad++; + } + long i = vec.maxDot(temp, inner_count, newDot); + if (newDot > maxDot) + { + maxDot = newDot; + supportVerticesOut[j] = temp[i]; + } + } + } +} + +void btMultiSphereShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + //as an approximation, take the inertia of the box that bounds the spheres + + btVector3 localAabbMin, localAabbMax; + getCachedLocalAabb(localAabbMin, localAabbMax); + btVector3 halfExtents = (localAabbMax - localAabbMin) * btScalar(0.5); + + btScalar lx = btScalar(2.) * (halfExtents.x()); + btScalar ly = btScalar(2.) * (halfExtents.y()); + btScalar lz = btScalar(2.) * (halfExtents.z()); + + inertia.setValue(mass / (btScalar(12.0)) * (ly * ly + lz * lz), + mass / (btScalar(12.0)) * (lx * lx + lz * lz), + mass / (btScalar(12.0)) * (lx * lx + ly * ly)); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +const char* btMultiSphereShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btMultiSphereShapeData* shapeData = (btMultiSphereShapeData*)dataBuffer; + btConvexInternalShape::serialize(&shapeData->m_convexInternalShapeData, serializer); + + int numElem = m_localPositionArray.size(); + shapeData->m_localPositionArrayPtr = numElem ? (btPositionAndRadius*)serializer->getUniquePointer((void*)&m_localPositionArray[0]) : 0; + + shapeData->m_localPositionArraySize = numElem; + if (numElem) + { + btChunk* chunk = serializer->allocate(sizeof(btPositionAndRadius), numElem); + btPositionAndRadius* memPtr = (btPositionAndRadius*)chunk->m_oldPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + m_localPositionArray[i].serializeFloat(memPtr->m_pos); + memPtr->m_radius = float(m_radiArray[i]); + } + serializer->finalizeChunk(chunk, "btPositionAndRadius", BT_ARRAY_CODE, (void*)&m_localPositionArray[0]); + } + + // Fill padding with zeros to appease msan. + memset(shapeData->m_padding, 0, sizeof(shapeData->m_padding)); + + return "btMultiSphereShapeData"; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.cpp.i new file mode 100644 index 00000000..8fac7456 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btMultiSphereShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btMultiSphereShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btMultiSphereShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.h new file mode 100644 index 00000000..2d79c07c --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.h @@ -0,0 +1,95 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_MULTI_SPHERE_MINKOWSKI_H +#define BT_MULTI_SPHERE_MINKOWSKI_H + +#include "btConvexInternalShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +#include "LinearMath/btAlignedObjectArray.h" +#include "LinearMath/btAabbUtil2.h" + +///The btMultiSphereShape represents the convex hull of a collection of spheres. You can create special capsules or other smooth volumes. +///It is possible to animate the spheres for deformation, but call 'recalcLocalAabb' after changing any sphere position/radius +ATTRIBUTE_ALIGNED16(class) +btMultiSphereShape : public btConvexInternalAabbCachingShape +{ + btAlignedObjectArray m_localPositionArray; + btAlignedObjectArray m_radiArray; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btMultiSphereShape(const btVector3* positions, const btScalar* radi, int numSpheres); + + ///CollisionShape Interface + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + /// btConvexShape Interface + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + int getSphereCount() const + { + return m_localPositionArray.size(); + } + + const btVector3& getSpherePosition(int index) const + { + return m_localPositionArray[index]; + } + + btScalar getSphereRadius(int index) const + { + return m_radiArray[index]; + } + + virtual const char* getName() const + { + return "MultiSphere"; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +struct btPositionAndRadius +{ + btVector3FloatData m_pos; + float m_radius; +}; + +// clang-format off + +struct btMultiSphereShapeData +{ + btConvexInternalShapeData m_convexInternalShapeData; + + btPositionAndRadius *m_localPositionArrayPtr; + int m_localPositionArraySize; + char m_padding[4]; +}; + +// clang-format on + +SIMD_FORCE_INLINE int btMultiSphereShape::calculateSerializeBufferSize() const +{ + return sizeof(btMultiSphereShapeData); +} + +#endif //BT_MULTI_SPHERE_MINKOWSKI_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.h.i new file mode 100644 index 00000000..5a211b05 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultiSphereShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btMultiSphereShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btMultiSphereShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btMultiSphereShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp new file mode 100644 index 00000000..30108c9e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp @@ -0,0 +1,43 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/// This file was created by Alex Silverman + +#include "BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h" +#include "BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h" +//#include "BulletCollision/CollisionShapes/btOptimizedBvh.h" + +///Obtains the material for a specific triangle +const btMaterial *btMultimaterialTriangleMeshShape::getMaterialProperties(int partID, int triIndex) +{ + const unsigned char *materialBase = 0; + int numMaterials; + PHY_ScalarType materialType; + int materialStride; + const unsigned char *triangleMaterialBase = 0; + int numTriangles; + int triangleMaterialStride; + PHY_ScalarType triangleType; + + ((btTriangleIndexVertexMaterialArray *)m_meshInterface)->getLockedReadOnlyMaterialBase(&materialBase, numMaterials, materialType, materialStride, &triangleMaterialBase, numTriangles, triangleMaterialStride, triangleType, partID); + + // return the pointer to the place with the friction for the triangle + // TODO: This depends on whether it's a moving mesh or not + // BUG IN GIMPACT + //return (btScalar*)(&materialBase[triangleMaterialBase[(triIndex-1) * triangleMaterialStride] * materialStride]); + int *matInd = (int *)(&(triangleMaterialBase[(triIndex * triangleMaterialStride)])); + btMaterial *matVal = (btMaterial *)(&(materialBase[*matInd * materialStride])); + return (matVal); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp.i new file mode 100644 index 00000000..def62c43 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h new file mode 100644 index 00000000..d1d42f8e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h @@ -0,0 +1,115 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/// This file was created by Alex Silverman + +#ifndef BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H +#define BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H + +#include "btBvhTriangleMeshShape.h" +#include "btMaterial.h" + +///The BvhTriangleMaterialMeshShape extends the btBvhTriangleMeshShape. Its main contribution is the interface into a material array, which allows per-triangle friction and restitution. +ATTRIBUTE_ALIGNED16(class) +btMultimaterialTriangleMeshShape : public btBvhTriangleMeshShape +{ + btAlignedObjectArray m_materialList; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btMultimaterialTriangleMeshShape(btStridingMeshInterface * meshInterface, bool useQuantizedAabbCompression, bool buildBvh = true) : btBvhTriangleMeshShape(meshInterface, useQuantizedAabbCompression, buildBvh) + { + m_shapeType = MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE; + + const unsigned char *vertexbase; + int numverts; + PHY_ScalarType type; + int stride; + const unsigned char *indexbase; + int indexstride; + int numfaces; + PHY_ScalarType indicestype; + + //m_materialLookup = (int**)(btAlignedAlloc(sizeof(int*) * meshInterface->getNumSubParts(), 16)); + + for (int i = 0; i < meshInterface->getNumSubParts(); i++) + { + m_meshInterface->getLockedReadOnlyVertexIndexBase( + &vertexbase, + numverts, + type, + stride, + &indexbase, + indexstride, + numfaces, + indicestype, + i); + //m_materialLookup[i] = (int*)(btAlignedAlloc(sizeof(int) * numfaces, 16)); + } + } + + ///optionally pass in a larger bvh aabb, used for quantization. This allows for deformations within this aabb + btMultimaterialTriangleMeshShape(btStridingMeshInterface * meshInterface, bool useQuantizedAabbCompression, const btVector3 &bvhAabbMin, const btVector3 &bvhAabbMax, bool buildBvh = true) : btBvhTriangleMeshShape(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax, buildBvh) + { + m_shapeType = MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE; + + const unsigned char *vertexbase; + int numverts; + PHY_ScalarType type; + int stride; + const unsigned char *indexbase; + int indexstride; + int numfaces; + PHY_ScalarType indicestype; + + //m_materialLookup = (int**)(btAlignedAlloc(sizeof(int*) * meshInterface->getNumSubParts(), 16)); + + for (int i = 0; i < meshInterface->getNumSubParts(); i++) + { + m_meshInterface->getLockedReadOnlyVertexIndexBase( + &vertexbase, + numverts, + type, + stride, + &indexbase, + indexstride, + numfaces, + indicestype, + i); + //m_materialLookup[i] = (int*)(btAlignedAlloc(sizeof(int) * numfaces * 2, 16)); + } + } + + virtual ~btMultimaterialTriangleMeshShape() + { + /* + for(int i = 0; i < m_meshInterface->getNumSubParts(); i++) + { + btAlignedFree(m_materialValues[i]); + m_materialLookup[i] = NULL; + } + btAlignedFree(m_materialValues); + m_materialLookup = NULL; +*/ + } + //debugging + virtual const char *getName() const { return "MULTIMATERIALTRIANGLEMESH"; } + + ///Obtains the material for a specific triangle + const btMaterial *getMaterialProperties(int partID, int triIndex); +}; + +#endif //BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h.i new file mode 100644 index 00000000..fb3f4240 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.cpp new file mode 100644 index 00000000..863ea6d6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.cpp @@ -0,0 +1,364 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btOptimizedBvh.h" +#include "btStridingMeshInterface.h" +#include "LinearMath/btAabbUtil2.h" +#include "LinearMath/btIDebugDraw.h" + +btOptimizedBvh::btOptimizedBvh() +{ +} + +btOptimizedBvh::~btOptimizedBvh() +{ +} + +void btOptimizedBvh::build(btStridingMeshInterface* triangles, bool useQuantizedAabbCompression, const btVector3& bvhAabbMin, const btVector3& bvhAabbMax) +{ + m_useQuantization = useQuantizedAabbCompression; + + // NodeArray triangleNodes; + + struct NodeTriangleCallback : public btInternalTriangleIndexCallback + { + NodeArray& m_triangleNodes; + + NodeTriangleCallback& operator=(NodeTriangleCallback& other) + { + m_triangleNodes.copyFromArray(other.m_triangleNodes); + return *this; + } + + NodeTriangleCallback(NodeArray& triangleNodes) + : m_triangleNodes(triangleNodes) + { + } + + virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex) + { + btOptimizedBvhNode node; + btVector3 aabbMin, aabbMax; + aabbMin.setValue(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + aabbMax.setValue(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + aabbMin.setMin(triangle[0]); + aabbMax.setMax(triangle[0]); + aabbMin.setMin(triangle[1]); + aabbMax.setMax(triangle[1]); + aabbMin.setMin(triangle[2]); + aabbMax.setMax(triangle[2]); + + //with quantization? + node.m_aabbMinOrg = aabbMin; + node.m_aabbMaxOrg = aabbMax; + + node.m_escapeIndex = -1; + + //for child nodes + node.m_subPart = partId; + node.m_triangleIndex = triangleIndex; + m_triangleNodes.push_back(node); + } + }; + struct QuantizedNodeTriangleCallback : public btInternalTriangleIndexCallback + { + QuantizedNodeArray& m_triangleNodes; + const btQuantizedBvh* m_optimizedTree; // for quantization + + QuantizedNodeTriangleCallback& operator=(QuantizedNodeTriangleCallback& other) + { + m_triangleNodes.copyFromArray(other.m_triangleNodes); + m_optimizedTree = other.m_optimizedTree; + return *this; + } + + QuantizedNodeTriangleCallback(QuantizedNodeArray& triangleNodes, const btQuantizedBvh* tree) + : m_triangleNodes(triangleNodes), m_optimizedTree(tree) + { + } + + virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex) + { + // The partId and triangle index must fit in the same (positive) integer + btAssert(partId < (1 << MAX_NUM_PARTS_IN_BITS)); + btAssert(triangleIndex < (1 << (31 - MAX_NUM_PARTS_IN_BITS))); + //negative indices are reserved for escapeIndex + btAssert(triangleIndex >= 0); + + btQuantizedBvhNode node; + btVector3 aabbMin, aabbMax; + aabbMin.setValue(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + aabbMax.setValue(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + aabbMin.setMin(triangle[0]); + aabbMax.setMax(triangle[0]); + aabbMin.setMin(triangle[1]); + aabbMax.setMax(triangle[1]); + aabbMin.setMin(triangle[2]); + aabbMax.setMax(triangle[2]); + + //PCK: add these checks for zero dimensions of aabb + const btScalar MIN_AABB_DIMENSION = btScalar(0.002); + const btScalar MIN_AABB_HALF_DIMENSION = btScalar(0.001); + if (aabbMax.x() - aabbMin.x() < MIN_AABB_DIMENSION) + { + aabbMax.setX(aabbMax.x() + MIN_AABB_HALF_DIMENSION); + aabbMin.setX(aabbMin.x() - MIN_AABB_HALF_DIMENSION); + } + if (aabbMax.y() - aabbMin.y() < MIN_AABB_DIMENSION) + { + aabbMax.setY(aabbMax.y() + MIN_AABB_HALF_DIMENSION); + aabbMin.setY(aabbMin.y() - MIN_AABB_HALF_DIMENSION); + } + if (aabbMax.z() - aabbMin.z() < MIN_AABB_DIMENSION) + { + aabbMax.setZ(aabbMax.z() + MIN_AABB_HALF_DIMENSION); + aabbMin.setZ(aabbMin.z() - MIN_AABB_HALF_DIMENSION); + } + + m_optimizedTree->quantize(&node.m_quantizedAabbMin[0], aabbMin, 0); + m_optimizedTree->quantize(&node.m_quantizedAabbMax[0], aabbMax, 1); + + node.m_escapeIndexOrTriangleIndex = (partId << (31 - MAX_NUM_PARTS_IN_BITS)) | triangleIndex; + + m_triangleNodes.push_back(node); + } + }; + + int numLeafNodes = 0; + + if (m_useQuantization) + { + //initialize quantization values + setQuantizationValues(bvhAabbMin, bvhAabbMax); + + QuantizedNodeTriangleCallback callback(m_quantizedLeafNodes, this); + + triangles->InternalProcessAllTriangles(&callback, m_bvhAabbMin, m_bvhAabbMax); + + //now we have an array of leafnodes in m_leafNodes + numLeafNodes = m_quantizedLeafNodes.size(); + + m_quantizedContiguousNodes.resize(2 * numLeafNodes); + } + else + { + NodeTriangleCallback callback(m_leafNodes); + + btVector3 aabbMin(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + btVector3 aabbMax(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + + triangles->InternalProcessAllTriangles(&callback, aabbMin, aabbMax); + + //now we have an array of leafnodes in m_leafNodes + numLeafNodes = m_leafNodes.size(); + + m_contiguousNodes.resize(2 * numLeafNodes); + } + + m_curNodeIndex = 0; + + buildTree(0, numLeafNodes); + + ///if the entire tree is small then subtree size, we need to create a header info for the tree + if (m_useQuantization && !m_SubtreeHeaders.size()) + { + btBvhSubtreeInfo& subtree = m_SubtreeHeaders.expand(); + subtree.setAabbFromQuantizeNode(m_quantizedContiguousNodes[0]); + subtree.m_rootNodeIndex = 0; + subtree.m_subtreeSize = m_quantizedContiguousNodes[0].isLeafNode() ? 1 : m_quantizedContiguousNodes[0].getEscapeIndex(); + } + + //PCK: update the copy of the size + m_subtreeHeaderCount = m_SubtreeHeaders.size(); + + //PCK: clear m_quantizedLeafNodes and m_leafNodes, they are temporary + m_quantizedLeafNodes.clear(); + m_leafNodes.clear(); +} + +void btOptimizedBvh::refit(btStridingMeshInterface* meshInterface, const btVector3& aabbMin, const btVector3& aabbMax) +{ + if (m_useQuantization) + { + setQuantizationValues(aabbMin, aabbMax); + + updateBvhNodes(meshInterface, 0, m_curNodeIndex, 0); + + ///now update all subtree headers + + int i; + for (i = 0; i < m_SubtreeHeaders.size(); i++) + { + btBvhSubtreeInfo& subtree = m_SubtreeHeaders[i]; + subtree.setAabbFromQuantizeNode(m_quantizedContiguousNodes[subtree.m_rootNodeIndex]); + } + } + else + { + } +} + +void btOptimizedBvh::refitPartial(btStridingMeshInterface* meshInterface, const btVector3& aabbMin, const btVector3& aabbMax) +{ + //incrementally initialize quantization values + btAssert(m_useQuantization); + + btAssert(aabbMin.getX() > m_bvhAabbMin.getX()); + btAssert(aabbMin.getY() > m_bvhAabbMin.getY()); + btAssert(aabbMin.getZ() > m_bvhAabbMin.getZ()); + + btAssert(aabbMax.getX() < m_bvhAabbMax.getX()); + btAssert(aabbMax.getY() < m_bvhAabbMax.getY()); + btAssert(aabbMax.getZ() < m_bvhAabbMax.getZ()); + + ///we should update all quantization values, using updateBvhNodes(meshInterface); + ///but we only update chunks that overlap the given aabb + + unsigned short quantizedQueryAabbMin[3]; + unsigned short quantizedQueryAabbMax[3]; + + quantize(&quantizedQueryAabbMin[0], aabbMin, 0); + quantize(&quantizedQueryAabbMax[0], aabbMax, 1); + + int i; + for (i = 0; i < this->m_SubtreeHeaders.size(); i++) + { + btBvhSubtreeInfo& subtree = m_SubtreeHeaders[i]; + + //PCK: unsigned instead of bool + unsigned overlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin, quantizedQueryAabbMax, subtree.m_quantizedAabbMin, subtree.m_quantizedAabbMax); + if (overlap != 0) + { + updateBvhNodes(meshInterface, subtree.m_rootNodeIndex, subtree.m_rootNodeIndex + subtree.m_subtreeSize, i); + + subtree.setAabbFromQuantizeNode(m_quantizedContiguousNodes[subtree.m_rootNodeIndex]); + } + } +} + +void btOptimizedBvh::updateBvhNodes(btStridingMeshInterface* meshInterface, int firstNode, int endNode, int index) +{ + (void)index; + + btAssert(m_useQuantization); + + int curNodeSubPart = -1; + + //get access info to trianglemesh data + const unsigned char* vertexbase = 0; + int numverts = 0; + PHY_ScalarType type = PHY_INTEGER; + int stride = 0; + const unsigned char* indexbase = 0; + int indexstride = 0; + int numfaces = 0; + PHY_ScalarType indicestype = PHY_INTEGER; + + btVector3 triangleVerts[3]; + btVector3 aabbMin, aabbMax; + const btVector3& meshScaling = meshInterface->getScaling(); + + int i; + for (i = endNode - 1; i >= firstNode; i--) + { + btQuantizedBvhNode& curNode = m_quantizedContiguousNodes[i]; + if (curNode.isLeafNode()) + { + //recalc aabb from triangle data + int nodeSubPart = curNode.getPartId(); + int nodeTriangleIndex = curNode.getTriangleIndex(); + if (nodeSubPart != curNodeSubPart) + { + if (curNodeSubPart >= 0) + meshInterface->unLockReadOnlyVertexBase(curNodeSubPart); + meshInterface->getLockedReadOnlyVertexIndexBase(&vertexbase, numverts, type, stride, &indexbase, indexstride, numfaces, indicestype, nodeSubPart); + + curNodeSubPart = nodeSubPart; + } + //triangles->getLockedReadOnlyVertexIndexBase(vertexBase,numVerts, + + unsigned int* gfxbase = (unsigned int*)(indexbase + nodeTriangleIndex * indexstride); + + for (int j = 2; j >= 0; j--) + { + int graphicsindex; + switch (indicestype) { + case PHY_INTEGER: graphicsindex = gfxbase[j]; break; + case PHY_SHORT: graphicsindex = ((unsigned short*)gfxbase)[j]; break; + case PHY_UCHAR: graphicsindex = ((unsigned char*)gfxbase)[j]; break; + default: btAssert(0); + } + if (type == PHY_FLOAT) + { + float* graphicsbase = (float*)(vertexbase + graphicsindex * stride); + triangleVerts[j] = btVector3( + graphicsbase[0] * meshScaling.getX(), + graphicsbase[1] * meshScaling.getY(), + graphicsbase[2] * meshScaling.getZ()); + } + else + { + double* graphicsbase = (double*)(vertexbase + graphicsindex * stride); + triangleVerts[j] = btVector3(btScalar(graphicsbase[0] * meshScaling.getX()), btScalar(graphicsbase[1] * meshScaling.getY()), btScalar(graphicsbase[2] * meshScaling.getZ())); + } + } + + aabbMin.setValue(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + aabbMax.setValue(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + aabbMin.setMin(triangleVerts[0]); + aabbMax.setMax(triangleVerts[0]); + aabbMin.setMin(triangleVerts[1]); + aabbMax.setMax(triangleVerts[1]); + aabbMin.setMin(triangleVerts[2]); + aabbMax.setMax(triangleVerts[2]); + + quantize(&curNode.m_quantizedAabbMin[0], aabbMin, 0); + quantize(&curNode.m_quantizedAabbMax[0], aabbMax, 1); + } + else + { + //combine aabb from both children + + btQuantizedBvhNode* leftChildNode = &m_quantizedContiguousNodes[i + 1]; + + btQuantizedBvhNode* rightChildNode = leftChildNode->isLeafNode() ? &m_quantizedContiguousNodes[i + 2] : &m_quantizedContiguousNodes[i + 1 + leftChildNode->getEscapeIndex()]; + + { + for (int i = 0; i < 3; i++) + { + curNode.m_quantizedAabbMin[i] = leftChildNode->m_quantizedAabbMin[i]; + if (curNode.m_quantizedAabbMin[i] > rightChildNode->m_quantizedAabbMin[i]) + curNode.m_quantizedAabbMin[i] = rightChildNode->m_quantizedAabbMin[i]; + + curNode.m_quantizedAabbMax[i] = leftChildNode->m_quantizedAabbMax[i]; + if (curNode.m_quantizedAabbMax[i] < rightChildNode->m_quantizedAabbMax[i]) + curNode.m_quantizedAabbMax[i] = rightChildNode->m_quantizedAabbMax[i]; + } + } + } + } + + if (curNodeSubPart >= 0) + meshInterface->unLockReadOnlyVertexBase(curNodeSubPart); +} + +///deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' +btOptimizedBvh* btOptimizedBvh::deSerializeInPlace(void* i_alignedDataBuffer, unsigned int i_dataBufferSize, bool i_swapEndian) +{ + btQuantizedBvh* bvh = btQuantizedBvh::deSerializeInPlace(i_alignedDataBuffer, i_dataBufferSize, i_swapEndian); + + //we don't add additional data so just do a static upcast + return static_cast(bvh); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.cpp.i new file mode 100644 index 00000000..69bd0349 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btOptimizedBvh.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btOptimizedBvh.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btOptimizedBvh.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.h new file mode 100644 index 00000000..22f131c8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.h @@ -0,0 +1,56 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///Contains contributions from Disney Studio's + +#ifndef BT_OPTIMIZED_BVH_H +#define BT_OPTIMIZED_BVH_H + +#include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" + +class btStridingMeshInterface; + +///The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes, through the btStridingMeshInterface. +ATTRIBUTE_ALIGNED16(class) +btOptimizedBvh : public btQuantizedBvh +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + +protected: +public: + btOptimizedBvh(); + + virtual ~btOptimizedBvh(); + + void build(btStridingMeshInterface * triangles, bool useQuantizedAabbCompression, const btVector3& bvhAabbMin, const btVector3& bvhAabbMax); + + void refit(btStridingMeshInterface * triangles, const btVector3& aabbMin, const btVector3& aabbMax); + + void refitPartial(btStridingMeshInterface * triangles, const btVector3& aabbMin, const btVector3& aabbMax); + + void updateBvhNodes(btStridingMeshInterface * meshInterface, int firstNode, int endNode, int index); + + /// Data buffer MUST be 16 byte aligned + virtual bool serializeInPlace(void* o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const + { + return btQuantizedBvh::serialize(o_alignedDataBuffer, i_dataBufferSize, i_swapEndian); + } + + ///deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' + static btOptimizedBvh* deSerializeInPlace(void* i_alignedDataBuffer, unsigned int i_dataBufferSize, bool i_swapEndian); +}; + +#endif //BT_OPTIMIZED_BVH_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.h.i new file mode 100644 index 00000000..f450d158 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btOptimizedBvh.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btOptimizedBvh.h ---------------- + +%include "BulletCollision/CollisionShapes/btOptimizedBvh.h" + +%{ +#include "BulletCollision/CollisionShapes/btOptimizedBvh.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp new file mode 100644 index 00000000..521ecfc7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp @@ -0,0 +1,549 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +#if defined(_WIN32) || defined(__i386__) +#define BT_USE_SSE_IN_API +#endif + +#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" +#include "btConvexPolyhedron.h" +#include "LinearMath/btConvexHullComputer.h" +#include +#include "LinearMath/btGeometryUtil.h" +#include "LinearMath/btGrahamScan2dConvexHull.h" + +btPolyhedralConvexShape::btPolyhedralConvexShape() : btConvexInternalShape(), + m_polyhedron(0) +{ +} + +btPolyhedralConvexShape::~btPolyhedralConvexShape() +{ + if (m_polyhedron) + { + m_polyhedron->~btConvexPolyhedron(); + btAlignedFree(m_polyhedron); + } +} + +void btPolyhedralConvexShape::setPolyhedralFeatures(btConvexPolyhedron& polyhedron) +{ + if (m_polyhedron) + { + *m_polyhedron = polyhedron; + } + else + { + void* mem = btAlignedAlloc(sizeof(btConvexPolyhedron), 16); + m_polyhedron = new (mem) btConvexPolyhedron(polyhedron); + } +} + +bool btPolyhedralConvexShape::initializePolyhedralFeatures(int shiftVerticesByMargin) +{ + if (m_polyhedron) + { + m_polyhedron->~btConvexPolyhedron(); + btAlignedFree(m_polyhedron); + } + + void* mem = btAlignedAlloc(sizeof(btConvexPolyhedron), 16); + m_polyhedron = new (mem) btConvexPolyhedron; + + btAlignedObjectArray orgVertices; + + for (int i = 0; i < getNumVertices(); i++) + { + btVector3& newVertex = orgVertices.expand(); + getVertex(i, newVertex); + } + + btConvexHullComputer conv; + + if (shiftVerticesByMargin) + { + btAlignedObjectArray planeEquations; + btGeometryUtil::getPlaneEquationsFromVertices(orgVertices, planeEquations); + + btAlignedObjectArray shiftedPlaneEquations; + for (int p = 0; p < planeEquations.size(); p++) + { + btVector3 plane = planeEquations[p]; + // btScalar margin = getMargin(); + plane[3] -= getMargin(); + shiftedPlaneEquations.push_back(plane); + } + + btAlignedObjectArray tmpVertices; + + btGeometryUtil::getVerticesFromPlaneEquations(shiftedPlaneEquations, tmpVertices); + + conv.compute(&tmpVertices[0].getX(), sizeof(btVector3), tmpVertices.size(), 0.f, 0.f); + } + else + { + conv.compute(&orgVertices[0].getX(), sizeof(btVector3), orgVertices.size(), 0.f, 0.f); + } + +#ifndef BT_RECONSTRUCT_FACES + + int numVertices = conv.vertices.size(); + m_polyhedron->m_vertices.resize(numVertices); + for (int p = 0; p < numVertices; p++) + { + m_polyhedron->m_vertices[p] = conv.vertices[p]; + } + + int v0, v1; + for (int j = 0; j < conv.faces.size(); j++) + { + btVector3 edges[3]; + int numEdges = 0; + btFace combinedFace; + const btConvexHullComputer::Edge* edge = &conv.edges[conv.faces[j]]; + v0 = edge->getSourceVertex(); + int prevVertex = v0; + combinedFace.m_indices.push_back(v0); + v1 = edge->getTargetVertex(); + while (v1 != v0) + { + btVector3 wa = conv.vertices[prevVertex]; + btVector3 wb = conv.vertices[v1]; + btVector3 newEdge = wb - wa; + newEdge.normalize(); + if (numEdges < 2) + edges[numEdges++] = newEdge; + + //face->addIndex(v1); + combinedFace.m_indices.push_back(v1); + edge = edge->getNextEdgeOfFace(); + prevVertex = v1; + int v01 = edge->getSourceVertex(); + v1 = edge->getTargetVertex(); + } + + btAssert(combinedFace.m_indices.size() > 2); + + btVector3 faceNormal = edges[0].cross(edges[1]); + faceNormal.normalize(); + + btScalar planeEq = 1e30f; + + for (int v = 0; v < combinedFace.m_indices.size(); v++) + { + btScalar eq = m_polyhedron->m_vertices[combinedFace.m_indices[v]].dot(faceNormal); + if (planeEq > eq) + { + planeEq = eq; + } + } + combinedFace.m_plane[0] = faceNormal.getX(); + combinedFace.m_plane[1] = faceNormal.getY(); + combinedFace.m_plane[2] = faceNormal.getZ(); + combinedFace.m_plane[3] = -planeEq; + + m_polyhedron->m_faces.push_back(combinedFace); + } + +#else //BT_RECONSTRUCT_FACES + + btAlignedObjectArray faceNormals; + int numFaces = conv.faces.size(); + faceNormals.resize(numFaces); + btConvexHullComputer* convexUtil = &conv; + + btAlignedObjectArray tmpFaces; + tmpFaces.resize(numFaces); + + int numVertices = convexUtil->vertices.size(); + m_polyhedron->m_vertices.resize(numVertices); + for (int p = 0; p < numVertices; p++) + { + m_polyhedron->m_vertices[p] = convexUtil->vertices[p]; + } + + for (int i = 0; i < numFaces; i++) + { + int face = convexUtil->faces[i]; + //printf("face=%d\n",face); + const btConvexHullComputer::Edge* firstEdge = &convexUtil->edges[face]; + const btConvexHullComputer::Edge* edge = firstEdge; + + btVector3 edges[3]; + int numEdges = 0; + //compute face normals + + do + { + int src = edge->getSourceVertex(); + tmpFaces[i].m_indices.push_back(src); + int targ = edge->getTargetVertex(); + btVector3 wa = convexUtil->vertices[src]; + + btVector3 wb = convexUtil->vertices[targ]; + btVector3 newEdge = wb - wa; + newEdge.normalize(); + if (numEdges < 2) + edges[numEdges++] = newEdge; + + edge = edge->getNextEdgeOfFace(); + } while (edge != firstEdge); + + btScalar planeEq = 1e30f; + + if (numEdges == 2) + { + faceNormals[i] = edges[0].cross(edges[1]); + faceNormals[i].normalize(); + tmpFaces[i].m_plane[0] = faceNormals[i].getX(); + tmpFaces[i].m_plane[1] = faceNormals[i].getY(); + tmpFaces[i].m_plane[2] = faceNormals[i].getZ(); + tmpFaces[i].m_plane[3] = planeEq; + } + else + { + btAssert(0); //degenerate? + faceNormals[i].setZero(); + } + + for (int v = 0; v < tmpFaces[i].m_indices.size(); v++) + { + btScalar eq = m_polyhedron->m_vertices[tmpFaces[i].m_indices[v]].dot(faceNormals[i]); + if (planeEq > eq) + { + planeEq = eq; + } + } + tmpFaces[i].m_plane[3] = -planeEq; + } + + //merge coplanar faces and copy them to m_polyhedron + + btScalar faceWeldThreshold = 0.999f; + btAlignedObjectArray todoFaces; + for (int i = 0; i < tmpFaces.size(); i++) + todoFaces.push_back(i); + + while (todoFaces.size()) + { + btAlignedObjectArray coplanarFaceGroup; + int refFace = todoFaces[todoFaces.size() - 1]; + + coplanarFaceGroup.push_back(refFace); + btFace& faceA = tmpFaces[refFace]; + todoFaces.pop_back(); + + btVector3 faceNormalA(faceA.m_plane[0], faceA.m_plane[1], faceA.m_plane[2]); + for (int j = todoFaces.size() - 1; j >= 0; j--) + { + int i = todoFaces[j]; + btFace& faceB = tmpFaces[i]; + btVector3 faceNormalB(faceB.m_plane[0], faceB.m_plane[1], faceB.m_plane[2]); + if (faceNormalA.dot(faceNormalB) > faceWeldThreshold) + { + coplanarFaceGroup.push_back(i); + todoFaces.remove(i); + } + } + + bool did_merge = false; + if (coplanarFaceGroup.size() > 1) + { + //do the merge: use Graham Scan 2d convex hull + + btAlignedObjectArray orgpoints; + btVector3 averageFaceNormal(0, 0, 0); + + for (int i = 0; i < coplanarFaceGroup.size(); i++) + { + // m_polyhedron->m_faces.push_back(tmpFaces[coplanarFaceGroup[i]]); + + btFace& face = tmpFaces[coplanarFaceGroup[i]]; + btVector3 faceNormal(face.m_plane[0], face.m_plane[1], face.m_plane[2]); + averageFaceNormal += faceNormal; + for (int f = 0; f < face.m_indices.size(); f++) + { + int orgIndex = face.m_indices[f]; + btVector3 pt = m_polyhedron->m_vertices[orgIndex]; + + bool found = false; + + for (int i = 0; i < orgpoints.size(); i++) + { + //if ((orgpoints[i].m_orgIndex == orgIndex) || ((rotatedPt-orgpoints[i]).length2()<0.0001)) + if (orgpoints[i].m_orgIndex == orgIndex) + { + found = true; + break; + } + } + if (!found) + orgpoints.push_back(GrahamVector3(pt, orgIndex)); + } + } + + btFace combinedFace; + for (int i = 0; i < 4; i++) + combinedFace.m_plane[i] = tmpFaces[coplanarFaceGroup[0]].m_plane[i]; + + btAlignedObjectArray hull; + + averageFaceNormal.normalize(); + GrahamScanConvexHull2D(orgpoints, hull, averageFaceNormal); + + for (int i = 0; i < hull.size(); i++) + { + combinedFace.m_indices.push_back(hull[i].m_orgIndex); + for (int k = 0; k < orgpoints.size(); k++) + { + if (orgpoints[k].m_orgIndex == hull[i].m_orgIndex) + { + orgpoints[k].m_orgIndex = -1; // invalidate... + break; + } + } + } + + // are there rejected vertices? + bool reject_merge = false; + + for (int i = 0; i < orgpoints.size(); i++) + { + if (orgpoints[i].m_orgIndex == -1) + continue; // this is in the hull... + // this vertex is rejected -- is anybody else using this vertex? + for (int j = 0; j < tmpFaces.size(); j++) + { + btFace& face = tmpFaces[j]; + // is this a face of the current coplanar group? + bool is_in_current_group = false; + for (int k = 0; k < coplanarFaceGroup.size(); k++) + { + if (coplanarFaceGroup[k] == j) + { + is_in_current_group = true; + break; + } + } + if (is_in_current_group) // ignore this face... + continue; + // does this face use this rejected vertex? + for (int v = 0; v < face.m_indices.size(); v++) + { + if (face.m_indices[v] == orgpoints[i].m_orgIndex) + { + // this rejected vertex is used in another face -- reject merge + reject_merge = true; + break; + } + } + if (reject_merge) + break; + } + if (reject_merge) + break; + } + + if (!reject_merge) + { + // do this merge! + did_merge = true; + m_polyhedron->m_faces.push_back(combinedFace); + } + } + if (!did_merge) + { + for (int i = 0; i < coplanarFaceGroup.size(); i++) + { + btFace face = tmpFaces[coplanarFaceGroup[i]]; + m_polyhedron->m_faces.push_back(face); + } + } + } + +#endif //BT_RECONSTRUCT_FACES + + m_polyhedron->initialize(); + + return true; +} + +#ifndef MIN +#define MIN(_a, _b) ((_a) < (_b) ? (_a) : (_b)) +#endif + +btVector3 btPolyhedralConvexShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0) const +{ + btVector3 supVec(0, 0, 0); +#ifndef __SPU__ + int i; + btScalar maxDot(btScalar(-BT_LARGE_FLOAT)); + + btVector3 vec = vec0; + btScalar lenSqr = vec.length2(); + if (lenSqr < btScalar(0.0001)) + { + vec.setValue(1, 0, 0); + } + else + { + btScalar rlen = btScalar(1.) / btSqrt(lenSqr); + vec *= rlen; + } + + btVector3 vtx; + btScalar newDot; + + for (int k = 0; k < getNumVertices(); k += 128) + { + btVector3 temp[128]; + int inner_count = MIN(getNumVertices() - k, 128); + for (i = 0; i < inner_count; i++) + getVertex(i, temp[i]); + i = (int)vec.maxDot(temp, inner_count, newDot); + if (newDot > maxDot) + { + maxDot = newDot; + supVec = temp[i]; + } + } + +#endif //__SPU__ + return supVec; +} + +void btPolyhedralConvexShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ +#ifndef __SPU__ + int i; + + btVector3 vtx; + btScalar newDot; + + for (i = 0; i < numVectors; i++) + { + supportVerticesOut[i][3] = btScalar(-BT_LARGE_FLOAT); + } + + for (int j = 0; j < numVectors; j++) + { + const btVector3& vec = vectors[j]; + + for (int k = 0; k < getNumVertices(); k += 128) + { + btVector3 temp[128]; + int inner_count = MIN(getNumVertices() - k, 128); + for (i = 0; i < inner_count; i++) + getVertex(i, temp[i]); + i = (int)vec.maxDot(temp, inner_count, newDot); + if (newDot > supportVerticesOut[j][3]) + { + supportVerticesOut[j] = temp[i]; + supportVerticesOut[j][3] = newDot; + } + } + } + +#endif //__SPU__ +} + +void btPolyhedralConvexShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ +#ifndef __SPU__ + //not yet, return box inertia + + btScalar margin = getMargin(); + + btTransform ident; + ident.setIdentity(); + btVector3 aabbMin, aabbMax; + getAabb(ident, aabbMin, aabbMax); + btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5); + + btScalar lx = btScalar(2.) * (halfExtents.x() + margin); + btScalar ly = btScalar(2.) * (halfExtents.y() + margin); + btScalar lz = btScalar(2.) * (halfExtents.z() + margin); + const btScalar x2 = lx * lx; + const btScalar y2 = ly * ly; + const btScalar z2 = lz * lz; + const btScalar scaledmass = mass * btScalar(0.08333333); + + inertia = scaledmass * (btVector3(y2 + z2, x2 + z2, x2 + y2)); +#endif //__SPU__ +} + +void btPolyhedralConvexAabbCachingShape::setLocalScaling(const btVector3& scaling) +{ + btConvexInternalShape::setLocalScaling(scaling); + recalcLocalAabb(); +} + +btPolyhedralConvexAabbCachingShape::btPolyhedralConvexAabbCachingShape() + : btPolyhedralConvexShape(), + m_localAabbMin(1, 1, 1), + m_localAabbMax(-1, -1, -1), + m_isLocalAabbValid(false) +{ +} + +void btPolyhedralConvexAabbCachingShape::getAabb(const btTransform& trans, btVector3& aabbMin, btVector3& aabbMax) const +{ + getNonvirtualAabb(trans, aabbMin, aabbMax, getMargin()); +} + +void btPolyhedralConvexAabbCachingShape::recalcLocalAabb() +{ + m_isLocalAabbValid = true; + +#if 1 + static const btVector3 _directions[] = + { + btVector3(1., 0., 0.), + btVector3(0., 1., 0.), + btVector3(0., 0., 1.), + btVector3(-1., 0., 0.), + btVector3(0., -1., 0.), + btVector3(0., 0., -1.)}; + + btVector3 _supporting[] = + { + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.)}; + + batchedUnitVectorGetSupportingVertexWithoutMargin(_directions, _supporting, 6); + + for (int i = 0; i < 3; ++i) + { + m_localAabbMax[i] = _supporting[i][i] + m_collisionMargin; + m_localAabbMin[i] = _supporting[i + 3][i] - m_collisionMargin; + } + +#else + + for (int i = 0; i < 3; i++) + { + btVector3 vec(btScalar(0.), btScalar(0.), btScalar(0.)); + vec[i] = btScalar(1.); + btVector3 tmp = localGetSupportingVertex(vec); + m_localAabbMax[i] = tmp[i]; + vec[i] = btScalar(-1.); + tmp = localGetSupportingVertex(vec); + m_localAabbMin[i] = tmp[i]; + } +#endif +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp.i new file mode 100644 index 00000000..05767a4c --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h new file mode 100644 index 00000000..b3ffab7a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h @@ -0,0 +1,106 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_POLYHEDRAL_CONVEX_SHAPE_H +#define BT_POLYHEDRAL_CONVEX_SHAPE_H + +#include "LinearMath/btMatrix3x3.h" +#include "btConvexInternalShape.h" +class btConvexPolyhedron; + +///The btPolyhedralConvexShape is an internal interface class for polyhedral convex shapes. +ATTRIBUTE_ALIGNED16(class) +btPolyhedralConvexShape : public btConvexInternalShape +{ +protected: + btConvexPolyhedron* m_polyhedron; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btPolyhedralConvexShape(); + + virtual ~btPolyhedralConvexShape(); + + ///optional method mainly used to generate multiple contact points by clipping polyhedral features (faces/edges) + ///experimental/work-in-progress + virtual bool initializePolyhedralFeatures(int shiftVerticesByMargin = 0); + + virtual void setPolyhedralFeatures(btConvexPolyhedron & polyhedron); + + const btConvexPolyhedron* getConvexPolyhedron() const + { + return m_polyhedron; + } + + //brute force implementations + + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + virtual int getNumVertices() const = 0; + virtual int getNumEdges() const = 0; + virtual void getEdge(int i, btVector3& pa, btVector3& pb) const = 0; + virtual void getVertex(int i, btVector3& vtx) const = 0; + virtual int getNumPlanes() const = 0; + virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const = 0; + // virtual int getIndex(int i) const = 0 ; + + virtual bool isInside(const btVector3& pt, btScalar tolerance) const = 0; +}; + +///The btPolyhedralConvexAabbCachingShape adds aabb caching to the btPolyhedralConvexShape +class btPolyhedralConvexAabbCachingShape : public btPolyhedralConvexShape +{ + btVector3 m_localAabbMin; + btVector3 m_localAabbMax; + bool m_isLocalAabbValid; + +protected: + void setCachedLocalAabb(const btVector3& aabbMin, const btVector3& aabbMax) + { + m_isLocalAabbValid = true; + m_localAabbMin = aabbMin; + m_localAabbMax = aabbMax; + } + + inline void getCachedLocalAabb(btVector3& aabbMin, btVector3& aabbMax) const + { + btAssert(m_isLocalAabbValid); + aabbMin = m_localAabbMin; + aabbMax = m_localAabbMax; + } + +protected: + btPolyhedralConvexAabbCachingShape(); + +public: + inline void getNonvirtualAabb(const btTransform& trans, btVector3& aabbMin, btVector3& aabbMax, btScalar margin) const + { + //lazy evaluation of local aabb + btAssert(m_isLocalAabbValid); + btTransformAabb(m_localAabbMin, m_localAabbMax, margin, trans, aabbMin, aabbMax); + } + + virtual void setLocalScaling(const btVector3& scaling); + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + void recalcLocalAabb(); +}; + +#endif //BT_POLYHEDRAL_CONVEX_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h.i new file mode 100644 index 00000000..078d9427 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btPolyhedralConvexShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp new file mode 100644 index 00000000..f4273199 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp @@ -0,0 +1,115 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btScaledBvhTriangleMeshShape.h" + +btScaledBvhTriangleMeshShape::btScaledBvhTriangleMeshShape(btBvhTriangleMeshShape* childShape, const btVector3& localScaling) + : m_localScaling(localScaling), m_bvhTriMeshShape(childShape) +{ + m_shapeType = SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE; +} + +btScaledBvhTriangleMeshShape::~btScaledBvhTriangleMeshShape() +{ +} + +class btScaledTriangleCallback : public btTriangleCallback +{ + btTriangleCallback* m_originalCallback; + + btVector3 m_localScaling; + +public: + btScaledTriangleCallback(btTriangleCallback* originalCallback, const btVector3& localScaling) + : m_originalCallback(originalCallback), + m_localScaling(localScaling) + { + } + + virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex) + { + btVector3 newTriangle[3]; + newTriangle[0] = triangle[0] * m_localScaling; + newTriangle[1] = triangle[1] * m_localScaling; + newTriangle[2] = triangle[2] * m_localScaling; + m_originalCallback->processTriangle(&newTriangle[0], partId, triangleIndex); + } +}; + +void btScaledBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const +{ + btScaledTriangleCallback scaledCallback(callback, m_localScaling); + + btVector3 invLocalScaling(1.f / m_localScaling.getX(), 1.f / m_localScaling.getY(), 1.f / m_localScaling.getZ()); + btVector3 scaledAabbMin, scaledAabbMax; + + ///support negative scaling + scaledAabbMin[0] = m_localScaling.getX() >= 0. ? aabbMin[0] * invLocalScaling[0] : aabbMax[0] * invLocalScaling[0]; + scaledAabbMin[1] = m_localScaling.getY() >= 0. ? aabbMin[1] * invLocalScaling[1] : aabbMax[1] * invLocalScaling[1]; + scaledAabbMin[2] = m_localScaling.getZ() >= 0. ? aabbMin[2] * invLocalScaling[2] : aabbMax[2] * invLocalScaling[2]; + scaledAabbMin[3] = 0.f; + + scaledAabbMax[0] = m_localScaling.getX() <= 0. ? aabbMin[0] * invLocalScaling[0] : aabbMax[0] * invLocalScaling[0]; + scaledAabbMax[1] = m_localScaling.getY() <= 0. ? aabbMin[1] * invLocalScaling[1] : aabbMax[1] * invLocalScaling[1]; + scaledAabbMax[2] = m_localScaling.getZ() <= 0. ? aabbMin[2] * invLocalScaling[2] : aabbMax[2] * invLocalScaling[2]; + scaledAabbMax[3] = 0.f; + + m_bvhTriMeshShape->processAllTriangles(&scaledCallback, scaledAabbMin, scaledAabbMax); +} + +void btScaledBvhTriangleMeshShape::getAabb(const btTransform& trans, btVector3& aabbMin, btVector3& aabbMax) const +{ + btVector3 localAabbMin = m_bvhTriMeshShape->getLocalAabbMin(); + btVector3 localAabbMax = m_bvhTriMeshShape->getLocalAabbMax(); + + btVector3 tmpLocalAabbMin = localAabbMin * m_localScaling; + btVector3 tmpLocalAabbMax = localAabbMax * m_localScaling; + + localAabbMin[0] = (m_localScaling.getX() >= 0.) ? tmpLocalAabbMin[0] : tmpLocalAabbMax[0]; + localAabbMin[1] = (m_localScaling.getY() >= 0.) ? tmpLocalAabbMin[1] : tmpLocalAabbMax[1]; + localAabbMin[2] = (m_localScaling.getZ() >= 0.) ? tmpLocalAabbMin[2] : tmpLocalAabbMax[2]; + localAabbMax[0] = (m_localScaling.getX() <= 0.) ? tmpLocalAabbMin[0] : tmpLocalAabbMax[0]; + localAabbMax[1] = (m_localScaling.getY() <= 0.) ? tmpLocalAabbMin[1] : tmpLocalAabbMax[1]; + localAabbMax[2] = (m_localScaling.getZ() <= 0.) ? tmpLocalAabbMin[2] : tmpLocalAabbMax[2]; + + btVector3 localHalfExtents = btScalar(0.5) * (localAabbMax - localAabbMin); + btScalar margin = m_bvhTriMeshShape->getMargin(); + localHalfExtents += btVector3(margin, margin, margin); + btVector3 localCenter = btScalar(0.5) * (localAabbMax + localAabbMin); + + btMatrix3x3 abs_b = trans.getBasis().absolute(); + + btVector3 center = trans(localCenter); + + btVector3 extent = localHalfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]); + aabbMin = center - extent; + aabbMax = center + extent; +} + +void btScaledBvhTriangleMeshShape::setLocalScaling(const btVector3& scaling) +{ + m_localScaling = scaling; +} + +const btVector3& btScaledBvhTriangleMeshShape::getLocalScaling() const +{ + return m_localScaling; +} + +void btScaledBvhTriangleMeshShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + ///don't make this a movable object! + // btAssert(0); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp.i new file mode 100644 index 00000000..737aa2c7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h new file mode 100644 index 00000000..4d6feb61 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h @@ -0,0 +1,86 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H +#define BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H + +#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" + +///The btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMeshShape. +///Note that each btBvhTriangleMeshShape still can have its own local scaling, independent from this btScaledBvhTriangleMeshShape 'localScaling' +ATTRIBUTE_ALIGNED16(class) +btScaledBvhTriangleMeshShape : public btConcaveShape +{ + btVector3 m_localScaling; + + btBvhTriangleMeshShape* m_bvhTriMeshShape; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btScaledBvhTriangleMeshShape(btBvhTriangleMeshShape * childShape, const btVector3& localScaling); + + virtual ~btScaledBvhTriangleMeshShape(); + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + virtual void setLocalScaling(const btVector3& scaling); + virtual const btVector3& getLocalScaling() const; + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const; + + btBvhTriangleMeshShape* getChildShape() + { + return m_bvhTriMeshShape; + } + + const btBvhTriangleMeshShape* getChildShape() const + { + return m_bvhTriMeshShape; + } + + //debugging + virtual const char* getName() const { return "SCALEDBVHTRIANGLEMESH"; } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btScaledTriangleMeshShapeData +{ + btTriangleMeshShapeData m_trimeshShapeData; + + btVector3FloatData m_localScaling; +}; + +SIMD_FORCE_INLINE int btScaledBvhTriangleMeshShape::calculateSerializeBufferSize() const +{ + return sizeof(btScaledTriangleMeshShapeData); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btScaledBvhTriangleMeshShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btScaledTriangleMeshShapeData* scaledMeshData = (btScaledTriangleMeshShapeData*)dataBuffer; + m_bvhTriMeshShape->serialize(&scaledMeshData->m_trimeshShapeData, serializer); + scaledMeshData->m_trimeshShapeData.m_collisionShapeData.m_shapeType = SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE; + m_localScaling.serializeFloat(scaledMeshData->m_localScaling); + return "btScaledTriangleMeshShapeData"; +} + +#endif //BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h.i new file mode 100644 index 00000000..9f3b35b5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.cpp new file mode 100644 index 00000000..23c95ad3 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.cpp @@ -0,0 +1,95 @@ +#include "btSdfCollisionShape.h" +#include "btMiniSDF.h" +#include "LinearMath/btAabbUtil2.h" + +ATTRIBUTE_ALIGNED16(struct) +btSdfCollisionShapeInternalData +{ + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btVector3 m_localScaling; + btScalar m_margin; + btMiniSDF m_sdf; + + btSdfCollisionShapeInternalData() + : m_localScaling(1, 1, 1), + m_margin(0) + { + } +}; + +bool btSdfCollisionShape::initializeSDF(const char* sdfData, int sizeInBytes) +{ + bool valid = m_data->m_sdf.load(sdfData, sizeInBytes); + return valid; +} +btSdfCollisionShape::btSdfCollisionShape() +{ + m_shapeType = SDF_SHAPE_PROXYTYPE; + m_data = new btSdfCollisionShapeInternalData(); + + //"E:/develop/bullet3/data/toys/ground_hole64_64_8.cdf");//ground_cube.cdf"); + /*unsigned int field_id=0; + Eigen::Vector3d x (1,10,1); + Eigen::Vector3d gradient; + double dist = m_data->m_sdf.interpolate(field_id, x, &gradient); + printf("dist=%g\n", dist); + */ +} +btSdfCollisionShape::~btSdfCollisionShape() +{ + delete m_data; +} + +void btSdfCollisionShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + btAssert(m_data->m_sdf.isValid()); + btVector3 localAabbMin = m_data->m_sdf.m_domain.m_min; + btVector3 localAabbMax = m_data->m_sdf.m_domain.m_max; + btScalar margin(0); + btTransformAabb(localAabbMin, localAabbMax, margin, t, aabbMin, aabbMax); +} + +void btSdfCollisionShape::setLocalScaling(const btVector3& scaling) +{ + m_data->m_localScaling = scaling; +} +const btVector3& btSdfCollisionShape::getLocalScaling() const +{ + return m_data->m_localScaling; +} +void btSdfCollisionShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + inertia.setValue(0, 0, 0); +} +const char* btSdfCollisionShape::getName() const +{ + return "btSdfCollisionShape"; +} +void btSdfCollisionShape::setMargin(btScalar margin) +{ + m_data->m_margin = margin; +} +btScalar btSdfCollisionShape::getMargin() const +{ + return m_data->m_margin; +} + +void btSdfCollisionShape::processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const +{ + //not yet +} + +bool btSdfCollisionShape::queryPoint(const btVector3& ptInSDF, btScalar& distOut, btVector3& normal) +{ + int field = 0; + btVector3 grad; + double dist; + bool hasResult = m_data->m_sdf.interpolate(field, dist, ptInSDF, &grad); + if (hasResult) + { + normal.setValue(grad[0], grad[1], grad[2]); + distOut = dist; + } + return hasResult; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.cpp.i new file mode 100644 index 00000000..25c55a19 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btSdfCollisionShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btSdfCollisionShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btSdfCollisionShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.h new file mode 100644 index 00000000..3989d624 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.h @@ -0,0 +1,29 @@ +#ifndef BT_SDF_COLLISION_SHAPE_H +#define BT_SDF_COLLISION_SHAPE_H + +#include "btConcaveShape.h" + +class btSdfCollisionShape : public btConcaveShape +{ + struct btSdfCollisionShapeInternalData* m_data; + +public: + btSdfCollisionShape(); + virtual ~btSdfCollisionShape(); + + bool initializeSDF(const char* sdfData, int sizeInBytes); + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + virtual void setLocalScaling(const btVector3& scaling); + virtual const btVector3& getLocalScaling() const; + virtual void calculateLocalInertia(btScalar mass, btVector3& inertia) const; + virtual const char* getName() const; + virtual void setMargin(btScalar margin); + virtual btScalar getMargin() const; + + virtual void processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const; + + bool queryPoint(const btVector3& ptInSDF, btScalar& distOut, btVector3& normal); +}; + +#endif //BT_SDF_COLLISION_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.h.i new file mode 100644 index 00000000..f9176cfa --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSdfCollisionShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btSdfCollisionShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btSdfCollisionShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btSdfCollisionShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.cpp new file mode 100644 index 00000000..a2c490fa --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.cpp @@ -0,0 +1,421 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +//btShapeHull was implemented by John McCutchan. + +#include "btShapeHull.h" +#include "LinearMath/btConvexHull.h" + +#define NUM_UNITSPHERE_POINTS 42 +#define NUM_UNITSPHERE_POINTS_HIGHRES 256 + +btShapeHull::btShapeHull(const btConvexShape* shape) +{ + m_shape = shape; + m_vertices.clear(); + m_indices.clear(); + m_numIndices = 0; +} + +btShapeHull::~btShapeHull() +{ + m_indices.clear(); + m_vertices.clear(); +} + +bool btShapeHull::buildHull(btScalar /*margin*/, int highres) +{ + + int numSampleDirections = highres ? NUM_UNITSPHERE_POINTS_HIGHRES : NUM_UNITSPHERE_POINTS; + btVector3 supportPoints[NUM_UNITSPHERE_POINTS_HIGHRES + MAX_PREFERRED_PENETRATION_DIRECTIONS * 2]; + int i; + for (i = 0; i < numSampleDirections; i++) + { + supportPoints[i] = m_shape->localGetSupportingVertex(getUnitSpherePoints(highres)[i]); + } + + int numPDA = m_shape->getNumPreferredPenetrationDirections(); + if (numPDA) + { + for (int s = 0; s < numPDA; s++) + { + btVector3 norm; + m_shape->getPreferredPenetrationDirection(s, norm); + supportPoints[i++] = m_shape->localGetSupportingVertex(norm); + numSampleDirections++; + } + } + HullDesc hd; + hd.mFlags = QF_TRIANGLES; + hd.mVcount = static_cast(numSampleDirections); + +#ifdef BT_USE_DOUBLE_PRECISION + hd.mVertices = &supportPoints[0]; + hd.mVertexStride = sizeof(btVector3); +#else + hd.mVertices = &supportPoints[0]; + hd.mVertexStride = sizeof(btVector3); +#endif + + HullLibrary hl; + HullResult hr; + if (hl.CreateConvexHull(hd, hr) == QE_FAIL) + { + return false; + } + + m_vertices.resize(static_cast(hr.mNumOutputVertices)); + + for (i = 0; i < static_cast(hr.mNumOutputVertices); i++) + { + m_vertices[i] = hr.m_OutputVertices[i]; + } + m_numIndices = hr.mNumIndices; + m_indices.resize(static_cast(m_numIndices)); + for (i = 0; i < static_cast(m_numIndices); i++) + { + m_indices[i] = hr.m_Indices[i]; + } + + // free temporary hull result that we just copied + hl.ReleaseResult(hr); + + return true; +} + +int btShapeHull::numTriangles() const +{ + return static_cast(m_numIndices / 3); +} + +int btShapeHull::numVertices() const +{ + return m_vertices.size(); +} + +int btShapeHull::numIndices() const +{ + return static_cast(m_numIndices); +} + +btVector3* btShapeHull::getUnitSpherePoints(int highres) +{ + static btVector3 sUnitSpherePointsHighres[NUM_UNITSPHERE_POINTS_HIGHRES + MAX_PREFERRED_PENETRATION_DIRECTIONS * 2] = + { + btVector3(btScalar(0.997604), btScalar(0.067004), btScalar(0.017144)), + btVector3(btScalar(0.984139), btScalar(-0.086784), btScalar(-0.154427)), + btVector3(btScalar(0.971065), btScalar(0.124164), btScalar(-0.203224)), + btVector3(btScalar(0.955844), btScalar(0.291173), btScalar(-0.037704)), + btVector3(btScalar(0.957405), btScalar(0.212238), btScalar(0.195157)), + btVector3(btScalar(0.971650), btScalar(-0.012709), btScalar(0.235561)), + btVector3(btScalar(0.984920), btScalar(-0.161831), btScalar(0.059695)), + btVector3(btScalar(0.946673), btScalar(-0.299288), btScalar(-0.117536)), + btVector3(btScalar(0.922670), btScalar(-0.219186), btScalar(-0.317019)), + btVector3(btScalar(0.928134), btScalar(-0.007265), btScalar(-0.371867)), + btVector3(btScalar(0.875642), btScalar(0.198434), btScalar(-0.439988)), + btVector3(btScalar(0.908035), btScalar(0.325975), btScalar(-0.262562)), + btVector3(btScalar(0.864519), btScalar(0.488706), btScalar(-0.116755)), + btVector3(btScalar(0.893009), btScalar(0.428046), btScalar(0.137185)), + btVector3(btScalar(0.857494), btScalar(0.362137), btScalar(0.364776)), + btVector3(btScalar(0.900815), btScalar(0.132524), btScalar(0.412987)), + btVector3(btScalar(0.934964), btScalar(-0.241739), btScalar(0.259179)), + btVector3(btScalar(0.894570), btScalar(-0.103504), btScalar(0.434263)), + btVector3(btScalar(0.922085), btScalar(-0.376668), btScalar(0.086241)), + btVector3(btScalar(0.862177), btScalar(-0.499154), btScalar(-0.085330)), + btVector3(btScalar(0.861982), btScalar(-0.420218), btScalar(-0.282861)), + btVector3(btScalar(0.818076), btScalar(-0.328256), btScalar(-0.471804)), + btVector3(btScalar(0.762657), btScalar(-0.179329), btScalar(-0.621124)), + btVector3(btScalar(0.826857), btScalar(0.019760), btScalar(-0.561786)), + btVector3(btScalar(0.731434), btScalar(0.206599), btScalar(-0.649817)), + btVector3(btScalar(0.769486), btScalar(0.379052), btScalar(-0.513770)), + btVector3(btScalar(0.796806), btScalar(0.507176), btScalar(-0.328145)), + btVector3(btScalar(0.679722), btScalar(0.684101), btScalar(-0.264123)), + btVector3(btScalar(0.786854), btScalar(0.614886), btScalar(0.050912)), + btVector3(btScalar(0.769486), btScalar(0.571141), btScalar(0.285139)), + btVector3(btScalar(0.707432), btScalar(0.492789), btScalar(0.506288)), + btVector3(btScalar(0.774560), btScalar(0.268037), btScalar(0.572652)), + btVector3(btScalar(0.796220), btScalar(0.031230), btScalar(0.604077)), + btVector3(btScalar(0.837395), btScalar(-0.320285), btScalar(0.442461)), + btVector3(btScalar(0.848127), btScalar(-0.450548), btScalar(0.278307)), + btVector3(btScalar(0.775536), btScalar(-0.206354), btScalar(0.596465)), + btVector3(btScalar(0.816320), btScalar(-0.567007), btScalar(0.109469)), + btVector3(btScalar(0.741191), btScalar(-0.668690), btScalar(-0.056832)), + btVector3(btScalar(0.755632), btScalar(-0.602975), btScalar(-0.254949)), + btVector3(btScalar(0.720311), btScalar(-0.521318), btScalar(-0.457165)), + btVector3(btScalar(0.670746), btScalar(-0.386583), btScalar(-0.632835)), + btVector3(btScalar(0.587031), btScalar(-0.219769), btScalar(-0.778836)), + btVector3(btScalar(0.676015), btScalar(-0.003182), btScalar(-0.736676)), + btVector3(btScalar(0.566932), btScalar(0.186963), btScalar(-0.802064)), + btVector3(btScalar(0.618254), btScalar(0.398105), btScalar(-0.677533)), + btVector3(btScalar(0.653964), btScalar(0.575224), btScalar(-0.490933)), + btVector3(btScalar(0.525367), btScalar(0.743205), btScalar(-0.414028)), + btVector3(btScalar(0.506439), btScalar(0.836528), btScalar(-0.208885)), + btVector3(btScalar(0.651427), btScalar(0.756426), btScalar(-0.056247)), + btVector3(btScalar(0.641670), btScalar(0.745149), btScalar(0.180908)), + btVector3(btScalar(0.602643), btScalar(0.687211), btScalar(0.405180)), + btVector3(btScalar(0.516586), btScalar(0.596999), btScalar(0.613447)), + btVector3(btScalar(0.602252), btScalar(0.387801), btScalar(0.697573)), + btVector3(btScalar(0.646549), btScalar(0.153911), btScalar(0.746956)), + btVector3(btScalar(0.650842), btScalar(-0.087756), btScalar(0.753983)), + btVector3(btScalar(0.740411), btScalar(-0.497404), btScalar(0.451830)), + btVector3(btScalar(0.726946), btScalar(-0.619890), btScalar(0.295093)), + btVector3(btScalar(0.637768), btScalar(-0.313092), btScalar(0.703624)), + btVector3(btScalar(0.678942), btScalar(-0.722934), btScalar(0.126645)), + btVector3(btScalar(0.489072), btScalar(-0.867195), btScalar(-0.092942)), + btVector3(btScalar(0.622742), btScalar(-0.757541), btScalar(-0.194636)), + btVector3(btScalar(0.596788), btScalar(-0.693576), btScalar(-0.403098)), + btVector3(btScalar(0.550150), btScalar(-0.582172), btScalar(-0.598287)), + btVector3(btScalar(0.474436), btScalar(-0.429745), btScalar(-0.768101)), + btVector3(btScalar(0.372574), btScalar(-0.246016), btScalar(-0.894583)), + btVector3(btScalar(0.480095), btScalar(-0.026513), btScalar(-0.876626)), + btVector3(btScalar(0.352474), btScalar(0.177242), btScalar(-0.918787)), + btVector3(btScalar(0.441848), btScalar(0.374386), btScalar(-0.814946)), + btVector3(btScalar(0.492389), btScalar(0.582223), btScalar(-0.646693)), + btVector3(btScalar(0.343498), btScalar(0.866080), btScalar(-0.362693)), + btVector3(btScalar(0.362036), btScalar(0.745149), btScalar(-0.559639)), + btVector3(btScalar(0.334131), btScalar(0.937044), btScalar(-0.099774)), + btVector3(btScalar(0.486925), btScalar(0.871718), btScalar(0.052473)), + btVector3(btScalar(0.452776), btScalar(0.845665), btScalar(0.281820)), + btVector3(btScalar(0.399503), btScalar(0.771785), btScalar(0.494576)), + btVector3(btScalar(0.296469), btScalar(0.673018), btScalar(0.677469)), + btVector3(btScalar(0.392088), btScalar(0.479179), btScalar(0.785213)), + btVector3(btScalar(0.452190), btScalar(0.252094), btScalar(0.855286)), + btVector3(btScalar(0.478339), btScalar(0.013149), btScalar(0.877928)), + btVector3(btScalar(0.481656), btScalar(-0.219380), btScalar(0.848259)), + btVector3(btScalar(0.615327), btScalar(-0.494293), btScalar(0.613837)), + btVector3(btScalar(0.594642), btScalar(-0.650414), btScalar(0.472325)), + btVector3(btScalar(0.562249), btScalar(-0.771345), btScalar(0.297631)), + btVector3(btScalar(0.467411), btScalar(-0.437133), btScalar(0.768231)), + btVector3(btScalar(0.519513), btScalar(-0.847947), btScalar(0.103808)), + btVector3(btScalar(0.297640), btScalar(-0.938159), btScalar(-0.176288)), + btVector3(btScalar(0.446727), btScalar(-0.838615), btScalar(-0.311359)), + btVector3(btScalar(0.331790), btScalar(-0.942437), btScalar(0.040762)), + btVector3(btScalar(0.413358), btScalar(-0.748403), btScalar(-0.518259)), + btVector3(btScalar(0.347596), btScalar(-0.621640), btScalar(-0.701737)), + btVector3(btScalar(0.249831), btScalar(-0.456186), btScalar(-0.853984)), + btVector3(btScalar(0.131772), btScalar(-0.262931), btScalar(-0.955678)), + btVector3(btScalar(0.247099), btScalar(-0.042261), btScalar(-0.967975)), + btVector3(btScalar(0.113624), btScalar(0.165965), btScalar(-0.979491)), + btVector3(btScalar(0.217438), btScalar(0.374580), btScalar(-0.901220)), + btVector3(btScalar(0.307983), btScalar(0.554615), btScalar(-0.772786)), + btVector3(btScalar(0.166702), btScalar(0.953181), btScalar(-0.252021)), + btVector3(btScalar(0.172751), btScalar(0.844499), btScalar(-0.506743)), + btVector3(btScalar(0.177630), btScalar(0.711125), btScalar(-0.679876)), + btVector3(btScalar(0.120064), btScalar(0.992260), btScalar(-0.030482)), + btVector3(btScalar(0.289640), btScalar(0.949098), btScalar(0.122546)), + btVector3(btScalar(0.239879), btScalar(0.909047), btScalar(0.340377)), + btVector3(btScalar(0.181142), btScalar(0.821363), btScalar(0.540641)), + btVector3(btScalar(0.066986), btScalar(0.719097), btScalar(0.691327)), + btVector3(btScalar(0.156750), btScalar(0.545478), btScalar(0.823079)), + btVector3(btScalar(0.236172), btScalar(0.342306), btScalar(0.909353)), + btVector3(btScalar(0.277541), btScalar(0.112693), btScalar(0.953856)), + btVector3(btScalar(0.295299), btScalar(-0.121974), btScalar(0.947415)), + btVector3(btScalar(0.287883), btScalar(-0.349254), btScalar(0.891591)), + btVector3(btScalar(0.437165), btScalar(-0.634666), btScalar(0.636869)), + btVector3(btScalar(0.407113), btScalar(-0.784954), btScalar(0.466664)), + btVector3(btScalar(0.375111), btScalar(-0.888193), btScalar(0.264839)), + btVector3(btScalar(0.275394), btScalar(-0.560591), btScalar(0.780723)), + btVector3(btScalar(0.122015), btScalar(-0.992209), btScalar(-0.024821)), + btVector3(btScalar(0.087866), btScalar(-0.966156), btScalar(-0.241676)), + btVector3(btScalar(0.239489), btScalar(-0.885665), btScalar(-0.397437)), + btVector3(btScalar(0.167287), btScalar(-0.965184), btScalar(0.200817)), + btVector3(btScalar(0.201632), btScalar(-0.776789), btScalar(-0.596335)), + btVector3(btScalar(0.122015), btScalar(-0.637971), btScalar(-0.760098)), + btVector3(btScalar(0.008054), btScalar(-0.464741), btScalar(-0.885214)), + btVector3(btScalar(-0.116054), btScalar(-0.271096), btScalar(-0.955482)), + btVector3(btScalar(-0.000727), btScalar(-0.056065), btScalar(-0.998424)), + btVector3(btScalar(-0.134007), btScalar(0.152939), btScalar(-0.978905)), + btVector3(btScalar(-0.025900), btScalar(0.366026), btScalar(-0.930108)), + btVector3(btScalar(0.081231), btScalar(0.557337), btScalar(-0.826072)), + btVector3(btScalar(-0.002874), btScalar(0.917213), btScalar(-0.398023)), + btVector3(btScalar(-0.050683), btScalar(0.981761), btScalar(-0.182534)), + btVector3(btScalar(-0.040536), btScalar(0.710153), btScalar(-0.702713)), + btVector3(btScalar(-0.139081), btScalar(0.827973), btScalar(-0.543048)), + btVector3(btScalar(-0.101029), btScalar(0.994010), btScalar(0.041152)), + btVector3(btScalar(0.069328), btScalar(0.978067), btScalar(0.196133)), + btVector3(btScalar(0.023860), btScalar(0.911380), btScalar(0.410645)), + btVector3(btScalar(-0.153521), btScalar(0.736789), btScalar(0.658145)), + btVector3(btScalar(-0.070002), btScalar(0.591750), btScalar(0.802780)), + btVector3(btScalar(0.002590), btScalar(0.312948), btScalar(0.949562)), + btVector3(btScalar(0.090988), btScalar(-0.020680), btScalar(0.995627)), + btVector3(btScalar(0.088842), btScalar(-0.250099), btScalar(0.964006)), + btVector3(btScalar(0.083378), btScalar(-0.470185), btScalar(0.878318)), + btVector3(btScalar(0.240074), btScalar(-0.749764), btScalar(0.616374)), + btVector3(btScalar(0.210803), btScalar(-0.885860), btScalar(0.412987)), + btVector3(btScalar(0.077524), btScalar(-0.660524), btScalar(0.746565)), + btVector3(btScalar(-0.096736), btScalar(-0.990070), btScalar(-0.100945)), + btVector3(btScalar(-0.052634), btScalar(-0.990264), btScalar(0.127426)), + btVector3(btScalar(-0.106102), btScalar(-0.938354), btScalar(-0.328340)), + btVector3(btScalar(0.013323), btScalar(-0.863112), btScalar(-0.504596)), + btVector3(btScalar(-0.002093), btScalar(-0.936993), btScalar(0.349161)), + btVector3(btScalar(-0.106297), btScalar(-0.636610), btScalar(-0.763612)), + btVector3(btScalar(-0.229430), btScalar(-0.463769), btScalar(-0.855546)), + btVector3(btScalar(-0.245236), btScalar(-0.066175), btScalar(-0.966999)), + btVector3(btScalar(-0.351587), btScalar(-0.270513), btScalar(-0.896145)), + btVector3(btScalar(-0.370906), btScalar(0.133108), btScalar(-0.918982)), + btVector3(btScalar(-0.264360), btScalar(0.346000), btScalar(-0.900049)), + btVector3(btScalar(-0.151375), btScalar(0.543728), btScalar(-0.825291)), + btVector3(btScalar(-0.218697), btScalar(0.912741), btScalar(-0.344346)), + btVector3(btScalar(-0.274507), btScalar(0.953764), btScalar(-0.121635)), + btVector3(btScalar(-0.259677), btScalar(0.692266), btScalar(-0.673044)), + btVector3(btScalar(-0.350416), btScalar(0.798810), btScalar(-0.488786)), + btVector3(btScalar(-0.320170), btScalar(0.941127), btScalar(0.108297)), + btVector3(btScalar(-0.147667), btScalar(0.952792), btScalar(0.265034)), + btVector3(btScalar(-0.188061), btScalar(0.860636), btScalar(0.472910)), + btVector3(btScalar(-0.370906), btScalar(0.739900), btScalar(0.560941)), + btVector3(btScalar(-0.297143), btScalar(0.585334), btScalar(0.754178)), + btVector3(btScalar(-0.189622), btScalar(0.428241), btScalar(0.883393)), + btVector3(btScalar(-0.091272), btScalar(0.098695), btScalar(0.990747)), + btVector3(btScalar(-0.256945), btScalar(0.228375), btScalar(0.938827)), + btVector3(btScalar(-0.111761), btScalar(-0.133251), btScalar(0.984696)), + btVector3(btScalar(-0.118006), btScalar(-0.356253), btScalar(0.926725)), + btVector3(btScalar(-0.119372), btScalar(-0.563896), btScalar(0.817029)), + btVector3(btScalar(0.041228), btScalar(-0.833949), btScalar(0.550010)), + btVector3(btScalar(-0.121909), btScalar(-0.736543), btScalar(0.665172)), + btVector3(btScalar(-0.307681), btScalar(-0.931160), btScalar(-0.195026)), + btVector3(btScalar(-0.283679), btScalar(-0.957990), btScalar(0.041348)), + btVector3(btScalar(-0.227284), btScalar(-0.935243), btScalar(0.270890)), + btVector3(btScalar(-0.293436), btScalar(-0.858252), btScalar(-0.420860)), + btVector3(btScalar(-0.175767), btScalar(-0.780677), btScalar(-0.599262)), + btVector3(btScalar(-0.170108), btScalar(-0.858835), btScalar(0.482865)), + btVector3(btScalar(-0.332854), btScalar(-0.635055), btScalar(-0.696857)), + btVector3(btScalar(-0.447791), btScalar(-0.445299), btScalar(-0.775128)), + btVector3(btScalar(-0.470622), btScalar(-0.074146), btScalar(-0.879164)), + btVector3(btScalar(-0.639417), btScalar(-0.340505), btScalar(-0.689049)), + btVector3(btScalar(-0.598438), btScalar(0.104722), btScalar(-0.794256)), + btVector3(btScalar(-0.488575), btScalar(0.307699), btScalar(-0.816313)), + btVector3(btScalar(-0.379882), btScalar(0.513592), btScalar(-0.769077)), + btVector3(btScalar(-0.425740), btScalar(0.862775), btScalar(-0.272516)), + btVector3(btScalar(-0.480769), btScalar(0.875412), btScalar(-0.048439)), + btVector3(btScalar(-0.467890), btScalar(0.648716), btScalar(-0.600043)), + btVector3(btScalar(-0.543799), btScalar(0.730956), btScalar(-0.411881)), + btVector3(btScalar(-0.516284), btScalar(0.838277), btScalar(0.174076)), + btVector3(btScalar(-0.353343), btScalar(0.876384), btScalar(0.326519)), + btVector3(btScalar(-0.572875), btScalar(0.614497), btScalar(0.542007)), + btVector3(btScalar(-0.503600), btScalar(0.497261), btScalar(0.706161)), + btVector3(btScalar(-0.530920), btScalar(0.754870), btScalar(0.384685)), + btVector3(btScalar(-0.395884), btScalar(0.366414), btScalar(0.841818)), + btVector3(btScalar(-0.300656), btScalar(0.001678), btScalar(0.953661)), + btVector3(btScalar(-0.461060), btScalar(0.146912), btScalar(0.875000)), + btVector3(btScalar(-0.315486), btScalar(-0.232212), btScalar(0.919893)), + btVector3(btScalar(-0.323682), btScalar(-0.449187), btScalar(0.832644)), + btVector3(btScalar(-0.318999), btScalar(-0.639527), btScalar(0.699134)), + btVector3(btScalar(-0.496771), btScalar(-0.866029), btScalar(-0.055271)), + btVector3(btScalar(-0.496771), btScalar(-0.816257), btScalar(-0.294377)), + btVector3(btScalar(-0.456377), btScalar(-0.869528), btScalar(0.188130)), + btVector3(btScalar(-0.380858), btScalar(-0.827144), btScalar(0.412792)), + btVector3(btScalar(-0.449352), btScalar(-0.727405), btScalar(-0.518259)), + btVector3(btScalar(-0.570533), btScalar(-0.551064), btScalar(-0.608632)), + btVector3(btScalar(-0.656394), btScalar(-0.118280), btScalar(-0.744874)), + btVector3(btScalar(-0.756696), btScalar(-0.438105), btScalar(-0.484882)), + btVector3(btScalar(-0.801773), btScalar(-0.204798), btScalar(-0.561005)), + btVector3(btScalar(-0.785186), btScalar(0.038618), btScalar(-0.617805)), + btVector3(btScalar(-0.709082), btScalar(0.262399), btScalar(-0.654306)), + btVector3(btScalar(-0.583412), btScalar(0.462265), btScalar(-0.667383)), + btVector3(btScalar(-0.616001), btScalar(0.761286), btScalar(-0.201272)), + btVector3(btScalar(-0.660687), btScalar(0.750204), btScalar(0.020072)), + btVector3(btScalar(-0.744987), btScalar(0.435823), btScalar(-0.504791)), + btVector3(btScalar(-0.713765), btScalar(0.605554), btScalar(-0.351373)), + btVector3(btScalar(-0.686251), btScalar(0.687600), btScalar(0.236927)), + btVector3(btScalar(-0.680201), btScalar(0.429407), btScalar(0.593732)), + btVector3(btScalar(-0.733474), btScalar(0.546450), btScalar(0.403814)), + btVector3(btScalar(-0.591023), btScalar(0.292923), btScalar(0.751445)), + btVector3(btScalar(-0.500283), btScalar(-0.080757), btScalar(0.861922)), + btVector3(btScalar(-0.643710), btScalar(0.070115), btScalar(0.761985)), + btVector3(btScalar(-0.506332), btScalar(-0.308425), btScalar(0.805122)), + btVector3(btScalar(-0.503015), btScalar(-0.509847), btScalar(0.697573)), + btVector3(btScalar(-0.482525), btScalar(-0.682105), btScalar(0.549229)), + btVector3(btScalar(-0.680396), btScalar(-0.716323), btScalar(-0.153451)), + btVector3(btScalar(-0.658346), btScalar(-0.746264), btScalar(0.097562)), + btVector3(btScalar(-0.653272), btScalar(-0.646915), btScalar(-0.392948)), + btVector3(btScalar(-0.590828), btScalar(-0.732655), btScalar(0.337645)), + btVector3(btScalar(-0.819140), btScalar(-0.518013), btScalar(-0.246166)), + btVector3(btScalar(-0.900513), btScalar(-0.282178), btScalar(-0.330487)), + btVector3(btScalar(-0.914953), btScalar(-0.028652), btScalar(-0.402122)), + btVector3(btScalar(-0.859924), btScalar(0.220209), btScalar(-0.459898)), + btVector3(btScalar(-0.777185), btScalar(0.613720), btScalar(-0.137836)), + btVector3(btScalar(-0.805285), btScalar(0.586889), btScalar(0.082728)), + btVector3(btScalar(-0.872413), btScalar(0.406077), btScalar(-0.271735)), + btVector3(btScalar(-0.859339), btScalar(0.448072), btScalar(0.246101)), + btVector3(btScalar(-0.757671), btScalar(0.216320), btScalar(0.615594)), + btVector3(btScalar(-0.826165), btScalar(0.348139), btScalar(0.442851)), + btVector3(btScalar(-0.671810), btScalar(-0.162803), btScalar(0.722557)), + btVector3(btScalar(-0.796504), btScalar(-0.004543), btScalar(0.604468)), + btVector3(btScalar(-0.676298), btScalar(-0.378223), btScalar(0.631794)), + btVector3(btScalar(-0.668883), btScalar(-0.558258), btScalar(0.490673)), + btVector3(btScalar(-0.821287), btScalar(-0.570118), btScalar(0.006994)), + btVector3(btScalar(-0.767428), btScalar(-0.587810), btScalar(0.255470)), + btVector3(btScalar(-0.933296), btScalar(-0.349837), btScalar(-0.079865)), + btVector3(btScalar(-0.982667), btScalar(-0.100393), btScalar(-0.155208)), + btVector3(btScalar(-0.961396), btScalar(0.160910), btScalar(-0.222938)), + btVector3(btScalar(-0.934858), btScalar(0.354555), btScalar(-0.006864)), + btVector3(btScalar(-0.941687), btScalar(0.229736), btScalar(0.245711)), + btVector3(btScalar(-0.884317), btScalar(0.131552), btScalar(0.447536)), + btVector3(btScalar(-0.810359), btScalar(-0.219769), btScalar(0.542788)), + btVector3(btScalar(-0.915929), btScalar(-0.210048), btScalar(0.341743)), + btVector3(btScalar(-0.816799), btScalar(-0.407192), btScalar(0.408303)), + btVector3(btScalar(-0.903050), btScalar(-0.392416), btScalar(0.174076)), + btVector3(btScalar(-0.980325), btScalar(-0.170969), btScalar(0.096586)), + btVector3(btScalar(-0.995936), btScalar(0.084891), btScalar(0.029441)), + btVector3(btScalar(-0.960031), btScalar(0.002650), btScalar(0.279283)), + }; + static btVector3 sUnitSpherePoints[NUM_UNITSPHERE_POINTS + MAX_PREFERRED_PENETRATION_DIRECTIONS * 2] = + { + btVector3(btScalar(0.000000), btScalar(-0.000000), btScalar(-1.000000)), + btVector3(btScalar(0.723608), btScalar(-0.525725), btScalar(-0.447219)), + btVector3(btScalar(-0.276388), btScalar(-0.850649), btScalar(-0.447219)), + btVector3(btScalar(-0.894426), btScalar(-0.000000), btScalar(-0.447216)), + btVector3(btScalar(-0.276388), btScalar(0.850649), btScalar(-0.447220)), + btVector3(btScalar(0.723608), btScalar(0.525725), btScalar(-0.447219)), + btVector3(btScalar(0.276388), btScalar(-0.850649), btScalar(0.447220)), + btVector3(btScalar(-0.723608), btScalar(-0.525725), btScalar(0.447219)), + btVector3(btScalar(-0.723608), btScalar(0.525725), btScalar(0.447219)), + btVector3(btScalar(0.276388), btScalar(0.850649), btScalar(0.447219)), + btVector3(btScalar(0.894426), btScalar(0.000000), btScalar(0.447216)), + btVector3(btScalar(-0.000000), btScalar(0.000000), btScalar(1.000000)), + btVector3(btScalar(0.425323), btScalar(-0.309011), btScalar(-0.850654)), + btVector3(btScalar(-0.162456), btScalar(-0.499995), btScalar(-0.850654)), + btVector3(btScalar(0.262869), btScalar(-0.809012), btScalar(-0.525738)), + btVector3(btScalar(0.425323), btScalar(0.309011), btScalar(-0.850654)), + btVector3(btScalar(0.850648), btScalar(-0.000000), btScalar(-0.525736)), + btVector3(btScalar(-0.525730), btScalar(-0.000000), btScalar(-0.850652)), + btVector3(btScalar(-0.688190), btScalar(-0.499997), btScalar(-0.525736)), + btVector3(btScalar(-0.162456), btScalar(0.499995), btScalar(-0.850654)), + btVector3(btScalar(-0.688190), btScalar(0.499997), btScalar(-0.525736)), + btVector3(btScalar(0.262869), btScalar(0.809012), btScalar(-0.525738)), + btVector3(btScalar(0.951058), btScalar(0.309013), btScalar(0.000000)), + btVector3(btScalar(0.951058), btScalar(-0.309013), btScalar(0.000000)), + btVector3(btScalar(0.587786), btScalar(-0.809017), btScalar(0.000000)), + btVector3(btScalar(0.000000), btScalar(-1.000000), btScalar(0.000000)), + btVector3(btScalar(-0.587786), btScalar(-0.809017), btScalar(0.000000)), + btVector3(btScalar(-0.951058), btScalar(-0.309013), btScalar(-0.000000)), + btVector3(btScalar(-0.951058), btScalar(0.309013), btScalar(-0.000000)), + btVector3(btScalar(-0.587786), btScalar(0.809017), btScalar(-0.000000)), + btVector3(btScalar(-0.000000), btScalar(1.000000), btScalar(-0.000000)), + btVector3(btScalar(0.587786), btScalar(0.809017), btScalar(-0.000000)), + btVector3(btScalar(0.688190), btScalar(-0.499997), btScalar(0.525736)), + btVector3(btScalar(-0.262869), btScalar(-0.809012), btScalar(0.525738)), + btVector3(btScalar(-0.850648), btScalar(0.000000), btScalar(0.525736)), + btVector3(btScalar(-0.262869), btScalar(0.809012), btScalar(0.525738)), + btVector3(btScalar(0.688190), btScalar(0.499997), btScalar(0.525736)), + btVector3(btScalar(0.525730), btScalar(0.000000), btScalar(0.850652)), + btVector3(btScalar(0.162456), btScalar(-0.499995), btScalar(0.850654)), + btVector3(btScalar(-0.425323), btScalar(-0.309011), btScalar(0.850654)), + btVector3(btScalar(-0.425323), btScalar(0.309011), btScalar(0.850654)), + btVector3(btScalar(0.162456), btScalar(0.499995), btScalar(0.850654))}; + if (highres) + return sUnitSpherePointsHighres; + return sUnitSpherePoints; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.cpp.i new file mode 100644 index 00000000..060921b6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btShapeHull.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btShapeHull.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btShapeHull.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.h new file mode 100644 index 00000000..54439f9c --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.h @@ -0,0 +1,60 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///btShapeHull implemented by John McCutchan. + +#ifndef BT_SHAPE_HULL_H +#define BT_SHAPE_HULL_H + +#include "LinearMath/btAlignedObjectArray.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" + +///The btShapeHull class takes a btConvexShape, builds a simplified convex hull using btConvexHull and provides triangle indices and vertices. +///It can be useful for to simplify a complex convex object and for visualization of a non-polyhedral convex object. +///It approximates the convex hull using the supporting vertex of 42 directions. +ATTRIBUTE_ALIGNED16(class) +btShapeHull +{ +protected: + btAlignedObjectArray m_vertices; + btAlignedObjectArray m_indices; + unsigned int m_numIndices; + const btConvexShape* m_shape; + + static btVector3* getUnitSpherePoints(int highres = 0); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btShapeHull(const btConvexShape* shape); + ~btShapeHull(); + + bool buildHull(btScalar margin, int highres = 0); + + int numTriangles() const; + int numVertices() const; + int numIndices() const; + + const btVector3* getVertexPointer() const + { + return &m_vertices[0]; + } + const unsigned int* getIndexPointer() const + { + return &m_indices[0]; + } +}; + +#endif //BT_SHAPE_HULL_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.h.i new file mode 100644 index 00000000..3c76c327 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btShapeHull.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btShapeHull.h ---------------- + +%include "BulletCollision/CollisionShapes/btShapeHull.h" + +%{ +#include "BulletCollision/CollisionShapes/btShapeHull.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.cpp new file mode 100644 index 00000000..027db2e1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.cpp @@ -0,0 +1,65 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btSphereShape.h" +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" + +#include "LinearMath/btQuaternion.h" + +btVector3 btSphereShape::localGetSupportingVertexWithoutMargin(const btVector3& vec) const +{ + (void)vec; + return btVector3(btScalar(0.), btScalar(0.), btScalar(0.)); +} + +void btSphereShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + (void)vectors; + + for (int i = 0; i < numVectors; i++) + { + supportVerticesOut[i].setValue(btScalar(0.), btScalar(0.), btScalar(0.)); + } +} + +btVector3 btSphereShape::localGetSupportingVertex(const btVector3& vec) const +{ + btVector3 supVertex; + supVertex = localGetSupportingVertexWithoutMargin(vec); + + btVector3 vecnorm = vec; + if (vecnorm.length2() < (SIMD_EPSILON * SIMD_EPSILON)) + { + vecnorm.setValue(btScalar(-1.), btScalar(-1.), btScalar(-1.)); + } + vecnorm.normalize(); + supVertex += getMargin() * vecnorm; + return supVertex; +} + +//broken due to scaling +void btSphereShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + const btVector3& center = t.getOrigin(); + btVector3 extent(getMargin(), getMargin(), getMargin()); + aabbMin = center - extent; + aabbMax = center + extent; +} + +void btSphereShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + btScalar elem = btScalar(0.4) * mass * getMargin() * getMargin(); + inertia.setValue(elem, elem, elem); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.cpp.i new file mode 100644 index 00000000..04f4cbd0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btSphereShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btSphereShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btSphereShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.h new file mode 100644 index 00000000..75e4fd8e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.h @@ -0,0 +1,71 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +#ifndef BT_SPHERE_MINKOWSKI_H +#define BT_SPHERE_MINKOWSKI_H + +#include "btConvexInternalShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +///The btSphereShape implements an implicit sphere, centered around a local origin with radius. +ATTRIBUTE_ALIGNED16(class) +btSphereShape : public btConvexInternalShape + +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btSphereShape(btScalar radius) : btConvexInternalShape() + { + m_shapeType = SPHERE_SHAPE_PROXYTYPE; + m_localScaling.setValue(1.0, 1.0, 1.0); + m_implicitShapeDimensions.setZero(); + m_implicitShapeDimensions.setX(radius); + m_collisionMargin = radius; + m_padding = 0; + } + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const; + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + //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; + + btScalar getRadius() const { return m_implicitShapeDimensions.getX() * m_localScaling.getX(); } + + void setUnscaledRadius(btScalar radius) + { + m_implicitShapeDimensions.setX(radius); + btConvexInternalShape::setMargin(radius); + } + + //debugging + virtual const char* getName() const { return "SPHERE"; } + + virtual void setMargin(btScalar margin) + { + btConvexInternalShape::setMargin(margin); + } + virtual btScalar getMargin() const + { + //to improve gjk behaviour, use radius+margin as the full margin, so never get into the penetration case + //this means, non-uniform scaling is not supported anymore + return getRadius(); + } +}; + +#endif //BT_SPHERE_MINKOWSKI_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.h.i new file mode 100644 index 00000000..b802c6c3 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btSphereShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btSphereShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btSphereShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btSphereShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp new file mode 100644 index 00000000..9238c919 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp @@ -0,0 +1,93 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btStaticPlaneShape.h" + +#include "LinearMath/btTransformUtil.h" + +btStaticPlaneShape::btStaticPlaneShape(const btVector3& planeNormal, btScalar planeConstant) + : btConcaveShape(), m_planeNormal(planeNormal.normalized()), m_planeConstant(planeConstant), m_localScaling(btScalar(1.), btScalar(1.), btScalar(1.)) +{ + m_shapeType = STATIC_PLANE_PROXYTYPE; + // btAssert( btFuzzyZero(m_planeNormal.length() - btScalar(1.)) ); +} + +btStaticPlaneShape::~btStaticPlaneShape() +{ +} + +void btStaticPlaneShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ + (void)t; + /* + btVector3 infvec (btScalar(BT_LARGE_FLOAT),btScalar(BT_LARGE_FLOAT),btScalar(BT_LARGE_FLOAT)); + + btVector3 center = m_planeNormal*m_planeConstant; + aabbMin = center + infvec*m_planeNormal; + aabbMax = aabbMin; + aabbMin.setMin(center - infvec*m_planeNormal); + aabbMax.setMax(center - infvec*m_planeNormal); + */ + + aabbMin.setValue(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + aabbMax.setValue(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); +} + +void btStaticPlaneShape::processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const +{ + btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5); + btScalar radius = halfExtents.length(); + btVector3 center = (aabbMax + aabbMin) * btScalar(0.5); + + //this is where the triangles are generated, given AABB and plane equation (normal/constant) + + btVector3 tangentDir0, tangentDir1; + + //tangentDir0/tangentDir1 can be precalculated + btPlaneSpace1(m_planeNormal, tangentDir0, tangentDir1); + + btVector3 projectedCenter = center - (m_planeNormal.dot(center) - m_planeConstant) * m_planeNormal; + + btVector3 triangle[3]; + triangle[0] = projectedCenter + tangentDir0 * radius + tangentDir1 * radius; + triangle[1] = projectedCenter + tangentDir0 * radius - tangentDir1 * radius; + triangle[2] = projectedCenter - tangentDir0 * radius - tangentDir1 * radius; + + callback->processTriangle(triangle, 0, 0); + + triangle[0] = projectedCenter - tangentDir0 * radius - tangentDir1 * radius; + triangle[1] = projectedCenter - tangentDir0 * radius + tangentDir1 * radius; + triangle[2] = projectedCenter + tangentDir0 * radius + tangentDir1 * radius; + + callback->processTriangle(triangle, 0, 1); +} + +void btStaticPlaneShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + (void)mass; + + //moving concave objects not supported + + inertia.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); +} + +void btStaticPlaneShape::setLocalScaling(const btVector3& scaling) +{ + m_localScaling = scaling; +} +const btVector3& btStaticPlaneShape::getLocalScaling() const +{ + return m_localScaling; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp.i new file mode 100644 index 00000000..f2e9a149 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btStaticPlaneShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btStaticPlaneShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btStaticPlaneShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.h new file mode 100644 index 00000000..1cda8bbc --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.h @@ -0,0 +1,103 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_STATIC_PLANE_SHAPE_H +#define BT_STATIC_PLANE_SHAPE_H + +#include "btConcaveShape.h" + +///The btStaticPlaneShape simulates an infinite non-moving (static) collision plane. +ATTRIBUTE_ALIGNED16(class) +btStaticPlaneShape : public btConcaveShape +{ +protected: + btVector3 m_localAabbMin; + btVector3 m_localAabbMax; + + btVector3 m_planeNormal; + btScalar m_planeConstant; + btVector3 m_localScaling; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btStaticPlaneShape(const btVector3& planeNormal, btScalar planeConstant); + + virtual ~btStaticPlaneShape(); + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const; + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + virtual void setLocalScaling(const btVector3& scaling); + virtual const btVector3& getLocalScaling() const; + + const btVector3& getPlaneNormal() const + { + return m_planeNormal; + } + + const btScalar& getPlaneConstant() const + { + return m_planeConstant; + } + + //debugging + virtual const char* getName() const { return "STATICPLANE"; } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btStaticPlaneShapeData +{ + btCollisionShapeData m_collisionShapeData; + + btVector3FloatData m_localScaling; + btVector3FloatData m_planeNormal; + float m_planeConstant; + char m_pad[4]; +}; + +SIMD_FORCE_INLINE int btStaticPlaneShape::calculateSerializeBufferSize() const +{ + return sizeof(btStaticPlaneShapeData); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btStaticPlaneShape::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btStaticPlaneShapeData* planeData = (btStaticPlaneShapeData*)dataBuffer; + btCollisionShape::serialize(&planeData->m_collisionShapeData, serializer); + + m_localScaling.serializeFloat(planeData->m_localScaling); + m_planeNormal.serializeFloat(planeData->m_planeNormal); + planeData->m_planeConstant = float(m_planeConstant); + + // Fill padding with zeros to appease msan. + planeData->m_pad[0] = 0; + planeData->m_pad[1] = 0; + planeData->m_pad[2] = 0; + planeData->m_pad[3] = 0; + + return "btStaticPlaneShapeData"; +} + +#endif //BT_STATIC_PLANE_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.h.i new file mode 100644 index 00000000..836b8ee5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStaticPlaneShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btStaticPlaneShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btStaticPlaneShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp new file mode 100644 index 00000000..eb288e99 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp @@ -0,0 +1,380 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btStridingMeshInterface.h" +#include "LinearMath/btSerializer.h" + +btStridingMeshInterface::~btStridingMeshInterface() +{ +} + +void btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleIndexCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const +{ + (void)aabbMin; + (void)aabbMax; + int numtotalphysicsverts = 0; + int part, graphicssubparts = getNumSubParts(); + const unsigned char* vertexbase; + const unsigned char* indexbase; + int indexstride; + PHY_ScalarType type; + PHY_ScalarType gfxindextype; + int stride, numverts, numtriangles; + int gfxindex; + btVector3 triangle[3]; + + btVector3 meshScaling = getScaling(); + + ///if the number of parts is big, the performance might drop due to the innerloop switch on indextype + for (part = 0; part < graphicssubparts; part++) + { + getLockedReadOnlyVertexIndexBase(&vertexbase, numverts, type, stride, &indexbase, indexstride, numtriangles, gfxindextype, part); + numtotalphysicsverts += numtriangles * 3; //upper bound + + ///unlike that developers want to pass in double-precision meshes in single-precision Bullet build + ///so disable this feature by default + ///see patch http://code.google.com/p/bullet/issues/detail?id=213 + + switch (type) + { + case PHY_FLOAT: + { + float* graphicsbase; + + switch (gfxindextype) + { + case PHY_INTEGER: + { + for (gfxindex = 0; gfxindex < numtriangles; gfxindex++) + { + unsigned int* tri_indices = (unsigned int*)(indexbase + gfxindex * indexstride); + graphicsbase = (float*)(vertexbase + tri_indices[0] * stride); + triangle[0].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (float*)(vertexbase + tri_indices[1] * stride); + triangle[1].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (float*)(vertexbase + tri_indices[2] * stride); + triangle[2].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + callback->internalProcessTriangleIndex(triangle, part, gfxindex); + } + break; + } + case PHY_SHORT: + { + for (gfxindex = 0; gfxindex < numtriangles; gfxindex++) + { + unsigned short int* tri_indices = (unsigned short int*)(indexbase + gfxindex * indexstride); + graphicsbase = (float*)(vertexbase + tri_indices[0] * stride); + triangle[0].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (float*)(vertexbase + tri_indices[1] * stride); + triangle[1].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (float*)(vertexbase + tri_indices[2] * stride); + triangle[2].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + callback->internalProcessTriangleIndex(triangle, part, gfxindex); + } + break; + } + case PHY_UCHAR: + { + for (gfxindex = 0; gfxindex < numtriangles; gfxindex++) + { + unsigned char* tri_indices = (unsigned char*)(indexbase + gfxindex * indexstride); + graphicsbase = (float*)(vertexbase + tri_indices[0] * stride); + triangle[0].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (float*)(vertexbase + tri_indices[1] * stride); + triangle[1].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (float*)(vertexbase + tri_indices[2] * stride); + triangle[2].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ()); + callback->internalProcessTriangleIndex(triangle, part, gfxindex); + } + break; + } + default: + btAssert((gfxindextype == PHY_INTEGER) || (gfxindextype == PHY_SHORT)); + } + break; + } + + case PHY_DOUBLE: + { + double* graphicsbase; + + switch (gfxindextype) + { + case PHY_INTEGER: + { + for (gfxindex = 0; gfxindex < numtriangles; gfxindex++) + { + unsigned int* tri_indices = (unsigned int*)(indexbase + gfxindex * indexstride); + graphicsbase = (double*)(vertexbase + tri_indices[0] * stride); + triangle[0].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (double*)(vertexbase + tri_indices[1] * stride); + triangle[1].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (double*)(vertexbase + tri_indices[2] * stride); + triangle[2].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ()); + callback->internalProcessTriangleIndex(triangle, part, gfxindex); + } + break; + } + case PHY_SHORT: + { + for (gfxindex = 0; gfxindex < numtriangles; gfxindex++) + { + unsigned short int* tri_indices = (unsigned short int*)(indexbase + gfxindex * indexstride); + graphicsbase = (double*)(vertexbase + tri_indices[0] * stride); + triangle[0].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (double*)(vertexbase + tri_indices[1] * stride); + triangle[1].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (double*)(vertexbase + tri_indices[2] * stride); + triangle[2].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ()); + callback->internalProcessTriangleIndex(triangle, part, gfxindex); + } + break; + } + case PHY_UCHAR: + { + for (gfxindex = 0; gfxindex < numtriangles; gfxindex++) + { + unsigned char* tri_indices = (unsigned char*)(indexbase + gfxindex * indexstride); + graphicsbase = (double*)(vertexbase + tri_indices[0] * stride); + triangle[0].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (double*)(vertexbase + tri_indices[1] * stride); + triangle[1].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ()); + graphicsbase = (double*)(vertexbase + tri_indices[2] * stride); + triangle[2].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ()); + callback->internalProcessTriangleIndex(triangle, part, gfxindex); + } + break; + } + default: + btAssert((gfxindextype == PHY_INTEGER) || (gfxindextype == PHY_SHORT)); + } + break; + } + default: + btAssert((type == PHY_FLOAT) || (type == PHY_DOUBLE)); + } + + unLockReadOnlyVertexBase(part); + } +} + +void btStridingMeshInterface::calculateAabbBruteForce(btVector3& aabbMin, btVector3& aabbMax) +{ + struct AabbCalculationCallback : public btInternalTriangleIndexCallback + { + btVector3 m_aabbMin; + btVector3 m_aabbMax; + + AabbCalculationCallback() + { + m_aabbMin.setValue(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + m_aabbMax.setValue(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + } + + virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex) + { + (void)partId; + (void)triangleIndex; + + m_aabbMin.setMin(triangle[0]); + m_aabbMax.setMax(triangle[0]); + m_aabbMin.setMin(triangle[1]); + m_aabbMax.setMax(triangle[1]); + m_aabbMin.setMin(triangle[2]); + m_aabbMax.setMax(triangle[2]); + } + }; + + //first calculate the total aabb for all triangles + AabbCalculationCallback aabbCallback; + aabbMin.setValue(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT)); + aabbMax.setValue(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + InternalProcessAllTriangles(&aabbCallback, aabbMin, aabbMax); + + aabbMin = aabbCallback.m_aabbMin; + aabbMax = aabbCallback.m_aabbMax; +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +const char* btStridingMeshInterface::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btStridingMeshInterfaceData* trimeshData = (btStridingMeshInterfaceData*)dataBuffer; + + trimeshData->m_numMeshParts = getNumSubParts(); + + //void* uniquePtr = 0; + + trimeshData->m_meshPartsPtr = 0; + + if (trimeshData->m_numMeshParts) + { + btChunk* chunk = serializer->allocate(sizeof(btMeshPartData), trimeshData->m_numMeshParts); + btMeshPartData* memPtr = (btMeshPartData*)chunk->m_oldPtr; + trimeshData->m_meshPartsPtr = (btMeshPartData*)serializer->getUniquePointer(memPtr); + + // int numtotalphysicsverts = 0; + int part, graphicssubparts = getNumSubParts(); + const unsigned char* vertexbase; + const unsigned char* indexbase; + int indexstride; + PHY_ScalarType type; + PHY_ScalarType gfxindextype; + int stride, numverts, numtriangles; + int gfxindex; + // btVector3 triangle[3]; + + // btVector3 meshScaling = getScaling(); + + ///if the number of parts is big, the performance might drop due to the innerloop switch on indextype + for (part = 0; part < graphicssubparts; part++, memPtr++) + { + getLockedReadOnlyVertexIndexBase(&vertexbase, numverts, type, stride, &indexbase, indexstride, numtriangles, gfxindextype, part); + memPtr->m_numTriangles = numtriangles; //indices = 3*numtriangles + memPtr->m_numVertices = numverts; + memPtr->m_indices16 = 0; + memPtr->m_indices32 = 0; + memPtr->m_3indices16 = 0; + memPtr->m_3indices8 = 0; + memPtr->m_vertices3f = 0; + memPtr->m_vertices3d = 0; + + switch (gfxindextype) + { + case PHY_INTEGER: + { + int numindices = numtriangles * 3; + + if (numindices) + { + btChunk* chunk = serializer->allocate(sizeof(btIntIndexData), numindices); + btIntIndexData* tmpIndices = (btIntIndexData*)chunk->m_oldPtr; + memPtr->m_indices32 = (btIntIndexData*)serializer->getUniquePointer(tmpIndices); + for (gfxindex = 0; gfxindex < numtriangles; gfxindex++) + { + unsigned int* tri_indices = (unsigned int*)(indexbase + gfxindex * indexstride); + tmpIndices[gfxindex * 3].m_value = tri_indices[0]; + tmpIndices[gfxindex * 3 + 1].m_value = tri_indices[1]; + tmpIndices[gfxindex * 3 + 2].m_value = tri_indices[2]; + } + serializer->finalizeChunk(chunk, "btIntIndexData", BT_ARRAY_CODE, (void*)chunk->m_oldPtr); + } + break; + } + case PHY_SHORT: + { + if (numtriangles) + { + btChunk* chunk = serializer->allocate(sizeof(btShortIntIndexTripletData), numtriangles); + btShortIntIndexTripletData* tmpIndices = (btShortIntIndexTripletData*)chunk->m_oldPtr; + memPtr->m_3indices16 = (btShortIntIndexTripletData*)serializer->getUniquePointer(tmpIndices); + for (gfxindex = 0; gfxindex < numtriangles; gfxindex++) + { + unsigned short int* tri_indices = (unsigned short int*)(indexbase + gfxindex * indexstride); + tmpIndices[gfxindex].m_values[0] = tri_indices[0]; + tmpIndices[gfxindex].m_values[1] = tri_indices[1]; + tmpIndices[gfxindex].m_values[2] = tri_indices[2]; + // Fill padding with zeros to appease msan. + tmpIndices[gfxindex].m_pad[0] = 0; + tmpIndices[gfxindex].m_pad[1] = 0; + } + serializer->finalizeChunk(chunk, "btShortIntIndexTripletData", BT_ARRAY_CODE, (void*)chunk->m_oldPtr); + } + break; + } + case PHY_UCHAR: + { + if (numtriangles) + { + btChunk* chunk = serializer->allocate(sizeof(btCharIndexTripletData), numtriangles); + btCharIndexTripletData* tmpIndices = (btCharIndexTripletData*)chunk->m_oldPtr; + memPtr->m_3indices8 = (btCharIndexTripletData*)serializer->getUniquePointer(tmpIndices); + for (gfxindex = 0; gfxindex < numtriangles; gfxindex++) + { + unsigned char* tri_indices = (unsigned char*)(indexbase + gfxindex * indexstride); + tmpIndices[gfxindex].m_values[0] = tri_indices[0]; + tmpIndices[gfxindex].m_values[1] = tri_indices[1]; + tmpIndices[gfxindex].m_values[2] = tri_indices[2]; + // Fill padding with zeros to appease msan. + tmpIndices[gfxindex].m_pad = 0; + } + serializer->finalizeChunk(chunk, "btCharIndexTripletData", BT_ARRAY_CODE, (void*)chunk->m_oldPtr); + } + break; + } + default: + { + btAssert(0); + //unknown index type + } + } + + switch (type) + { + case PHY_FLOAT: + { + float* graphicsbase; + + if (numverts) + { + btChunk* chunk = serializer->allocate(sizeof(btVector3FloatData), numverts); + btVector3FloatData* tmpVertices = (btVector3FloatData*)chunk->m_oldPtr; + memPtr->m_vertices3f = (btVector3FloatData*)serializer->getUniquePointer(tmpVertices); + for (int i = 0; i < numverts; i++) + { + graphicsbase = (float*)(vertexbase + i * stride); + tmpVertices[i].m_floats[0] = graphicsbase[0]; + tmpVertices[i].m_floats[1] = graphicsbase[1]; + tmpVertices[i].m_floats[2] = graphicsbase[2]; + } + serializer->finalizeChunk(chunk, "btVector3FloatData", BT_ARRAY_CODE, (void*)chunk->m_oldPtr); + } + break; + } + + case PHY_DOUBLE: + { + if (numverts) + { + btChunk* chunk = serializer->allocate(sizeof(btVector3DoubleData), numverts); + btVector3DoubleData* tmpVertices = (btVector3DoubleData*)chunk->m_oldPtr; + memPtr->m_vertices3d = (btVector3DoubleData*)serializer->getUniquePointer(tmpVertices); + for (int i = 0; i < numverts; i++) + { + double* graphicsbase = (double*)(vertexbase + i * stride); //for now convert to float, might leave it at double + tmpVertices[i].m_floats[0] = graphicsbase[0]; + tmpVertices[i].m_floats[1] = graphicsbase[1]; + tmpVertices[i].m_floats[2] = graphicsbase[2]; + } + serializer->finalizeChunk(chunk, "btVector3DoubleData", BT_ARRAY_CODE, (void*)chunk->m_oldPtr); + } + break; + } + + default: + btAssert((type == PHY_FLOAT) || (type == PHY_DOUBLE)); + } + + unLockReadOnlyVertexBase(part); + } + + serializer->finalizeChunk(chunk, "btMeshPartData", BT_ARRAY_CODE, chunk->m_oldPtr); + } + + // Fill padding with zeros to appease msan. + memset(trimeshData->m_padding, 0, sizeof(trimeshData->m_padding)); + + m_scaling.serializeFloat(trimeshData->m_scaling); + return "btStridingMeshInterfaceData"; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp.i new file mode 100644 index 00000000..ce7f5329 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btStridingMeshInterface.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btStridingMeshInterface.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btStridingMeshInterface.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.h new file mode 100644 index 00000000..68a41dfb --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.h @@ -0,0 +1,153 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_STRIDING_MESHINTERFACE_H +#define BT_STRIDING_MESHINTERFACE_H + +#include "LinearMath/btVector3.h" +#include "btTriangleCallback.h" +#include "btConcaveShape.h" + +/// The btStridingMeshInterface is the interface class for high performance generic access to triangle meshes, used in combination with btBvhTriangleMeshShape and some other collision shapes. +/// Using index striding of 3*sizeof(integer) it can use triangle arrays, using index striding of 1*sizeof(integer) it can handle triangle strips. +/// It allows for sharing graphics and collision meshes. Also it provides locking/unlocking of graphics meshes that are in gpu memory. +ATTRIBUTE_ALIGNED16(class) +btStridingMeshInterface +{ +protected: + btVector3 m_scaling; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btStridingMeshInterface() : m_scaling(btScalar(1.), btScalar(1.), btScalar(1.)) + { + } + + virtual ~btStridingMeshInterface(); + + virtual void InternalProcessAllTriangles(btInternalTriangleIndexCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const; + + ///brute force method to calculate aabb + void calculateAabbBruteForce(btVector3 & aabbMin, btVector3 & aabbMax); + + /// get read and write access to a subpart of a triangle mesh + /// this subpart has a continuous array of vertices and indices + /// in this way the mesh can be handled as chunks of memory with striding + /// very similar to OpenGL vertexarray support + /// make a call to unLockVertexBase when the read and write access is finished + virtual void getLockedVertexIndexBase(unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& stride, unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0) = 0; + + virtual void getLockedReadOnlyVertexIndexBase(const unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& stride, const unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0) const = 0; + + /// unLockVertexBase finishes the access to a subpart of the triangle mesh + /// make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished + virtual void unLockVertexBase(int subpart) = 0; + + virtual void unLockReadOnlyVertexBase(int subpart) const = 0; + + /// getNumSubParts returns the number of separate subparts + /// each subpart has a continuous array of vertices and indices + virtual int getNumSubParts() const = 0; + + virtual void preallocateVertices(int numverts) = 0; + virtual void preallocateIndices(int numindices) = 0; + + virtual bool hasPremadeAabb() const { return false; } + virtual void setPremadeAabb(const btVector3& aabbMin, const btVector3& aabbMax) const + { + (void)aabbMin; + (void)aabbMax; + } + virtual void getPremadeAabb(btVector3 * aabbMin, btVector3 * aabbMax) const + { + (void)aabbMin; + (void)aabbMax; + } + + const btVector3& getScaling() const + { + return m_scaling; + } + void setScaling(const btVector3& scaling) + { + m_scaling = scaling; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +struct btIntIndexData +{ + int m_value; +}; + +struct btShortIntIndexData +{ + short m_value; + char m_pad[2]; +}; + +struct btShortIntIndexTripletData +{ + short m_values[3]; + char m_pad[2]; +}; + +struct btCharIndexTripletData +{ + unsigned char m_values[3]; + char m_pad; +}; + +// clang-format off + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btMeshPartData +{ + btVector3FloatData *m_vertices3f; + btVector3DoubleData *m_vertices3d; + + btIntIndexData *m_indices32; + btShortIntIndexTripletData *m_3indices16; + btCharIndexTripletData *m_3indices8; + + btShortIntIndexData *m_indices16;//backwards compatibility + + int m_numTriangles;//length of m_indices = m_numTriangles + int m_numVertices; +}; + + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btStridingMeshInterfaceData +{ + btMeshPartData *m_meshPartsPtr; + btVector3FloatData m_scaling; + int m_numMeshParts; + char m_padding[4]; +}; + +// clang-format on + +SIMD_FORCE_INLINE int btStridingMeshInterface::calculateSerializeBufferSize() const +{ + return sizeof(btStridingMeshInterfaceData); +} + +#endif //BT_STRIDING_MESHINTERFACE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.h.i new file mode 100644 index 00000000..f99c3e37 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btStridingMeshInterface.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btStridingMeshInterface.h ---------------- + +%include "BulletCollision/CollisionShapes/btStridingMeshInterface.h" + +%{ +#include "BulletCollision/CollisionShapes/btStridingMeshInterface.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.cpp new file mode 100644 index 00000000..c4d33c42 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.cpp @@ -0,0 +1,203 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btTetrahedronShape.h" +#include "LinearMath/btMatrix3x3.h" + +btBU_Simplex1to4::btBU_Simplex1to4() : btPolyhedralConvexAabbCachingShape(), + m_numVertices(0) +{ + m_shapeType = TETRAHEDRAL_SHAPE_PROXYTYPE; +} + +btBU_Simplex1to4::btBU_Simplex1to4(const btVector3& pt0) : btPolyhedralConvexAabbCachingShape(), + m_numVertices(0) +{ + m_shapeType = TETRAHEDRAL_SHAPE_PROXYTYPE; + addVertex(pt0); +} + +btBU_Simplex1to4::btBU_Simplex1to4(const btVector3& pt0, const btVector3& pt1) : btPolyhedralConvexAabbCachingShape(), + m_numVertices(0) +{ + m_shapeType = TETRAHEDRAL_SHAPE_PROXYTYPE; + addVertex(pt0); + addVertex(pt1); +} + +btBU_Simplex1to4::btBU_Simplex1to4(const btVector3& pt0, const btVector3& pt1, const btVector3& pt2) : btPolyhedralConvexAabbCachingShape(), + m_numVertices(0) +{ + m_shapeType = TETRAHEDRAL_SHAPE_PROXYTYPE; + addVertex(pt0); + addVertex(pt1); + addVertex(pt2); +} + +btBU_Simplex1to4::btBU_Simplex1to4(const btVector3& pt0, const btVector3& pt1, const btVector3& pt2, const btVector3& pt3) : btPolyhedralConvexAabbCachingShape(), + m_numVertices(0) +{ + m_shapeType = TETRAHEDRAL_SHAPE_PROXYTYPE; + addVertex(pt0); + addVertex(pt1); + addVertex(pt2); + addVertex(pt3); +} + +void btBU_Simplex1to4::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ +#if 1 + btPolyhedralConvexAabbCachingShape::getAabb(t, aabbMin, aabbMax); +#else + aabbMin.setValue(BT_LARGE_FLOAT, BT_LARGE_FLOAT, BT_LARGE_FLOAT); + aabbMax.setValue(-BT_LARGE_FLOAT, -BT_LARGE_FLOAT, -BT_LARGE_FLOAT); + + //just transform the vertices in worldspace, and take their AABB + for (int i = 0; i < m_numVertices; i++) + { + btVector3 worldVertex = t(m_vertices[i]); + aabbMin.setMin(worldVertex); + aabbMax.setMax(worldVertex); + } +#endif +} + +void btBU_Simplex1to4::addVertex(const btVector3& pt) +{ + m_vertices[m_numVertices++] = pt; + recalcLocalAabb(); +} + +int btBU_Simplex1to4::getNumVertices() const +{ + return m_numVertices; +} + +int btBU_Simplex1to4::getNumEdges() const +{ + //euler formula, F-E+V = 2, so E = F+V-2 + + switch (m_numVertices) + { + case 0: + return 0; + case 1: + return 0; + case 2: + return 1; + case 3: + return 3; + case 4: + return 6; + } + + return 0; +} + +void btBU_Simplex1to4::getEdge(int i, btVector3& pa, btVector3& pb) const +{ + switch (m_numVertices) + { + case 2: + pa = m_vertices[0]; + pb = m_vertices[1]; + break; + case 3: + switch (i) + { + case 0: + pa = m_vertices[0]; + pb = m_vertices[1]; + break; + case 1: + pa = m_vertices[1]; + pb = m_vertices[2]; + break; + case 2: + pa = m_vertices[2]; + pb = m_vertices[0]; + break; + } + break; + case 4: + switch (i) + { + case 0: + pa = m_vertices[0]; + pb = m_vertices[1]; + break; + case 1: + pa = m_vertices[1]; + pb = m_vertices[2]; + break; + case 2: + pa = m_vertices[2]; + pb = m_vertices[0]; + break; + case 3: + pa = m_vertices[0]; + pb = m_vertices[3]; + break; + case 4: + pa = m_vertices[1]; + pb = m_vertices[3]; + break; + case 5: + pa = m_vertices[2]; + pb = m_vertices[3]; + break; + } + } +} + +void btBU_Simplex1to4::getVertex(int i, btVector3& vtx) const +{ + vtx = m_vertices[i]; +} + +int btBU_Simplex1to4::getNumPlanes() const +{ + switch (m_numVertices) + { + case 0: + return 0; + case 1: + return 0; + case 2: + return 0; + case 3: + return 2; + case 4: + return 4; + default: + { + } + } + return 0; +} + +void btBU_Simplex1to4::getPlane(btVector3&, btVector3&, int) const +{ +} + +int btBU_Simplex1to4::getIndex(int) const +{ + return 0; +} + +bool btBU_Simplex1to4::isInside(const btVector3&, btScalar) const +{ + return false; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.cpp.i new file mode 100644 index 00000000..ae43998f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTetrahedronShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btTetrahedronShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btTetrahedronShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.h new file mode 100644 index 00000000..f5e2209e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.h @@ -0,0 +1,71 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SIMPLEX_1TO4_SHAPE +#define BT_SIMPLEX_1TO4_SHAPE + +#include "btPolyhedralConvexShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" + +///The btBU_Simplex1to4 implements tetrahedron, triangle, line, vertex collision shapes. In most cases it is better to use btConvexHullShape instead. +ATTRIBUTE_ALIGNED16(class) +btBU_Simplex1to4 : public btPolyhedralConvexAabbCachingShape +{ +protected: + int m_numVertices; + btVector3 m_vertices[4]; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btBU_Simplex1to4(); + + btBU_Simplex1to4(const btVector3& pt0); + btBU_Simplex1to4(const btVector3& pt0, const btVector3& pt1); + btBU_Simplex1to4(const btVector3& pt0, const btVector3& pt1, const btVector3& pt2); + btBU_Simplex1to4(const btVector3& pt0, const btVector3& pt1, const btVector3& pt2, const btVector3& pt3); + + void reset() + { + m_numVertices = 0; + } + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + void addVertex(const btVector3& pt); + + //PolyhedralConvexShape interface + + virtual int getNumVertices() const; + + virtual int getNumEdges() const; + + virtual void getEdge(int i, btVector3& pa, btVector3& pb) const; + + virtual void getVertex(int i, btVector3& vtx) const; + + virtual int getNumPlanes() const; + + virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const; + + virtual int getIndex(int i) const; + + virtual bool isInside(const btVector3& pt, btScalar tolerance) const; + + ///getName is for debugging + virtual const char* getName() const { return "btBU_Simplex1to4"; } +}; + +#endif //BT_SIMPLEX_1TO4_SHAPE diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.h.i new file mode 100644 index 00000000..3349bef1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTetrahedronShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTetrahedronShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btTetrahedronShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btTetrahedronShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.cpp new file mode 100644 index 00000000..3b6db2b3 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.cpp @@ -0,0 +1,28 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btTriangleBuffer.h" + +void btTriangleBuffer::processTriangle(btVector3* triangle, int partId, int triangleIndex) +{ + btTriangle tri; + tri.m_vertex0 = triangle[0]; + tri.m_vertex1 = triangle[1]; + tri.m_vertex2 = triangle[2]; + tri.m_partId = partId; + tri.m_triangleIndex = triangleIndex; + + m_triangleBuffer.push_back(tri); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.cpp.i new file mode 100644 index 00000000..ff4499c6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleBuffer.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleBuffer.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleBuffer.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.h new file mode 100644 index 00000000..a89b9cd8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.h @@ -0,0 +1,63 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_TRIANGLE_BUFFER_H +#define BT_TRIANGLE_BUFFER_H + +#include "btTriangleCallback.h" +#include "LinearMath/btAlignedObjectArray.h" + +struct btTriangle +{ + btVector3 m_vertex0; + btVector3 m_vertex1; + btVector3 m_vertex2; + int m_partId; + int m_triangleIndex; +}; + +///The btTriangleBuffer callback can be useful to collect and store overlapping triangles between AABB and concave objects that support 'processAllTriangles' +///Example usage of this class: +/// btTriangleBuffer triBuf; +/// concaveShape->processAllTriangles(&triBuf,aabbMin, aabbMax); +/// for (int i=0;i m_triangleBuffer; + +public: + virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex); + + int getNumTriangles() const + { + return int(m_triangleBuffer.size()); + } + + const btTriangle& getTriangle(int index) const + { + return m_triangleBuffer[index]; + } + + void clearBuffer() + { + m_triangleBuffer.clear(); + } +}; + +#endif //BT_TRIANGLE_BUFFER_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.h.i new file mode 100644 index 00000000..9e4a2177 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleBuffer.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleBuffer.h ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleBuffer.h" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleBuffer.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.cpp new file mode 100644 index 00000000..5bd2c595 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.cpp @@ -0,0 +1,24 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btTriangleCallback.h" + +btTriangleCallback::~btTriangleCallback() +{ +} + +btInternalTriangleIndexCallback::~btInternalTriangleIndexCallback() +{ +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.cpp.i new file mode 100644 index 00000000..bb5f1dfc --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleCallback.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleCallback.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleCallback.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.h new file mode 100644 index 00000000..d3644891 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.h @@ -0,0 +1,37 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_TRIANGLE_CALLBACK_H +#define BT_TRIANGLE_CALLBACK_H + +#include "LinearMath/btVector3.h" + +///The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTriangles. +///This callback is called by processAllTriangles for all btConcaveShape derived class, such as btBvhTriangleMeshShape, btStaticPlaneShape and btHeightfieldTerrainShape. +class btTriangleCallback +{ +public: + virtual ~btTriangleCallback(); + virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex) = 0; +}; + +class btInternalTriangleIndexCallback +{ +public: + virtual ~btInternalTriangleIndexCallback(); + virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex) = 0; +}; + +#endif //BT_TRIANGLE_CALLBACK_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.h.i new file mode 100644 index 00000000..9caca6fe --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleCallback.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleCallback.h ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleCallback.h" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleCallback.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp new file mode 100644 index 00000000..dae42551 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp @@ -0,0 +1,90 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btTriangleIndexVertexArray.h" + +btTriangleIndexVertexArray::btTriangleIndexVertexArray(int numTriangles, int* triangleIndexBase, int triangleIndexStride, int numVertices, btScalar* vertexBase, int vertexStride) + : m_hasAabb(0) +{ + btIndexedMesh mesh; + + mesh.m_numTriangles = numTriangles; + mesh.m_triangleIndexBase = (const unsigned char*)triangleIndexBase; + mesh.m_triangleIndexStride = triangleIndexStride; + mesh.m_numVertices = numVertices; + mesh.m_vertexBase = (const unsigned char*)vertexBase; + mesh.m_vertexStride = vertexStride; + + addIndexedMesh(mesh); +} + +btTriangleIndexVertexArray::~btTriangleIndexVertexArray() +{ +} + +void btTriangleIndexVertexArray::getLockedVertexIndexBase(unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& vertexStride, unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart) +{ + btAssert(subpart < getNumSubParts()); + + btIndexedMesh& mesh = m_indexedMeshes[subpart]; + + numverts = mesh.m_numVertices; + (*vertexbase) = (unsigned char*)mesh.m_vertexBase; + + type = mesh.m_vertexType; + + vertexStride = mesh.m_vertexStride; + + numfaces = mesh.m_numTriangles; + + (*indexbase) = (unsigned char*)mesh.m_triangleIndexBase; + indexstride = mesh.m_triangleIndexStride; + indicestype = mesh.m_indexType; +} + +void btTriangleIndexVertexArray::getLockedReadOnlyVertexIndexBase(const unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& vertexStride, const unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart) const +{ + const btIndexedMesh& mesh = m_indexedMeshes[subpart]; + + numverts = mesh.m_numVertices; + (*vertexbase) = (const unsigned char*)mesh.m_vertexBase; + + type = mesh.m_vertexType; + + vertexStride = mesh.m_vertexStride; + + numfaces = mesh.m_numTriangles; + (*indexbase) = (const unsigned char*)mesh.m_triangleIndexBase; + indexstride = mesh.m_triangleIndexStride; + indicestype = mesh.m_indexType; +} + +bool btTriangleIndexVertexArray::hasPremadeAabb() const +{ + return (m_hasAabb == 1); +} + +void btTriangleIndexVertexArray::setPremadeAabb(const btVector3& aabbMin, const btVector3& aabbMax) const +{ + m_aabbMin = aabbMin; + m_aabbMax = aabbMax; + m_hasAabb = 1; // this is intentionally an int see notes in header +} + +void btTriangleIndexVertexArray::getPremadeAabb(btVector3* aabbMin, btVector3* aabbMax) const +{ + *aabbMin = m_aabbMin; + *aabbMax = m_aabbMax; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp.i new file mode 100644 index 00000000..d223562e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h new file mode 100644 index 00000000..556aa3fe --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h @@ -0,0 +1,128 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_TRIANGLE_INDEX_VERTEX_ARRAY_H +#define BT_TRIANGLE_INDEX_VERTEX_ARRAY_H + +#include "btStridingMeshInterface.h" +#include "LinearMath/btAlignedObjectArray.h" +#include "LinearMath/btScalar.h" + +///The btIndexedMesh indexes a single vertex and index array. Multiple btIndexedMesh objects can be passed into a btTriangleIndexVertexArray using addIndexedMesh. +///Instead of the number of indices, we pass the number of triangles. +ATTRIBUTE_ALIGNED16(struct) +btIndexedMesh +{ + BT_DECLARE_ALIGNED_ALLOCATOR(); + + int m_numTriangles; + const unsigned char* m_triangleIndexBase; + // Size in byte of the indices for one triangle (3*sizeof(index_type) if the indices are tightly packed) + int m_triangleIndexStride; + int m_numVertices; + const unsigned char* m_vertexBase; + // Size of a vertex, in bytes + int m_vertexStride; + + // The index type is set when adding an indexed mesh to the + // btTriangleIndexVertexArray, do not set it manually + PHY_ScalarType m_indexType; + + // The vertex type has a default type similar to Bullet's precision mode (float or double) + // but can be set manually if you for example run Bullet with double precision but have + // mesh data in single precision.. + PHY_ScalarType m_vertexType; + + btIndexedMesh() + : m_indexType(PHY_INTEGER), +#ifdef BT_USE_DOUBLE_PRECISION + m_vertexType(PHY_DOUBLE) +#else // BT_USE_DOUBLE_PRECISION + m_vertexType(PHY_FLOAT) +#endif // BT_USE_DOUBLE_PRECISION + { + } +}; + +typedef btAlignedObjectArray IndexedMeshArray; + +///The btTriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing triangle/index arrays. +///Additional meshes can be added using addIndexedMesh +///No duplicate is made of the vertex/index data, it only indexes into external vertex/index arrays. +///So keep those arrays around during the lifetime of this btTriangleIndexVertexArray. +ATTRIBUTE_ALIGNED16(class) +btTriangleIndexVertexArray : public btStridingMeshInterface +{ +protected: + IndexedMeshArray m_indexedMeshes; + int m_pad[2]; + mutable int m_hasAabb; // using int instead of bool to maintain alignment + mutable btVector3 m_aabbMin; + mutable btVector3 m_aabbMax; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btTriangleIndexVertexArray() : m_hasAabb(0) + { + } + + virtual ~btTriangleIndexVertexArray(); + + //just to be backwards compatible + btTriangleIndexVertexArray(int numTriangles, int* triangleIndexBase, int triangleIndexStride, int numVertices, btScalar* vertexBase, int vertexStride); + + void addIndexedMesh(const btIndexedMesh& mesh, PHY_ScalarType indexType = PHY_INTEGER) + { + m_indexedMeshes.push_back(mesh); + m_indexedMeshes[m_indexedMeshes.size() - 1].m_indexType = indexType; + } + + virtual void getLockedVertexIndexBase(unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& vertexStride, unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0); + + virtual void getLockedReadOnlyVertexIndexBase(const unsigned char** vertexbase, int& numverts, PHY_ScalarType& type, int& vertexStride, const unsigned char** indexbase, int& indexstride, int& numfaces, PHY_ScalarType& indicestype, int subpart = 0) const; + + /// unLockVertexBase finishes the access to a subpart of the triangle mesh + /// make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished + virtual void unLockVertexBase(int subpart) { (void)subpart; } + + virtual void unLockReadOnlyVertexBase(int subpart) const { (void)subpart; } + + /// getNumSubParts returns the number of separate subparts + /// each subpart has a continuous array of vertices and indices + virtual int getNumSubParts() const + { + return (int)m_indexedMeshes.size(); + } + + IndexedMeshArray& getIndexedMeshArray() + { + return m_indexedMeshes; + } + + const IndexedMeshArray& getIndexedMeshArray() const + { + return m_indexedMeshes; + } + + virtual void preallocateVertices(int numverts) { (void)numverts; } + virtual void preallocateIndices(int numindices) { (void)numindices; } + + virtual bool hasPremadeAabb() const; + virtual void setPremadeAabb(const btVector3& aabbMin, const btVector3& aabbMax) const; + virtual void getPremadeAabb(btVector3 * aabbMin, btVector3 * aabbMax) const; +}; + +#endif //BT_TRIANGLE_INDEX_VERTEX_ARRAY_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h.i new file mode 100644 index 00000000..b3cb9d9e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp new file mode 100644 index 00000000..4bf133d7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp @@ -0,0 +1,84 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///This file was created by Alex Silverman + +#include "btTriangleIndexVertexMaterialArray.h" + +btTriangleIndexVertexMaterialArray::btTriangleIndexVertexMaterialArray(int numTriangles, int* triangleIndexBase, int triangleIndexStride, + int numVertices, btScalar* vertexBase, int vertexStride, + int numMaterials, unsigned char* materialBase, int materialStride, + int* triangleMaterialsBase, int materialIndexStride) : btTriangleIndexVertexArray(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride) +{ + btMaterialProperties mat; + + mat.m_numMaterials = numMaterials; + mat.m_materialBase = materialBase; + mat.m_materialStride = materialStride; +#ifdef BT_USE_DOUBLE_PRECISION + mat.m_materialType = PHY_DOUBLE; +#else + mat.m_materialType = PHY_FLOAT; +#endif + + mat.m_numTriangles = numTriangles; + mat.m_triangleMaterialsBase = (unsigned char*)triangleMaterialsBase; + mat.m_triangleMaterialStride = materialIndexStride; + mat.m_triangleType = PHY_INTEGER; + + addMaterialProperties(mat); +} + +void btTriangleIndexVertexMaterialArray::getLockedMaterialBase(unsigned char** materialBase, int& numMaterials, PHY_ScalarType& materialType, int& materialStride, + unsigned char** triangleMaterialBase, int& numTriangles, int& triangleMaterialStride, PHY_ScalarType& triangleType, int subpart) +{ + btAssert(subpart < getNumSubParts()); + + btMaterialProperties& mats = m_materials[subpart]; + + numMaterials = mats.m_numMaterials; + (*materialBase) = (unsigned char*)mats.m_materialBase; +#ifdef BT_USE_DOUBLE_PRECISION + materialType = PHY_DOUBLE; +#else + materialType = PHY_FLOAT; +#endif + materialStride = mats.m_materialStride; + + numTriangles = mats.m_numTriangles; + (*triangleMaterialBase) = (unsigned char*)mats.m_triangleMaterialsBase; + triangleMaterialStride = mats.m_triangleMaterialStride; + triangleType = mats.m_triangleType; +} + +void btTriangleIndexVertexMaterialArray::getLockedReadOnlyMaterialBase(const unsigned char** materialBase, int& numMaterials, PHY_ScalarType& materialType, int& materialStride, + const unsigned char** triangleMaterialBase, int& numTriangles, int& triangleMaterialStride, PHY_ScalarType& triangleType, int subpart) +{ + btMaterialProperties& mats = m_materials[subpart]; + + numMaterials = mats.m_numMaterials; + (*materialBase) = (const unsigned char*)mats.m_materialBase; +#ifdef BT_USE_DOUBLE_PRECISION + materialType = PHY_DOUBLE; +#else + materialType = PHY_FLOAT; +#endif + materialStride = mats.m_materialStride; + + numTriangles = mats.m_numTriangles; + (*triangleMaterialBase) = (const unsigned char*)mats.m_triangleMaterialsBase; + triangleMaterialStride = mats.m_triangleMaterialStride; + triangleType = mats.m_triangleType; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp.i new file mode 100644 index 00000000..2a16cfa6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h new file mode 100644 index 00000000..315b1e21 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h @@ -0,0 +1,83 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///This file was created by Alex Silverman + +#ifndef BT_MULTIMATERIAL_TRIANGLE_INDEX_VERTEX_ARRAY_H +#define BT_MULTIMATERIAL_TRIANGLE_INDEX_VERTEX_ARRAY_H + +#include "btTriangleIndexVertexArray.h" + +ATTRIBUTE_ALIGNED16(struct) +btMaterialProperties +{ + ///m_materialBase ==========> 2 btScalar values make up one material, friction then restitution + int m_numMaterials; + const unsigned char* m_materialBase; + int m_materialStride; + PHY_ScalarType m_materialType; + ///m_numTriangles <=========== This exists in the btIndexedMesh object for the same subpart, but since we're + /// padding the structure, it can be reproduced at no real cost + ///m_triangleMaterials =====> 1 integer value makes up one entry + /// eg: m_triangleMaterials[1] = 5; // This will set triangle 2 to use material 5 + int m_numTriangles; + const unsigned char* m_triangleMaterialsBase; + int m_triangleMaterialStride; + ///m_triangleType <========== Automatically set in addMaterialProperties + PHY_ScalarType m_triangleType; +}; + +typedef btAlignedObjectArray MaterialArray; + +///Teh btTriangleIndexVertexMaterialArray is built on TriangleIndexVertexArray +///The addition of a material array allows for the utilization of the partID and +///triangleIndex that are returned in the ContactAddedCallback. As with +///TriangleIndexVertexArray, no duplicate is made of the material data, so it +///is the users responsibility to maintain the array during the lifetime of the +///TriangleIndexVertexMaterialArray. +ATTRIBUTE_ALIGNED16(class) +btTriangleIndexVertexMaterialArray : public btTriangleIndexVertexArray +{ +protected: + MaterialArray m_materials; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btTriangleIndexVertexMaterialArray() + { + } + + btTriangleIndexVertexMaterialArray(int numTriangles, int* triangleIndexBase, int triangleIndexStride, + int numVertices, btScalar* vertexBase, int vertexStride, + int numMaterials, unsigned char* materialBase, int materialStride, + int* triangleMaterialsBase, int materialIndexStride); + + virtual ~btTriangleIndexVertexMaterialArray() {} + + void addMaterialProperties(const btMaterialProperties& mat, PHY_ScalarType triangleType = PHY_INTEGER) + { + m_materials.push_back(mat); + m_materials[m_materials.size() - 1].m_triangleType = triangleType; + } + + virtual void getLockedMaterialBase(unsigned char** materialBase, int& numMaterials, PHY_ScalarType& materialType, int& materialStride, + unsigned char** triangleMaterialBase, int& numTriangles, int& triangleMaterialStride, PHY_ScalarType& triangleType, int subpart = 0); + + virtual void getLockedReadOnlyMaterialBase(const unsigned char** materialBase, int& numMaterials, PHY_ScalarType& materialType, int& materialStride, + const unsigned char** triangleMaterialBase, int& numTriangles, int& triangleMaterialStride, PHY_ScalarType& triangleType, int subpart = 0); +}; + +#endif //BT_MULTIMATERIAL_TRIANGLE_INDEX_VERTEX_ARRAY_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h.i new file mode 100644 index 00000000..4f5ba455 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleInfoMap.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleInfoMap.h new file mode 100644 index 00000000..8ee35ef5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleInfoMap.h @@ -0,0 +1,238 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2010 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef _BT_TRIANGLE_INFO_MAP_H +#define _BT_TRIANGLE_INFO_MAP_H + +#include "LinearMath/btHashMap.h" +#include "LinearMath/btSerializer.h" + +///for btTriangleInfo m_flags +#define TRI_INFO_V0V1_CONVEX 1 +#define TRI_INFO_V1V2_CONVEX 2 +#define TRI_INFO_V2V0_CONVEX 4 + +#define TRI_INFO_V0V1_SWAP_NORMALB 8 +#define TRI_INFO_V1V2_SWAP_NORMALB 16 +#define TRI_INFO_V2V0_SWAP_NORMALB 32 + +///The btTriangleInfo structure stores information to adjust collision normals to avoid collisions against internal edges +///it can be generated using +struct btTriangleInfo +{ + btTriangleInfo() + { + m_edgeV0V1Angle = SIMD_2_PI; + m_edgeV1V2Angle = SIMD_2_PI; + m_edgeV2V0Angle = SIMD_2_PI; + m_flags = 0; + } + + int m_flags; + + btScalar m_edgeV0V1Angle; + btScalar m_edgeV1V2Angle; + btScalar m_edgeV2V0Angle; +}; + +typedef btHashMap btInternalTriangleInfoMap; + +///The btTriangleInfoMap stores edge angle information for some triangles. You can compute this information yourself or using btGenerateInternalEdgeInfo. +struct btTriangleInfoMap : public btInternalTriangleInfoMap +{ + btScalar m_convexEpsilon; ///used to determine if an edge or contact normal is convex, using the dot product + btScalar m_planarEpsilon; ///used to determine if a triangle edge is planar with zero angle + btScalar m_equalVertexThreshold; ///used to compute connectivity: if the distance between two vertices is smaller than m_equalVertexThreshold, they are considered to be 'shared' + btScalar m_edgeDistanceThreshold; ///used to determine edge contacts: if the closest distance between a contact point and an edge is smaller than this distance threshold it is considered to "hit the edge" + btScalar m_maxEdgeAngleThreshold; //ignore edges that connect triangles at an angle larger than this m_maxEdgeAngleThreshold + btScalar m_zeroAreaThreshold; ///used to determine if a triangle is degenerate (length squared of cross product of 2 triangle edges < threshold) + + btTriangleInfoMap() + { + m_convexEpsilon = 0.00f; + m_planarEpsilon = 0.0001f; + m_equalVertexThreshold = btScalar(0.0001) * btScalar(0.0001); + m_edgeDistanceThreshold = btScalar(0.1); + m_zeroAreaThreshold = btScalar(0.0001) * btScalar(0.0001); + m_maxEdgeAngleThreshold = SIMD_2_PI; + } + virtual ~btTriangleInfoMap() {} + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; + + void deSerialize(struct btTriangleInfoMapData& data); +}; + +// clang-format off + +///those fields have to be float and not btScalar for the serialization to work properly +struct btTriangleInfoData +{ + int m_flags; + float m_edgeV0V1Angle; + float m_edgeV1V2Angle; + float m_edgeV2V0Angle; +}; + +struct btTriangleInfoMapData +{ + int *m_hashTablePtr; + int *m_nextPtr; + btTriangleInfoData *m_valueArrayPtr; + int *m_keyArrayPtr; + + float m_convexEpsilon; + float m_planarEpsilon; + float m_equalVertexThreshold; + float m_edgeDistanceThreshold; + float m_zeroAreaThreshold; + + int m_nextSize; + int m_hashTableSize; + int m_numValues; + int m_numKeys; + char m_padding[4]; +}; + +// clang-format on + +SIMD_FORCE_INLINE int btTriangleInfoMap::calculateSerializeBufferSize() const +{ + return sizeof(btTriangleInfoMapData); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btTriangleInfoMap::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btTriangleInfoMapData* tmapData = (btTriangleInfoMapData*)dataBuffer; + tmapData->m_convexEpsilon = (float)m_convexEpsilon; + tmapData->m_planarEpsilon = (float)m_planarEpsilon; + tmapData->m_equalVertexThreshold = (float)m_equalVertexThreshold; + tmapData->m_edgeDistanceThreshold = (float)m_edgeDistanceThreshold; + tmapData->m_zeroAreaThreshold = (float)m_zeroAreaThreshold; + + tmapData->m_hashTableSize = m_hashTable.size(); + + tmapData->m_hashTablePtr = tmapData->m_hashTableSize ? (int*)serializer->getUniquePointer((void*)&m_hashTable[0]) : 0; + if (tmapData->m_hashTablePtr) + { + //serialize an int buffer + int sz = sizeof(int); + int numElem = tmapData->m_hashTableSize; + btChunk* chunk = serializer->allocate(sz, numElem); + int* memPtr = (int*)chunk->m_oldPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + *memPtr = m_hashTable[i]; + } + serializer->finalizeChunk(chunk, "int", BT_ARRAY_CODE, (void*)&m_hashTable[0]); + } + + tmapData->m_nextSize = m_next.size(); + tmapData->m_nextPtr = tmapData->m_nextSize ? (int*)serializer->getUniquePointer((void*)&m_next[0]) : 0; + if (tmapData->m_nextPtr) + { + int sz = sizeof(int); + int numElem = tmapData->m_nextSize; + btChunk* chunk = serializer->allocate(sz, numElem); + int* memPtr = (int*)chunk->m_oldPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + *memPtr = m_next[i]; + } + serializer->finalizeChunk(chunk, "int", BT_ARRAY_CODE, (void*)&m_next[0]); + } + + tmapData->m_numValues = m_valueArray.size(); + tmapData->m_valueArrayPtr = tmapData->m_numValues ? (btTriangleInfoData*)serializer->getUniquePointer((void*)&m_valueArray[0]) : 0; + if (tmapData->m_valueArrayPtr) + { + int sz = sizeof(btTriangleInfoData); + int numElem = tmapData->m_numValues; + btChunk* chunk = serializer->allocate(sz, numElem); + btTriangleInfoData* memPtr = (btTriangleInfoData*)chunk->m_oldPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + memPtr->m_edgeV0V1Angle = (float)m_valueArray[i].m_edgeV0V1Angle; + memPtr->m_edgeV1V2Angle = (float)m_valueArray[i].m_edgeV1V2Angle; + memPtr->m_edgeV2V0Angle = (float)m_valueArray[i].m_edgeV2V0Angle; + memPtr->m_flags = m_valueArray[i].m_flags; + } + serializer->finalizeChunk(chunk, "btTriangleInfoData", BT_ARRAY_CODE, (void*)&m_valueArray[0]); + } + + tmapData->m_numKeys = m_keyArray.size(); + tmapData->m_keyArrayPtr = tmapData->m_numKeys ? (int*)serializer->getUniquePointer((void*)&m_keyArray[0]) : 0; + if (tmapData->m_keyArrayPtr) + { + int sz = sizeof(int); + int numElem = tmapData->m_numValues; + btChunk* chunk = serializer->allocate(sz, numElem); + int* memPtr = (int*)chunk->m_oldPtr; + for (int i = 0; i < numElem; i++, memPtr++) + { + *memPtr = m_keyArray[i].getUid1(); + } + serializer->finalizeChunk(chunk, "int", BT_ARRAY_CODE, (void*)&m_keyArray[0]); + } + + // Fill padding with zeros to appease msan. + tmapData->m_padding[0] = 0; + tmapData->m_padding[1] = 0; + tmapData->m_padding[2] = 0; + tmapData->m_padding[3] = 0; + + return "btTriangleInfoMapData"; +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE void btTriangleInfoMap::deSerialize(btTriangleInfoMapData& tmapData) +{ + m_convexEpsilon = tmapData.m_convexEpsilon; + m_planarEpsilon = tmapData.m_planarEpsilon; + m_equalVertexThreshold = tmapData.m_equalVertexThreshold; + m_edgeDistanceThreshold = tmapData.m_edgeDistanceThreshold; + m_zeroAreaThreshold = tmapData.m_zeroAreaThreshold; + m_hashTable.resize(tmapData.m_hashTableSize); + int i = 0; + for (i = 0; i < tmapData.m_hashTableSize; i++) + { + m_hashTable[i] = tmapData.m_hashTablePtr[i]; + } + m_next.resize(tmapData.m_nextSize); + for (i = 0; i < tmapData.m_nextSize; i++) + { + m_next[i] = tmapData.m_nextPtr[i]; + } + m_valueArray.resize(tmapData.m_numValues); + for (i = 0; i < tmapData.m_numValues; i++) + { + m_valueArray[i].m_edgeV0V1Angle = tmapData.m_valueArrayPtr[i].m_edgeV0V1Angle; + m_valueArray[i].m_edgeV1V2Angle = tmapData.m_valueArrayPtr[i].m_edgeV1V2Angle; + m_valueArray[i].m_edgeV2V0Angle = tmapData.m_valueArrayPtr[i].m_edgeV2V0Angle; + m_valueArray[i].m_flags = tmapData.m_valueArrayPtr[i].m_flags; + } + + m_keyArray.resize(tmapData.m_numKeys, btHashInt(0)); + for (i = 0; i < tmapData.m_numKeys; i++) + { + m_keyArray[i].setUid1(tmapData.m_keyArrayPtr[i]); + } +} + +#endif //_BT_TRIANGLE_INFO_MAP_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleInfoMap.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleInfoMap.h.i new file mode 100644 index 00000000..56ef22cd --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleInfoMap.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleInfoMap.h ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleInfoMap.h" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleInfoMap.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.cpp new file mode 100644 index 00000000..abd8c227 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.cpp @@ -0,0 +1,167 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btTriangleMesh.h" + +btTriangleMesh::btTriangleMesh(bool use32bitIndices, bool use4componentVertices) + : m_use32bitIndices(use32bitIndices), + m_use4componentVertices(use4componentVertices), + m_weldingThreshold(0.0) +{ + btIndexedMesh meshIndex; + meshIndex.m_numTriangles = 0; + meshIndex.m_numVertices = 0; + meshIndex.m_indexType = PHY_INTEGER; + meshIndex.m_triangleIndexBase = 0; + meshIndex.m_triangleIndexStride = 3 * sizeof(int); + meshIndex.m_vertexBase = 0; + meshIndex.m_vertexStride = sizeof(btVector3); + m_indexedMeshes.push_back(meshIndex); + + if (m_use32bitIndices) + { + m_indexedMeshes[0].m_numTriangles = m_32bitIndices.size() / 3; + m_indexedMeshes[0].m_triangleIndexBase = 0; + m_indexedMeshes[0].m_indexType = PHY_INTEGER; + m_indexedMeshes[0].m_triangleIndexStride = 3 * sizeof(int); + } + else + { + m_indexedMeshes[0].m_numTriangles = m_16bitIndices.size() / 3; + m_indexedMeshes[0].m_triangleIndexBase = 0; + m_indexedMeshes[0].m_indexType = PHY_SHORT; + m_indexedMeshes[0].m_triangleIndexStride = 3 * sizeof(short int); + } + + if (m_use4componentVertices) + { + m_indexedMeshes[0].m_numVertices = m_4componentVertices.size(); + m_indexedMeshes[0].m_vertexBase = 0; + m_indexedMeshes[0].m_vertexStride = sizeof(btVector3); + } + else + { + m_indexedMeshes[0].m_numVertices = m_3componentVertices.size() / 3; + m_indexedMeshes[0].m_vertexBase = 0; + m_indexedMeshes[0].m_vertexStride = 3 * sizeof(btScalar); + } +} + +void btTriangleMesh::addIndex(int index) +{ + if (m_use32bitIndices) + { + m_32bitIndices.push_back(index); + m_indexedMeshes[0].m_triangleIndexBase = (unsigned char*)&m_32bitIndices[0]; + } + else + { + m_16bitIndices.push_back(index); + m_indexedMeshes[0].m_triangleIndexBase = (unsigned char*)&m_16bitIndices[0]; + } +} + +void btTriangleMesh::addTriangleIndices(int index1, int index2, int index3) +{ + m_indexedMeshes[0].m_numTriangles++; + addIndex(index1); + addIndex(index2); + addIndex(index3); +} + +int btTriangleMesh::findOrAddVertex(const btVector3& vertex, bool removeDuplicateVertices) +{ + //return index of new/existing vertex + ///@todo: could use acceleration structure for this + if (m_use4componentVertices) + { + if (removeDuplicateVertices) + { + for (int i = 0; i < m_4componentVertices.size(); i++) + { + if ((m_4componentVertices[i] - vertex).length2() <= m_weldingThreshold) + { + return i; + } + } + } + m_indexedMeshes[0].m_numVertices++; + m_4componentVertices.push_back(vertex); + m_indexedMeshes[0].m_vertexBase = (unsigned char*)&m_4componentVertices[0]; + + return m_4componentVertices.size() - 1; + } + else + { + if (removeDuplicateVertices) + { + for (int i = 0; i < m_3componentVertices.size(); i += 3) + { + btVector3 vtx(m_3componentVertices[i], m_3componentVertices[i + 1], m_3componentVertices[i + 2]); + if ((vtx - vertex).length2() <= m_weldingThreshold) + { + return i / 3; + } + } + } + m_3componentVertices.push_back(vertex.getX()); + m_3componentVertices.push_back(vertex.getY()); + m_3componentVertices.push_back(vertex.getZ()); + m_indexedMeshes[0].m_numVertices++; + m_indexedMeshes[0].m_vertexBase = (unsigned char*)&m_3componentVertices[0]; + return (m_3componentVertices.size() / 3) - 1; + } +} + +void btTriangleMesh::addTriangle(const btVector3& vertex0, const btVector3& vertex1, const btVector3& vertex2, bool removeDuplicateVertices) +{ + m_indexedMeshes[0].m_numTriangles++; + addIndex(findOrAddVertex(vertex0, removeDuplicateVertices)); + addIndex(findOrAddVertex(vertex1, removeDuplicateVertices)); + addIndex(findOrAddVertex(vertex2, removeDuplicateVertices)); +} + +int btTriangleMesh::getNumTriangles() const +{ + if (m_use32bitIndices) + { + return m_32bitIndices.size() / 3; + } + return m_16bitIndices.size() / 3; +} + +void btTriangleMesh::preallocateVertices(int numverts) +{ + if (m_use4componentVertices) + { + m_4componentVertices.reserve(numverts); + } + else + { + m_3componentVertices.reserve(numverts); + } +} + +void btTriangleMesh::preallocateIndices(int numindices) +{ + if (m_use32bitIndices) + { + m_32bitIndices.reserve(numindices); + } + else + { + m_16bitIndices.reserve(numindices); + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.cpp.i new file mode 100644 index 00000000..2c96ed49 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleMesh.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleMesh.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleMesh.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.h new file mode 100644 index 00000000..a8a36235 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.h @@ -0,0 +1,69 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_TRIANGLE_MESH_H +#define BT_TRIANGLE_MESH_H + +#include "btTriangleIndexVertexArray.h" +#include "LinearMath/btVector3.h" +#include "LinearMath/btAlignedObjectArray.h" + +///The btTriangleMesh class is a convenience class derived from btTriangleIndexVertexArray, that provides storage for a concave triangle mesh. It can be used as data for the btBvhTriangleMeshShape. +///It allows either 32bit or 16bit indices, and 4 (x-y-z-w) or 3 (x-y-z) component vertices. +///If you want to share triangle/index data between graphics mesh and collision mesh (btBvhTriangleMeshShape), you can directly use btTriangleIndexVertexArray or derive your own class from btStridingMeshInterface. +///Performance of btTriangleMesh and btTriangleIndexVertexArray used in a btBvhTriangleMeshShape is the same. +class btTriangleMesh : public btTriangleIndexVertexArray +{ + btAlignedObjectArray m_4componentVertices; + btAlignedObjectArray m_3componentVertices; + + btAlignedObjectArray m_32bitIndices; + btAlignedObjectArray m_16bitIndices; + bool m_use32bitIndices; + bool m_use4componentVertices; + +public: + btScalar m_weldingThreshold; + + btTriangleMesh(bool use32bitIndices = true, bool use4componentVertices = true); + + bool getUse32bitIndices() const + { + return m_use32bitIndices; + } + + bool getUse4componentVertices() const + { + return m_use4componentVertices; + } + ///By default addTriangle won't search for duplicate vertices, because the search is very slow for large triangle meshes. + ///In general it is better to directly use btTriangleIndexVertexArray instead. + void addTriangle(const btVector3& vertex0, const btVector3& vertex1, const btVector3& vertex2, bool removeDuplicateVertices = false); + + ///Add a triangle using its indices. Make sure the indices are pointing within the vertices array, so add the vertices first (and to be sure, avoid removal of duplicate vertices) + void addTriangleIndices(int index1, int index2, int index3); + + int getNumTriangles() const; + + virtual void preallocateVertices(int numverts); + virtual void preallocateIndices(int numindices); + + ///findOrAddVertex is an internal method, use addTriangle instead + int findOrAddVertex(const btVector3& vertex, bool removeDuplicateVertices); + ///addIndex is an internal method, use addTriangle instead + void addIndex(int index); +}; + +#endif //BT_TRIANGLE_MESH_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.h.i new file mode 100644 index 00000000..7eec5fb9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMesh.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleMesh.h ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleMesh.h" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleMesh.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp new file mode 100644 index 00000000..aec23906 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp @@ -0,0 +1,179 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btTriangleMeshShape.h" +#include "LinearMath/btVector3.h" +#include "LinearMath/btQuaternion.h" +#include "btStridingMeshInterface.h" +#include "LinearMath/btAabbUtil2.h" +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" + +btTriangleMeshShape::btTriangleMeshShape(btStridingMeshInterface* meshInterface) + : btConcaveShape(), m_meshInterface(meshInterface) +{ + m_shapeType = TRIANGLE_MESH_SHAPE_PROXYTYPE; + if (meshInterface->hasPremadeAabb()) + { + meshInterface->getPremadeAabb(&m_localAabbMin, &m_localAabbMax); + } + else + { + recalcLocalAabb(); + } +} + +btTriangleMeshShape::~btTriangleMeshShape() +{ +} + +void btTriangleMeshShape::getAabb(const btTransform& trans, btVector3& aabbMin, btVector3& aabbMax) const +{ + btVector3 localHalfExtents = btScalar(0.5) * (m_localAabbMax - m_localAabbMin); + localHalfExtents += btVector3(getMargin(), getMargin(), getMargin()); + btVector3 localCenter = btScalar(0.5) * (m_localAabbMax + m_localAabbMin); + + btMatrix3x3 abs_b = trans.getBasis().absolute(); + + btVector3 center = trans(localCenter); + + btVector3 extent = localHalfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]); + aabbMin = center - extent; + aabbMax = center + extent; +} + +void btTriangleMeshShape::recalcLocalAabb() +{ + for (int i = 0; i < 3; i++) + { + btVector3 vec(btScalar(0.), btScalar(0.), btScalar(0.)); + vec[i] = btScalar(1.); + btVector3 tmp = localGetSupportingVertex(vec); + m_localAabbMax[i] = tmp[i] + m_collisionMargin; + vec[i] = btScalar(-1.); + tmp = localGetSupportingVertex(vec); + m_localAabbMin[i] = tmp[i] - m_collisionMargin; + } +} + +class SupportVertexCallback : public btTriangleCallback +{ + btVector3 m_supportVertexLocal; + +public: + btTransform m_worldTrans; + btScalar m_maxDot; + btVector3 m_supportVecLocal; + + SupportVertexCallback(const btVector3& supportVecWorld, const btTransform& trans) + : m_supportVertexLocal(btScalar(0.), btScalar(0.), btScalar(0.)), m_worldTrans(trans), m_maxDot(btScalar(-BT_LARGE_FLOAT)) + + { + m_supportVecLocal = supportVecWorld * m_worldTrans.getBasis(); + } + + virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex) + { + (void)partId; + (void)triangleIndex; + for (int i = 0; i < 3; i++) + { + btScalar dot = m_supportVecLocal.dot(triangle[i]); + if (dot > m_maxDot) + { + m_maxDot = dot; + m_supportVertexLocal = triangle[i]; + } + } + } + + btVector3 GetSupportVertexWorldSpace() + { + return m_worldTrans(m_supportVertexLocal); + } + + btVector3 GetSupportVertexLocal() + { + return m_supportVertexLocal; + } +}; + +void btTriangleMeshShape::setLocalScaling(const btVector3& scaling) +{ + m_meshInterface->setScaling(scaling); + recalcLocalAabb(); +} + +const btVector3& btTriangleMeshShape::getLocalScaling() const +{ + return m_meshInterface->getScaling(); +} + +//#define DEBUG_TRIANGLE_MESH + +void btTriangleMeshShape::processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const +{ + struct FilteredCallback : public btInternalTriangleIndexCallback + { + btTriangleCallback* m_callback; + btVector3 m_aabbMin; + btVector3 m_aabbMax; + + FilteredCallback(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) + : m_callback(callback), + m_aabbMin(aabbMin), + m_aabbMax(aabbMax) + { + } + + virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex) + { + if (TestTriangleAgainstAabb2(&triangle[0], m_aabbMin, m_aabbMax)) + { + //check aabb in triangle-space, before doing this + m_callback->processTriangle(triangle, partId, triangleIndex); + } + } + }; + + FilteredCallback filterCallback(callback, aabbMin, aabbMax); + + m_meshInterface->InternalProcessAllTriangles(&filterCallback, aabbMin, aabbMax); +} + +void btTriangleMeshShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + (void)mass; + //moving concave objects not supported + btAssert(0); + inertia.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); +} + +btVector3 btTriangleMeshShape::localGetSupportingVertex(const btVector3& vec) const +{ + btVector3 supportVertex; + + btTransform ident; + ident.setIdentity(); + + SupportVertexCallback supportCallback(vec, ident); + + btVector3 aabbMax(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + + processAllTriangles(&supportCallback, -aabbMax, aabbMax); + + supportVertex = supportCallback.GetSupportVertexLocal(); + + return supportVertex; +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp.i new file mode 100644 index 00000000..346df0e9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleMeshShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleMeshShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleMeshShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.h new file mode 100644 index 00000000..4a70e283 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.h @@ -0,0 +1,82 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_TRIANGLE_MESH_SHAPE_H +#define BT_TRIANGLE_MESH_SHAPE_H + +#include "btConcaveShape.h" +#include "btStridingMeshInterface.h" + +///The btTriangleMeshShape is an internal concave triangle mesh interface. Don't use this class directly, use btBvhTriangleMeshShape instead. +ATTRIBUTE_ALIGNED16(class) +btTriangleMeshShape : public btConcaveShape +{ +protected: + btVector3 m_localAabbMin; + btVector3 m_localAabbMax; + btStridingMeshInterface* m_meshInterface; + + ///btTriangleMeshShape constructor has been disabled/protected, so that users will not mistakenly use this class. + ///Don't use btTriangleMeshShape but use btBvhTriangleMeshShape instead! + btTriangleMeshShape(btStridingMeshInterface * meshInterface); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + virtual ~btTriangleMeshShape(); + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const; + + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const + { + btAssert(0); + return localGetSupportingVertex(vec); + } + + void recalcLocalAabb(); + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void processAllTriangles(btTriangleCallback * callback, const btVector3& aabbMin, const btVector3& aabbMax) const; + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + virtual void setLocalScaling(const btVector3& scaling); + virtual const btVector3& getLocalScaling() const; + + btStridingMeshInterface* getMeshInterface() + { + return m_meshInterface; + } + + const btStridingMeshInterface* getMeshInterface() const + { + return m_meshInterface; + } + + const btVector3& getLocalAabbMin() const + { + return m_localAabbMin; + } + const btVector3& getLocalAabbMax() const + { + return m_localAabbMax; + } + + //debugging + virtual const char* getName() const { return "TRIANGLEMESH"; } +}; + +#endif //BT_TRIANGLE_MESH_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.h.i new file mode 100644 index 00000000..48312edd --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleMeshShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleMeshShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleMeshShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleMeshShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleShape.h new file mode 100644 index 00000000..190cbdae --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleShape.h @@ -0,0 +1,175 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_OBB_TRIANGLE_MINKOWSKI_H +#define BT_OBB_TRIANGLE_MINKOWSKI_H + +#include "btConvexShape.h" +#include "btBoxShape.h" + +ATTRIBUTE_ALIGNED16(class) +btTriangleShape : public btPolyhedralConvexShape +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btVector3 m_vertices1[3]; + + virtual int getNumVertices() const + { + return 3; + } + + btVector3& getVertexPtr(int index) + { + return m_vertices1[index]; + } + + const btVector3& getVertexPtr(int index) const + { + return m_vertices1[index]; + } + virtual void getVertex(int index, btVector3& vert) const + { + vert = m_vertices1[index]; + } + + virtual int getNumEdges() const + { + return 3; + } + + virtual void getEdge(int i, btVector3& pa, btVector3& pb) const + { + getVertex(i, pa); + getVertex((i + 1) % 3, pb); + } + + virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const + { + // btAssert(0); + getAabbSlow(t, aabbMin, aabbMax); + } + + btVector3 localGetSupportingVertexWithoutMargin(const btVector3& dir) const + { + btVector3 dots = dir.dot3(m_vertices1[0], m_vertices1[1], m_vertices1[2]); + return m_vertices1[dots.maxAxis()]; + } + + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const + { + for (int i = 0; i < numVectors; i++) + { + const btVector3& dir = vectors[i]; + btVector3 dots = dir.dot3(m_vertices1[0], m_vertices1[1], m_vertices1[2]); + supportVerticesOut[i] = m_vertices1[dots.maxAxis()]; + } + } + + btTriangleShape() : btPolyhedralConvexShape() + { + m_shapeType = TRIANGLE_SHAPE_PROXYTYPE; + } + + btTriangleShape(const btVector3& p0, const btVector3& p1, const btVector3& p2) : btPolyhedralConvexShape() + { + m_shapeType = TRIANGLE_SHAPE_PROXYTYPE; + m_vertices1[0] = p0; + m_vertices1[1] = p1; + m_vertices1[2] = p2; + } + + virtual void getPlane(btVector3 & planeNormal, btVector3 & planeSupport, int i) const + { + getPlaneEquation(i, planeNormal, planeSupport); + } + + virtual int getNumPlanes() const + { + return 1; + } + + void calcNormal(btVector3 & normal) const + { + normal = (m_vertices1[1] - m_vertices1[0]).cross(m_vertices1[2] - m_vertices1[0]); + normal.normalize(); + } + + virtual void getPlaneEquation(int i, btVector3& planeNormal, btVector3& planeSupport) const + { + (void)i; + calcNormal(planeNormal); + planeSupport = m_vertices1[0]; + } + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const + { + (void)mass; + btAssert(0); + inertia.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); + } + + virtual bool isInside(const btVector3& pt, btScalar tolerance) const + { + btVector3 normal; + calcNormal(normal); + //distance to plane + btScalar dist = pt.dot(normal); + btScalar planeconst = m_vertices1[0].dot(normal); + dist -= planeconst; + if (dist >= -tolerance && dist <= tolerance) + { + //inside check on edge-planes + int i; + for (i = 0; i < 3; i++) + { + btVector3 pa, pb; + getEdge(i, pa, pb); + btVector3 edge = pb - pa; + btVector3 edgeNormal = edge.cross(normal); + edgeNormal.normalize(); + btScalar dist = pt.dot(edgeNormal); + btScalar edgeConst = pa.dot(edgeNormal); + dist -= edgeConst; + if (dist < -tolerance) + return false; + } + + return true; + } + + return false; + } + //debugging + virtual const char* getName() const + { + return "Triangle"; + } + + virtual int getNumPreferredPenetrationDirections() const + { + return 2; + } + + virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const + { + calcNormal(penetrationVector); + if (index) + penetrationVector *= btScalar(-1.); + } +}; + +#endif //BT_OBB_TRIANGLE_MINKOWSKI_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleShape.h.i new file mode 100644 index 00000000..83bada30 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btTriangleShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btTriangleShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btTriangleShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btTriangleShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.cpp b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.cpp new file mode 100644 index 00000000..ed3cd2d2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.cpp @@ -0,0 +1,150 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btUniformScalingShape.h" + +btUniformScalingShape::btUniformScalingShape(btConvexShape* convexChildShape, btScalar uniformScalingFactor) : btConvexShape(), m_childConvexShape(convexChildShape), m_uniformScalingFactor(uniformScalingFactor) +{ + m_shapeType = UNIFORM_SCALING_SHAPE_PROXYTYPE; +} + +btUniformScalingShape::~btUniformScalingShape() +{ +} + +btVector3 btUniformScalingShape::localGetSupportingVertexWithoutMargin(const btVector3& vec) const +{ + btVector3 tmpVertex; + tmpVertex = m_childConvexShape->localGetSupportingVertexWithoutMargin(vec); + return tmpVertex * m_uniformScalingFactor; +} + +void btUniformScalingShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const +{ + m_childConvexShape->batchedUnitVectorGetSupportingVertexWithoutMargin(vectors, supportVerticesOut, numVectors); + int i; + for (i = 0; i < numVectors; i++) + { + supportVerticesOut[i] = supportVerticesOut[i] * m_uniformScalingFactor; + } +} + +btVector3 btUniformScalingShape::localGetSupportingVertex(const btVector3& vec) const +{ + btVector3 tmpVertex; + tmpVertex = m_childConvexShape->localGetSupportingVertex(vec); + return tmpVertex * m_uniformScalingFactor; +} + +void btUniformScalingShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const +{ + ///this linear upscaling is not realistic, but we don't deal with large mass ratios... + btVector3 tmpInertia; + m_childConvexShape->calculateLocalInertia(mass, tmpInertia); + inertia = tmpInertia * m_uniformScalingFactor; +} + +///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version +void btUniformScalingShape::getAabb(const btTransform& trans, btVector3& aabbMin, btVector3& aabbMax) const +{ + getAabbSlow(trans, aabbMin, aabbMax); +} + +void btUniformScalingShape::getAabbSlow(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const +{ +#if 1 + btVector3 _directions[] = + { + btVector3(1., 0., 0.), + btVector3(0., 1., 0.), + btVector3(0., 0., 1.), + btVector3(-1., 0., 0.), + btVector3(0., -1., 0.), + btVector3(0., 0., -1.)}; + + btVector3 _supporting[] = + { + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.), + btVector3(0., 0., 0.)}; + + for (int i = 0; i < 6; i++) + { + _directions[i] = _directions[i] * t.getBasis(); + } + + batchedUnitVectorGetSupportingVertexWithoutMargin(_directions, _supporting, 6); + + btVector3 aabbMin1(0, 0, 0), aabbMax1(0, 0, 0); + + for (int i = 0; i < 3; ++i) + { + aabbMax1[i] = t(_supporting[i])[i]; + aabbMin1[i] = t(_supporting[i + 3])[i]; + } + btVector3 marginVec(getMargin(), getMargin(), getMargin()); + aabbMin = aabbMin1 - marginVec; + aabbMax = aabbMax1 + marginVec; + +#else + + btScalar margin = getMargin(); + for (int i = 0; i < 3; i++) + { + btVector3 vec(btScalar(0.), btScalar(0.), btScalar(0.)); + vec[i] = btScalar(1.); + btVector3 sv = localGetSupportingVertex(vec * t.getBasis()); + btVector3 tmp = t(sv); + aabbMax[i] = tmp[i] + margin; + vec[i] = btScalar(-1.); + sv = localGetSupportingVertex(vec * t.getBasis()); + tmp = t(sv); + aabbMin[i] = tmp[i] - margin; + } + +#endif +} + +void btUniformScalingShape::setLocalScaling(const btVector3& scaling) +{ + m_childConvexShape->setLocalScaling(scaling); +} + +const btVector3& btUniformScalingShape::getLocalScaling() const +{ + return m_childConvexShape->getLocalScaling(); +} + +void btUniformScalingShape::setMargin(btScalar margin) +{ + m_childConvexShape->setMargin(margin); +} +btScalar btUniformScalingShape::getMargin() const +{ + return m_childConvexShape->getMargin() * m_uniformScalingFactor; +} + +int btUniformScalingShape::getNumPreferredPenetrationDirections() const +{ + return m_childConvexShape->getNumPreferredPenetrationDirections(); +} + +void btUniformScalingShape::getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const +{ + m_childConvexShape->getPreferredPenetrationDirection(index, penetrationVector); +} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.cpp.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.cpp.i new file mode 100644 index 00000000..8a7b0e1e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btUniformScalingShape.cpp ---------------- + +%include "BulletCollision/CollisionShapes/btUniformScalingShape.cpp" + +%{ +#include "BulletCollision/CollisionShapes/btUniformScalingShape.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.h b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.h new file mode 100644 index 00000000..4dfe34ef --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.h @@ -0,0 +1,84 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_UNIFORM_SCALING_SHAPE_H +#define BT_UNIFORM_SCALING_SHAPE_H + +#include "btConvexShape.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +///The btUniformScalingShape allows to re-use uniform scaled instances of btConvexShape in a memory efficient way. +///Istead of using btUniformScalingShape, it is better to use the non-uniform setLocalScaling method on convex shapes that implement it. +ATTRIBUTE_ALIGNED16(class) +btUniformScalingShape : public btConvexShape +{ + btConvexShape* m_childConvexShape; + + btScalar m_uniformScalingFactor; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btUniformScalingShape(btConvexShape * convexChildShape, btScalar uniformScalingFactor); + + virtual ~btUniformScalingShape(); + + virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const; + + virtual btVector3 localGetSupportingVertex(const btVector3& vec) const; + + virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const; + + virtual void calculateLocalInertia(btScalar mass, btVector3 & inertia) const; + + btScalar getUniformScalingFactor() const + { + return m_uniformScalingFactor; + } + + btConvexShape* getChildShape() + { + return m_childConvexShape; + } + + const btConvexShape* getChildShape() const + { + return m_childConvexShape; + } + + virtual const char* getName() const + { + return "UniformScalingShape"; + } + + /////////////////////////// + + ///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version + void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void getAabbSlow(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const; + + virtual void setLocalScaling(const btVector3& scaling); + virtual const btVector3& getLocalScaling() const; + + virtual void setMargin(btScalar margin); + virtual btScalar getMargin() const; + + virtual int getNumPreferredPenetrationDirections() const; + + virtual void getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const; +}; + +#endif //BT_UNIFORM_SCALING_SHAPE_H diff --git a/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.h.i b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.h.i new file mode 100644 index 00000000..5bb4abc1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/CollisionShapes/btUniformScalingShape.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/CollisionShapes/btUniformScalingShape.h ---------------- + +%include "BulletCollision/CollisionShapes/btUniformScalingShape.h" + +%{ +#include "BulletCollision/CollisionShapes/btUniformScalingShape.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h new file mode 100644 index 00000000..3c821330 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h @@ -0,0 +1,354 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2014 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_GJK_EPA_PENETATION_CONVEX_COLLISION_H +#define BT_GJK_EPA_PENETATION_CONVEX_COLLISION_H + +#include "LinearMath/btTransform.h" // Note that btVector3 might be double precision... +#include "btGjkEpa3.h" +#include "btGjkCollisionDescription.h" +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" + +template +bool btGjkEpaCalcPenDepth(const btConvexTemplate& a, const btConvexTemplate& b, + const btGjkCollisionDescription& colDesc, + btVector3& v, btVector3& wWitnessOnA, btVector3& wWitnessOnB) +{ + (void)v; + + // const btScalar radialmargin(btScalar(0.)); + + btVector3 guessVector(b.getWorldTransform().getOrigin() - a.getWorldTransform().getOrigin()); //?? why not use the GJK input? + + btGjkEpaSolver3::sResults results; + + if (btGjkEpaSolver3_Penetration(a, b, guessVector, results)) + + { + // debugDraw->drawLine(results.witnesses[1],results.witnesses[1]+results.normal,btVector3(255,0,0)); + //resultOut->addContactPoint(results.normal,results.witnesses[1],-results.depth); + wWitnessOnA = results.witnesses[0]; + wWitnessOnB = results.witnesses[1]; + v = results.normal; + return true; + } + else + { + if (btGjkEpaSolver3_Distance(a, b, guessVector, results)) + { + wWitnessOnA = results.witnesses[0]; + wWitnessOnB = results.witnesses[1]; + v = results.normal; + return false; + } + } + return false; +} + +template +int btComputeGjkEpaPenetration(const btConvexTemplate& a, const btConvexTemplate& b, const btGjkCollisionDescription& colDesc, btVoronoiSimplexSolver& simplexSolver, btGjkDistanceTemplate* distInfo) +{ + bool m_catchDegeneracies = true; + btScalar m_cachedSeparatingDistance = 0.f; + + btScalar distance = btScalar(0.); + btVector3 normalInB(btScalar(0.), btScalar(0.), btScalar(0.)); + + btVector3 pointOnA, pointOnB; + btTransform localTransA = a.getWorldTransform(); + btTransform localTransB = b.getWorldTransform(); + + btScalar marginA = a.getMargin(); + btScalar marginB = b.getMargin(); + + int m_curIter = 0; + int gGjkMaxIter = colDesc.m_maxGjkIterations; //this is to catch invalid input, perhaps check for #NaN? + btVector3 m_cachedSeparatingAxis = colDesc.m_firstDir; + + bool isValid = false; + bool checkSimplex = false; + bool checkPenetration = true; + int m_degenerateSimplex = 0; + + int m_lastUsedMethod = -1; + + { + btScalar squaredDistance = BT_LARGE_FLOAT; + btScalar delta = btScalar(0.); + + btScalar margin = marginA + marginB; + + simplexSolver.reset(); + + for (;;) + //while (true) + { + btVector3 separatingAxisInA = (-m_cachedSeparatingAxis) * localTransA.getBasis(); + btVector3 separatingAxisInB = m_cachedSeparatingAxis * localTransB.getBasis(); + + btVector3 pInA = a.getLocalSupportWithoutMargin(separatingAxisInA); + btVector3 qInB = b.getLocalSupportWithoutMargin(separatingAxisInB); + + btVector3 pWorld = localTransA(pInA); + btVector3 qWorld = localTransB(qInB); + + btVector3 w = pWorld - qWorld; + delta = m_cachedSeparatingAxis.dot(w); + + // potential exit, they don't overlap + if ((delta > btScalar(0.0)) && (delta * delta > squaredDistance * colDesc.m_maximumDistanceSquared)) + { + m_degenerateSimplex = 10; + checkSimplex = true; + //checkPenetration = false; + break; + } + + //exit 0: the new point is already in the simplex, or we didn't come any closer + if (simplexSolver.inSimplex(w)) + { + m_degenerateSimplex = 1; + checkSimplex = true; + break; + } + // are we getting any closer ? + btScalar f0 = squaredDistance - delta; + btScalar f1 = squaredDistance * colDesc.m_gjkRelError2; + + if (f0 <= f1) + { + if (f0 <= btScalar(0.)) + { + m_degenerateSimplex = 2; + } + else + { + m_degenerateSimplex = 11; + } + checkSimplex = true; + break; + } + + //add current vertex to simplex + simplexSolver.addVertex(w, pWorld, qWorld); + btVector3 newCachedSeparatingAxis; + + //calculate the closest point to the origin (update vector v) + if (!simplexSolver.closest(newCachedSeparatingAxis)) + { + m_degenerateSimplex = 3; + checkSimplex = true; + break; + } + + if (newCachedSeparatingAxis.length2() < colDesc.m_gjkRelError2) + { + m_cachedSeparatingAxis = newCachedSeparatingAxis; + m_degenerateSimplex = 6; + checkSimplex = true; + break; + } + + btScalar previousSquaredDistance = squaredDistance; + squaredDistance = newCachedSeparatingAxis.length2(); +#if 0 + ///warning: this termination condition leads to some problems in 2d test case see Bullet/Demos/Box2dDemo + if (squaredDistance>previousSquaredDistance) + { + m_degenerateSimplex = 7; + squaredDistance = previousSquaredDistance; + checkSimplex = false; + break; + } +#endif // + + //redundant m_simplexSolver->compute_points(pointOnA, pointOnB); + + //are we getting any closer ? + if (previousSquaredDistance - squaredDistance <= SIMD_EPSILON * previousSquaredDistance) + { + // m_simplexSolver->backup_closest(m_cachedSeparatingAxis); + checkSimplex = true; + m_degenerateSimplex = 12; + + break; + } + + m_cachedSeparatingAxis = newCachedSeparatingAxis; + + //degeneracy, this is typically due to invalid/uninitialized worldtransforms for a btCollisionObject + if (m_curIter++ > gGjkMaxIter) + { +#if defined(DEBUG) || defined(_DEBUG) + + printf("btGjkPairDetector maxIter exceeded:%i\n", m_curIter); + printf("sepAxis=(%f,%f,%f), squaredDistance = %f\n", + m_cachedSeparatingAxis.getX(), + m_cachedSeparatingAxis.getY(), + m_cachedSeparatingAxis.getZ(), + squaredDistance); +#endif + + break; + } + + bool check = (!simplexSolver.fullSimplex()); + //bool check = (!m_simplexSolver->fullSimplex() && squaredDistance > SIMD_EPSILON * m_simplexSolver->maxVertex()); + + if (!check) + { + //do we need this backup_closest here ? + // m_simplexSolver->backup_closest(m_cachedSeparatingAxis); + m_degenerateSimplex = 13; + break; + } + } + + if (checkSimplex) + { + simplexSolver.compute_points(pointOnA, pointOnB); + normalInB = m_cachedSeparatingAxis; + + btScalar lenSqr = m_cachedSeparatingAxis.length2(); + + //valid normal + if (lenSqr < 0.0001) + { + m_degenerateSimplex = 5; + } + if (lenSqr > SIMD_EPSILON * SIMD_EPSILON) + { + btScalar rlen = btScalar(1.) / btSqrt(lenSqr); + normalInB *= rlen; //normalize + + btScalar s = btSqrt(squaredDistance); + + btAssert(s > btScalar(0.0)); + pointOnA -= m_cachedSeparatingAxis * (marginA / s); + pointOnB += m_cachedSeparatingAxis * (marginB / s); + distance = ((btScalar(1.) / rlen) - margin); + isValid = true; + + m_lastUsedMethod = 1; + } + else + { + m_lastUsedMethod = 2; + } + } + + bool catchDegeneratePenetrationCase = + (m_catchDegeneracies && m_degenerateSimplex && ((distance + margin) < 0.01)); + + //if (checkPenetration && !isValid) + if (checkPenetration && (!isValid || catchDegeneratePenetrationCase)) + { + //penetration case + + //if there is no way to handle penetrations, bail out + + // Penetration depth case. + btVector3 tmpPointOnA, tmpPointOnB; + + m_cachedSeparatingAxis.setZero(); + + bool isValid2 = btGjkEpaCalcPenDepth(a, b, + colDesc, + m_cachedSeparatingAxis, tmpPointOnA, tmpPointOnB); + + if (isValid2) + { + btVector3 tmpNormalInB = tmpPointOnB - tmpPointOnA; + btScalar lenSqr = tmpNormalInB.length2(); + if (lenSqr <= (SIMD_EPSILON * SIMD_EPSILON)) + { + tmpNormalInB = m_cachedSeparatingAxis; + lenSqr = m_cachedSeparatingAxis.length2(); + } + + if (lenSqr > (SIMD_EPSILON * SIMD_EPSILON)) + { + tmpNormalInB /= btSqrt(lenSqr); + btScalar distance2 = -(tmpPointOnA - tmpPointOnB).length(); + //only replace valid penetrations when the result is deeper (check) + if (!isValid || (distance2 < distance)) + { + distance = distance2; + pointOnA = tmpPointOnA; + pointOnB = tmpPointOnB; + normalInB = tmpNormalInB; + + isValid = true; + m_lastUsedMethod = 3; + } + else + { + m_lastUsedMethod = 8; + } + } + else + { + m_lastUsedMethod = 9; + } + } + else + + { + ///this is another degenerate case, where the initial GJK calculation reports a degenerate case + ///EPA reports no penetration, and the second GJK (using the supporting vector without margin) + ///reports a valid positive distance. Use the results of the second GJK instead of failing. + ///thanks to Jacob.Langford for the reproduction case + ///http://code.google.com/p/bullet/issues/detail?id=250 + + if (m_cachedSeparatingAxis.length2() > btScalar(0.)) + { + btScalar distance2 = (tmpPointOnA - tmpPointOnB).length() - margin; + //only replace valid distances when the distance is less + if (!isValid || (distance2 < distance)) + { + distance = distance2; + pointOnA = tmpPointOnA; + pointOnB = tmpPointOnB; + pointOnA -= m_cachedSeparatingAxis * marginA; + pointOnB += m_cachedSeparatingAxis * marginB; + normalInB = m_cachedSeparatingAxis; + normalInB.normalize(); + + isValid = true; + m_lastUsedMethod = 6; + } + else + { + m_lastUsedMethod = 5; + } + } + } + } + } + + if (isValid && ((distance < 0) || (distance * distance < colDesc.m_maximumDistanceSquared))) + { + m_cachedSeparatingAxis = normalInB; + m_cachedSeparatingDistance = distance; + distInfo->m_distance = distance; + distInfo->m_normalBtoA = normalInB; + distInfo->m_pointOnB = pointOnB; + distInfo->m_pointOnA = pointOnB + normalInB * distance; + return 0; + } + return -m_lastUsedMethod; +} + +#endif //BT_GJK_EPA_PENETATION_CONVEX_COLLISION_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h.i new file mode 100644 index 00000000..1efd8c04 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp new file mode 100644 index 00000000..623c58fc --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp @@ -0,0 +1,222 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btContinuousConvexCollision.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h" +#include "LinearMath/btTransformUtil.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" + +#include "btGjkPairDetector.h" +#include "btPointCollector.h" +#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h" + +btContinuousConvexCollision::btContinuousConvexCollision(const btConvexShape* convexA, const btConvexShape* convexB, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* penetrationDepthSolver) + : m_simplexSolver(simplexSolver), + m_penetrationDepthSolver(penetrationDepthSolver), + m_convexA(convexA), + m_convexB1(convexB), + m_planeShape(0) +{ +} + +btContinuousConvexCollision::btContinuousConvexCollision(const btConvexShape* convexA, const btStaticPlaneShape* plane) + : m_simplexSolver(0), + m_penetrationDepthSolver(0), + m_convexA(convexA), + m_convexB1(0), + m_planeShape(plane) +{ +} + +/// This maximum should not be necessary. It allows for untested/degenerate cases in production code. +/// You don't want your game ever to lock-up. +#define MAX_ITERATIONS 64 + +void btContinuousConvexCollision::computeClosestPoints(const btTransform& transA, const btTransform& transB, btPointCollector& pointCollector) +{ + if (m_convexB1) + { + m_simplexSolver->reset(); + btGjkPairDetector gjk(m_convexA, m_convexB1, m_convexA->getShapeType(), m_convexB1->getShapeType(), m_convexA->getMargin(), m_convexB1->getMargin(), m_simplexSolver, m_penetrationDepthSolver); + btGjkPairDetector::ClosestPointInput input; + input.m_transformA = transA; + input.m_transformB = transB; + gjk.getClosestPoints(input, pointCollector, 0); + } + else + { + //convex versus plane + const btConvexShape* convexShape = m_convexA; + const btStaticPlaneShape* planeShape = m_planeShape; + + const btVector3& planeNormal = planeShape->getPlaneNormal(); + const btScalar& planeConstant = planeShape->getPlaneConstant(); + + btTransform convexWorldTransform = transA; + btTransform convexInPlaneTrans; + convexInPlaneTrans = transB.inverse() * convexWorldTransform; + btTransform planeInConvex; + planeInConvex = convexWorldTransform.inverse() * transB; + + btVector3 vtx = convexShape->localGetSupportingVertex(planeInConvex.getBasis() * -planeNormal); + + btVector3 vtxInPlane = convexInPlaneTrans(vtx); + btScalar distance = (planeNormal.dot(vtxInPlane) - planeConstant); + + btVector3 vtxInPlaneProjected = vtxInPlane - distance * planeNormal; + btVector3 vtxInPlaneWorld = transB * vtxInPlaneProjected; + btVector3 normalOnSurfaceB = transB.getBasis() * planeNormal; + + pointCollector.addContactPoint( + normalOnSurfaceB, + vtxInPlaneWorld, + distance); + } +} + +bool btContinuousConvexCollision::calcTimeOfImpact( + const btTransform& fromA, + const btTransform& toA, + const btTransform& fromB, + const btTransform& toB, + CastResult& result) +{ + /// compute linear and angular velocity for this interval, to interpolate + btVector3 linVelA, angVelA, linVelB, angVelB; + btTransformUtil::calculateVelocity(fromA, toA, btScalar(1.), linVelA, angVelA); + btTransformUtil::calculateVelocity(fromB, toB, btScalar(1.), linVelB, angVelB); + + btScalar boundingRadiusA = m_convexA->getAngularMotionDisc(); + btScalar boundingRadiusB = m_convexB1 ? m_convexB1->getAngularMotionDisc() : 0.f; + + btScalar maxAngularProjectedVelocity = angVelA.length() * boundingRadiusA + angVelB.length() * boundingRadiusB; + btVector3 relLinVel = (linVelB - linVelA); + + btScalar relLinVelocLength = (linVelB - linVelA).length(); + + if ((relLinVelocLength + maxAngularProjectedVelocity) == 0.f) + return false; + + btScalar lambda = btScalar(0.); + + btVector3 n; + n.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); + bool hasResult = false; + btVector3 c; + + btScalar lastLambda = lambda; + //btScalar epsilon = btScalar(0.001); + + int numIter = 0; + //first solution, using GJK + + btScalar radius = 0.001f; + // result.drawCoordSystem(sphereTr); + + btPointCollector pointCollector1; + + { + computeClosestPoints(fromA, fromB, pointCollector1); + + hasResult = pointCollector1.m_hasResult; + c = pointCollector1.m_pointInWorld; + } + + if (hasResult) + { + btScalar dist; + dist = pointCollector1.m_distance + result.m_allowedPenetration; + n = pointCollector1.m_normalOnBInWorld; + btScalar projectedLinearVelocity = relLinVel.dot(n); + if ((projectedLinearVelocity + maxAngularProjectedVelocity) <= SIMD_EPSILON) + return false; + + //not close enough + while (dist > radius) + { + if (result.m_debugDrawer) + { + result.m_debugDrawer->drawSphere(c, 0.2f, btVector3(1, 1, 1)); + } + btScalar dLambda = btScalar(0.); + + projectedLinearVelocity = relLinVel.dot(n); + + //don't report time of impact for motion away from the contact normal (or causes minor penetration) + if ((projectedLinearVelocity + maxAngularProjectedVelocity) <= SIMD_EPSILON) + return false; + + dLambda = dist / (projectedLinearVelocity + maxAngularProjectedVelocity); + + lambda += dLambda; + + if (lambda > btScalar(1.) || lambda < btScalar(0.)) + return false; + + //todo: next check with relative epsilon + if (lambda <= lastLambda) + { + return false; + //n.setValue(0,0,0); + //break; + } + lastLambda = lambda; + + //interpolate to next lambda + btTransform interpolatedTransA, interpolatedTransB, relativeTrans; + + btTransformUtil::integrateTransform(fromA, linVelA, angVelA, lambda, interpolatedTransA); + btTransformUtil::integrateTransform(fromB, linVelB, angVelB, lambda, interpolatedTransB); + relativeTrans = interpolatedTransB.inverseTimes(interpolatedTransA); + + if (result.m_debugDrawer) + { + result.m_debugDrawer->drawSphere(interpolatedTransA.getOrigin(), 0.2f, btVector3(1, 0, 0)); + } + + result.DebugDraw(lambda); + + btPointCollector pointCollector; + computeClosestPoints(interpolatedTransA, interpolatedTransB, pointCollector); + + if (pointCollector.m_hasResult) + { + dist = pointCollector.m_distance + result.m_allowedPenetration; + c = pointCollector.m_pointInWorld; + n = pointCollector.m_normalOnBInWorld; + } + else + { + result.reportFailure(-1, numIter); + return false; + } + + numIter++; + if (numIter > MAX_ITERATIONS) + { + result.reportFailure(-2, numIter); + return false; + } + } + + result.m_fraction = lambda; + result.m_normal = n; + result.m_hitPoint = c; + return true; + } + + return false; +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp.i new file mode 100644 index 00000000..3c69b7c4 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp ---------------- + +// %include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h new file mode 100644 index 00000000..76c7731e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h @@ -0,0 +1,53 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONTINUOUS_COLLISION_CONVEX_CAST_H +#define BT_CONTINUOUS_COLLISION_CONVEX_CAST_H + +#include "btConvexCast.h" +#include "btSimplexSolverInterface.h" +class btConvexPenetrationDepthSolver; +class btConvexShape; +class btStaticPlaneShape; + +/// btContinuousConvexCollision implements angular and linear time of impact for convex objects. +/// Based on Brian Mirtich's Conservative Advancement idea (PhD thesis). +/// Algorithm operates in worldspace, in order to keep in between motion globally consistent. +/// It uses GJK at the moment. Future improvement would use minkowski sum / supporting vertex, merging innerloops +class btContinuousConvexCollision : public btConvexCast +{ + btSimplexSolverInterface* m_simplexSolver; + btConvexPenetrationDepthSolver* m_penetrationDepthSolver; + const btConvexShape* m_convexA; + //second object is either a convex or a plane (code sharing) + const btConvexShape* m_convexB1; + const btStaticPlaneShape* m_planeShape; + + void computeClosestPoints(const btTransform& transA, const btTransform& transB, struct btPointCollector& pointCollector); + +public: + btContinuousConvexCollision(const btConvexShape* shapeA, const btConvexShape* shapeB, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* penetrationDepthSolver); + + btContinuousConvexCollision(const btConvexShape* shapeA, const btStaticPlaneShape* plane); + + virtual bool calcTimeOfImpact( + const btTransform& fromA, + const btTransform& toA, + const btTransform& fromB, + const btTransform& toB, + CastResult& result); +}; + +#endif //BT_CONTINUOUS_COLLISION_CONVEX_CAST_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h.i new file mode 100644 index 00000000..2c9647ce --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.cpp new file mode 100644 index 00000000..f5b9b682 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.cpp @@ -0,0 +1,20 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btConvexCast.h" + +btConvexCast::~btConvexCast() +{ +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.cpp.i new file mode 100644 index 00000000..6dbd247d --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btConvexCast.cpp ---------------- + +// %include "BulletCollision/NarrowPhaseCollision/btConvexCast.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btConvexCast.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.h new file mode 100644 index 00000000..85476e61 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.h @@ -0,0 +1,90 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_CAST_H +#define BT_CONVEX_CAST_H + +#include "LinearMath/btTransform.h" +#include "LinearMath/btVector3.h" +#include "LinearMath/btScalar.h" +class btMinkowskiSumShape; +#include "LinearMath/btIDebugDraw.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define MAX_CONVEX_CAST_ITERATIONS 64 +#define MAX_CONVEX_CAST_EPSILON (SIMD_EPSILON * 10) +#else +#define MAX_CONVEX_CAST_ITERATIONS 32 +#define MAX_CONVEX_CAST_EPSILON btScalar(0.0001) +#endif +///Typically the conservative advancement reaches solution in a few iterations, clip it to 32 for degenerate cases. +///See discussion about this here https://bulletphysics.orgphpBB2/viewtopic.php?t=565 +//will need to digg deeper to make the algorithm more robust +//since, a large epsilon can cause an early termination with false +//positive results (ray intersections that shouldn't be there) + +/// btConvexCast is an interface for Casting +class btConvexCast +{ +public: + virtual ~btConvexCast(); + + ///RayResult stores the closest result + /// alternatively, add a callback method to decide about closest/all results + struct CastResult + { + //virtual bool addRayResult(const btVector3& normal,btScalar fraction) = 0; + + virtual void DebugDraw(btScalar fraction) { (void)fraction; } + virtual void drawCoordSystem(const btTransform& trans) { (void)trans; } + virtual void reportFailure(int errNo, int numIterations) + { + (void)errNo; + (void)numIterations; + } + CastResult() + : m_fraction(btScalar(BT_LARGE_FLOAT)), + m_debugDrawer(0), + m_allowedPenetration(btScalar(0)), + m_subSimplexCastMaxIterations(MAX_CONVEX_CAST_ITERATIONS), + m_subSimplexCastEpsilon(MAX_CONVEX_CAST_EPSILON) + { + } + + virtual ~CastResult(){}; + + btTransform m_hitTransformA; + btTransform m_hitTransformB; + btVector3 m_normal; + btVector3 m_hitPoint; + btScalar m_fraction; //input and output + btIDebugDraw* m_debugDrawer; + btScalar m_allowedPenetration; + + int m_subSimplexCastMaxIterations; + btScalar m_subSimplexCastEpsilon; + + }; + + /// cast a convex against another convex object + virtual bool calcTimeOfImpact( + const btTransform& fromA, + const btTransform& toA, + const btTransform& fromB, + const btTransform& toB, + CastResult& result) = 0; +}; + +#endif //BT_CONVEX_CAST_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.h.i new file mode 100644 index 00000000..af6dedb5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexCast.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btConvexCast.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btConvexCast.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btConvexCast.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h new file mode 100644 index 00000000..7672a412 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h @@ -0,0 +1,35 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONVEX_PENETRATION_DEPTH_H +#define BT_CONVEX_PENETRATION_DEPTH_H + +class btVector3; +#include "btSimplexSolverInterface.h" +class btConvexShape; +class btTransform; + +///ConvexPenetrationDepthSolver provides an interface for penetration depth calculation. +class btConvexPenetrationDepthSolver +{ +public: + virtual ~btConvexPenetrationDepthSolver(){}; + virtual bool calcPenDepth(btSimplexSolverInterface& simplexSolver, + const btConvexShape* convexA, const btConvexShape* convexB, + const btTransform& transA, const btTransform& transB, + btVector3& v, btVector3& pa, btVector3& pb, + class btIDebugDraw* debugDraw) = 0; +}; +#endif //BT_CONVEX_PENETRATION_DEPTH_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h.i new file mode 100644 index 00000000..2e0b40c2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h new file mode 100644 index 00000000..973975f3 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h @@ -0,0 +1,85 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H +#define BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H + +#include "LinearMath/btTransform.h" +#include "LinearMath/btVector3.h" + +/// This interface is made to be used by an iterative approach to do TimeOfImpact calculations +/// This interface allows to query for closest points and penetration depth between two (convex) objects +/// the closest point is on the second object (B), and the normal points from the surface on B towards A. +/// distance is between closest points on B and closest point on A. So you can calculate closest point on A +/// by taking closestPointInA = closestPointInB + m_distance * m_normalOnSurfaceB +struct btDiscreteCollisionDetectorInterface +{ + struct Result + { + virtual ~Result() {} + + ///setShapeIdentifiersA/B provides experimental support for per-triangle material / custom material combiner + virtual void setShapeIdentifiersA(int partId0, int index0) = 0; + virtual void setShapeIdentifiersB(int partId1, int index1) = 0; + virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth) = 0; + }; + + struct ClosestPointInput + { + ClosestPointInput() + : m_maximumDistanceSquared(btScalar(BT_LARGE_FLOAT)) + { + } + + btTransform m_transformA; + btTransform m_transformB; + btScalar m_maximumDistanceSquared; + }; + + virtual ~btDiscreteCollisionDetectorInterface(){}; + + // + // give either closest points (distance > 0) or penetration (distance) + // the normal always points from B towards A + // + virtual void getClosestPoints(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw, bool swapResults = false) = 0; +}; + +struct btStorageResult : public btDiscreteCollisionDetectorInterface::Result +{ + btVector3 m_normalOnSurfaceB; + btVector3 m_closestPointInB; + btScalar m_distance; //negative means penetration ! + +protected: + btStorageResult() : m_distance(btScalar(BT_LARGE_FLOAT)) + { + } + +public: + virtual ~btStorageResult(){}; + + virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth) + { + if (depth < m_distance) + { + m_normalOnSurfaceB = normalOnBInWorld; + m_closestPointInB = pointInWorld; + m_distance = depth; + } + } +}; + +#endif //BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h.i new file mode 100644 index 00000000..9ce3cb7b --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h new file mode 100644 index 00000000..c9fd84be --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h @@ -0,0 +1,39 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2014 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef GJK_COLLISION_DESCRIPTION_H +#define GJK_COLLISION_DESCRIPTION_H + +#include "LinearMath/btVector3.h" + +struct btGjkCollisionDescription +{ + btVector3 m_firstDir; + int m_maxGjkIterations; + btScalar m_maximumDistanceSquared; + btScalar m_gjkRelError2; + btGjkCollisionDescription() + : m_firstDir(0, 1, 0), + m_maxGjkIterations(1000), + m_maximumDistanceSquared(1e30f), + m_gjkRelError2(1.0e-6) + { + } + virtual ~btGjkCollisionDescription() + { + } +}; + +#endif //GJK_COLLISION_DESCRIPTION_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h.i new file mode 100644 index 00000000..e3410754 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp new file mode 100644 index 00000000..41da6998 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp @@ -0,0 +1,164 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btGjkConvexCast.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" +#include "btGjkPairDetector.h" +#include "btPointCollector.h" +#include "LinearMath/btTransformUtil.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define MAX_ITERATIONS 64 +#else +#define MAX_ITERATIONS 32 +#endif + +btGjkConvexCast::btGjkConvexCast(const btConvexShape* convexA, const btConvexShape* convexB, btSimplexSolverInterface* simplexSolver) + : m_simplexSolver(simplexSolver), + m_convexA(convexA), + m_convexB(convexB) +{ +} + +bool btGjkConvexCast::calcTimeOfImpact( + const btTransform& fromA, + const btTransform& toA, + const btTransform& fromB, + const btTransform& toB, + CastResult& result) +{ + m_simplexSolver->reset(); + + /// compute linear velocity for this interval, to interpolate + //assume no rotation/angular velocity, assert here? + btVector3 linVelA, linVelB; + linVelA = toA.getOrigin() - fromA.getOrigin(); + linVelB = toB.getOrigin() - fromB.getOrigin(); + + btScalar radius = btScalar(0.001); + btScalar lambda = btScalar(0.); + btVector3 v(1, 0, 0); + + int maxIter = MAX_ITERATIONS; + + btVector3 n; + n.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); + bool hasResult = false; + btVector3 c; + btVector3 r = (linVelA - linVelB); + + btScalar lastLambda = lambda; + //btScalar epsilon = btScalar(0.001); + + int numIter = 0; + //first solution, using GJK + + btTransform identityTrans; + identityTrans.setIdentity(); + + // result.drawCoordSystem(sphereTr); + + btPointCollector pointCollector; + + btGjkPairDetector gjk(m_convexA, m_convexB, m_simplexSolver, 0); //m_penetrationDepthSolver); + btGjkPairDetector::ClosestPointInput input; + + //we don't use margins during CCD + // gjk.setIgnoreMargin(true); + + input.m_transformA = fromA; + input.m_transformB = fromB; + gjk.getClosestPoints(input, pointCollector, 0); + + hasResult = pointCollector.m_hasResult; + c = pointCollector.m_pointInWorld; + + if (hasResult) + { + btScalar dist; + dist = pointCollector.m_distance; + n = pointCollector.m_normalOnBInWorld; + + //not close enough + while (dist > radius) + { + numIter++; + if (numIter > maxIter) + { + return false; //todo: report a failure + } + btScalar dLambda = btScalar(0.); + + btScalar projectedLinearVelocity = r.dot(n); + + dLambda = dist / (projectedLinearVelocity); + + lambda = lambda - dLambda; + + if (lambda > btScalar(1.)) + return false; + + if (lambda < btScalar(0.)) + return false; + + //todo: next check with relative epsilon + if (lambda <= lastLambda) + { + return false; + //n.setValue(0,0,0); + break; + } + lastLambda = lambda; + + //interpolate to next lambda + result.DebugDraw(lambda); + input.m_transformA.getOrigin().setInterpolate3(fromA.getOrigin(), toA.getOrigin(), lambda); + input.m_transformB.getOrigin().setInterpolate3(fromB.getOrigin(), toB.getOrigin(), lambda); + + gjk.getClosestPoints(input, pointCollector, 0); + if (pointCollector.m_hasResult) + { + if (pointCollector.m_distance < btScalar(0.)) + { + result.m_fraction = lastLambda; + n = pointCollector.m_normalOnBInWorld; + result.m_normal = n; + result.m_hitPoint = pointCollector.m_pointInWorld; + return true; + } + c = pointCollector.m_pointInWorld; + n = pointCollector.m_normalOnBInWorld; + dist = pointCollector.m_distance; + } + else + { + //?? + return false; + } + } + + //is n normalized? + //don't report time of impact for motion away from the contact normal (or causes minor penetration) + if (n.dot(r) >= -result.m_allowedPenetration) + return false; + + result.m_fraction = lambda; + result.m_normal = n; + result.m_hitPoint = c; + return true; + } + + return false; +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp.i new file mode 100644 index 00000000..4fe078eb --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp ---------------- + +// %include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h new file mode 100644 index 00000000..0ee46a59 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h @@ -0,0 +1,46 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_GJK_CONVEX_CAST_H +#define BT_GJK_CONVEX_CAST_H + +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" + +#include "LinearMath/btVector3.h" +#include "btConvexCast.h" +class btConvexShape; +class btMinkowskiSumShape; +#include "btSimplexSolverInterface.h" + +///GjkConvexCast performs a raycast on a convex object using support mapping. +class btGjkConvexCast : public btConvexCast +{ + btSimplexSolverInterface* m_simplexSolver; + const btConvexShape* m_convexA; + const btConvexShape* m_convexB; + +public: + btGjkConvexCast(const btConvexShape* convexA, const btConvexShape* convexB, btSimplexSolverInterface* simplexSolver); + + /// cast a convex against another convex object + virtual bool calcTimeOfImpact( + const btTransform& fromA, + const btTransform& toA, + const btTransform& fromB, + const btTransform& toB, + CastResult& result); +}; + +#endif //BT_GJK_CONVEX_CAST_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h.i new file mode 100644 index 00000000..2bd1bf33 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp new file mode 100644 index 00000000..22886047 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp @@ -0,0 +1,1104 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the +use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not +claim that you wrote the original software. If you use this software in a +product, an acknowledgment in the product documentation would be appreciated +but is not required. +2. Altered source versions must be plainly marked as such, and must not be +misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +GJK-EPA collision solver by Nathanael Presson, 2008 +*/ +#include "BulletCollision/CollisionShapes/btConvexInternalShape.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" +#include "btGjkEpa2.h" + +#if defined(DEBUG) || defined(_DEBUG) +#include //for debug printf +#ifdef __SPU__ +#include +#define printf spu_printf +#endif //__SPU__ +#endif + +namespace gjkepa2_impl +{ +// Config + +/* GJK */ +#define GJK_MAX_ITERATIONS 128 + +#ifdef BT_USE_DOUBLE_PRECISION +#define GJK_ACCURACY ((btScalar)1e-12) +#define GJK_MIN_DISTANCE ((btScalar)1e-12) +#define GJK_DUPLICATED_EPS ((btScalar)1e-12) +#else +#define GJK_ACCURACY ((btScalar)0.0001) +#define GJK_MIN_DISTANCE ((btScalar)0.0001) +#define GJK_DUPLICATED_EPS ((btScalar)0.0001) +#endif //BT_USE_DOUBLE_PRECISION + +#define GJK_SIMPLEX2_EPS ((btScalar)0.0) +#define GJK_SIMPLEX3_EPS ((btScalar)0.0) +#define GJK_SIMPLEX4_EPS ((btScalar)0.0) + +/* EPA */ +#define EPA_MAX_VERTICES 128 +#define EPA_MAX_ITERATIONS 255 + +#ifdef BT_USE_DOUBLE_PRECISION +#define EPA_ACCURACY ((btScalar)1e-12) +#define EPA_PLANE_EPS ((btScalar)1e-14) +#define EPA_INSIDE_EPS ((btScalar)1e-9) +#else +#define EPA_ACCURACY ((btScalar)0.0001) +#define EPA_PLANE_EPS ((btScalar)0.00001) +#define EPA_INSIDE_EPS ((btScalar)0.01) +#endif + +#define EPA_FALLBACK (10 * EPA_ACCURACY) +#define EPA_MAX_FACES (EPA_MAX_VERTICES * 2) + +// Shorthands +typedef unsigned int U; +typedef unsigned char U1; + +// MinkowskiDiff +struct MinkowskiDiff +{ + const btConvexShape* m_shapes[2]; + btMatrix3x3 m_toshape1; + btTransform m_toshape0; +#ifdef __SPU__ + bool m_enableMargin; +#else + btVector3 (btConvexShape::*Ls)(const btVector3&) const; +#endif //__SPU__ + + MinkowskiDiff() + { + } +#ifdef __SPU__ + void EnableMargin(bool enable) + { + m_enableMargin = enable; + } + inline btVector3 Support0(const btVector3& d) const + { + if (m_enableMargin) + { + return m_shapes[0]->localGetSupportVertexNonVirtual(d); + } + else + { + return m_shapes[0]->localGetSupportVertexWithoutMarginNonVirtual(d); + } + } + inline btVector3 Support1(const btVector3& d) const + { + if (m_enableMargin) + { + return m_toshape0 * (m_shapes[1]->localGetSupportVertexNonVirtual(m_toshape1 * d)); + } + else + { + return m_toshape0 * (m_shapes[1]->localGetSupportVertexWithoutMarginNonVirtual(m_toshape1 * d)); + } + } +#else + void EnableMargin(bool enable) + { + if (enable) + Ls = &btConvexShape::localGetSupportVertexNonVirtual; + else + Ls = &btConvexShape::localGetSupportVertexWithoutMarginNonVirtual; + } + inline btVector3 Support0(const btVector3& d) const + { + return (((m_shapes[0])->*(Ls))(d)); + } + inline btVector3 Support1(const btVector3& d) const + { + return (m_toshape0 * ((m_shapes[1])->*(Ls))(m_toshape1 * d)); + } +#endif //__SPU__ + + inline btVector3 Support(const btVector3& d) const + { + return (Support0(d) - Support1(-d)); + } + btVector3 Support(const btVector3& d, U index) const + { + if (index) + return (Support1(d)); + else + return (Support0(d)); + } +}; + +typedef MinkowskiDiff tShape; + +// GJK +struct GJK +{ + /* Types */ + struct sSV + { + btVector3 d, w; + }; + struct sSimplex + { + sSV* c[4]; + btScalar p[4]; + U rank; + }; + struct eStatus + { + enum _ + { + Valid, + Inside, + Failed + }; + }; + /* Fields */ + tShape m_shape; + btVector3 m_ray; + btScalar m_distance; + sSimplex m_simplices[2]; + sSV m_store[4]; + sSV* m_free[4]; + U m_nfree; + U m_current; + sSimplex* m_simplex; + eStatus::_ m_status; + /* Methods */ + GJK() + { + Initialize(); + } + void Initialize() + { + m_ray = btVector3(0, 0, 0); + m_nfree = 0; + m_status = eStatus::Failed; + m_current = 0; + m_distance = 0; + } + eStatus::_ Evaluate(const tShape& shapearg, const btVector3& guess) + { + U iterations = 0; + btScalar sqdist = 0; + btScalar alpha = 0; + btVector3 lastw[4]; + U clastw = 0; + /* Initialize solver */ + m_free[0] = &m_store[0]; + m_free[1] = &m_store[1]; + m_free[2] = &m_store[2]; + m_free[3] = &m_store[3]; + m_nfree = 4; + m_current = 0; + m_status = eStatus::Valid; + m_shape = shapearg; + m_distance = 0; + /* Initialize simplex */ + m_simplices[0].rank = 0; + m_ray = guess; + const btScalar sqrl = m_ray.length2(); + appendvertice(m_simplices[0], sqrl > 0 ? -m_ray : btVector3(1, 0, 0)); + m_simplices[0].p[0] = 1; + m_ray = m_simplices[0].c[0]->w; + sqdist = sqrl; + lastw[0] = + lastw[1] = + lastw[2] = + lastw[3] = m_ray; + /* Loop */ + do + { + const U next = 1 - m_current; + sSimplex& cs = m_simplices[m_current]; + sSimplex& ns = m_simplices[next]; + /* Check zero */ + const btScalar rl = m_ray.length(); + if (rl < GJK_MIN_DISTANCE) + { /* Touching or inside */ + m_status = eStatus::Inside; + break; + } + /* Append new vertice in -'v' direction */ + appendvertice(cs, -m_ray); + const btVector3& w = cs.c[cs.rank - 1]->w; + bool found = false; + for (U i = 0; i < 4; ++i) + { + if ((w - lastw[i]).length2() < GJK_DUPLICATED_EPS) + { + found = true; + break; + } + } + if (found) + { /* Return old simplex */ + removevertice(m_simplices[m_current]); + break; + } + else + { /* Update lastw */ + lastw[clastw = (clastw + 1) & 3] = w; + } + /* Check for termination */ + const btScalar omega = btDot(m_ray, w) / rl; + alpha = btMax(omega, alpha); + if (((rl - alpha) - (GJK_ACCURACY * rl)) <= 0) + { /* Return old simplex */ + removevertice(m_simplices[m_current]); + break; + } + /* Reduce simplex */ + btScalar weights[4]; + U mask = 0; + switch (cs.rank) + { + case 2: + sqdist = projectorigin(cs.c[0]->w, + cs.c[1]->w, + weights, mask); + break; + case 3: + sqdist = projectorigin(cs.c[0]->w, + cs.c[1]->w, + cs.c[2]->w, + weights, mask); + break; + case 4: + sqdist = projectorigin(cs.c[0]->w, + cs.c[1]->w, + cs.c[2]->w, + cs.c[3]->w, + weights, mask); + break; + } + if (sqdist >= 0) + { /* Valid */ + ns.rank = 0; + m_ray = btVector3(0, 0, 0); + m_current = next; + for (U i = 0, ni = cs.rank; i < ni; ++i) + { + if (mask & (1 << i)) + { + ns.c[ns.rank] = cs.c[i]; + ns.p[ns.rank++] = weights[i]; + m_ray += cs.c[i]->w * weights[i]; + } + else + { + m_free[m_nfree++] = cs.c[i]; + } + } + if (mask == 15) m_status = eStatus::Inside; + } + else + { /* Return old simplex */ + removevertice(m_simplices[m_current]); + break; + } + m_status = ((++iterations) < GJK_MAX_ITERATIONS) ? m_status : eStatus::Failed; + } while (m_status == eStatus::Valid); + m_simplex = &m_simplices[m_current]; + switch (m_status) + { + case eStatus::Valid: + m_distance = m_ray.length(); + break; + case eStatus::Inside: + m_distance = 0; + break; + default: + { + } + } + return (m_status); + } + bool EncloseOrigin() + { + switch (m_simplex->rank) + { + case 1: + { + for (U i = 0; i < 3; ++i) + { + btVector3 axis = btVector3(0, 0, 0); + axis[i] = 1; + appendvertice(*m_simplex, axis); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + appendvertice(*m_simplex, -axis); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + } + } + break; + case 2: + { + const btVector3 d = m_simplex->c[1]->w - m_simplex->c[0]->w; + for (U i = 0; i < 3; ++i) + { + btVector3 axis = btVector3(0, 0, 0); + axis[i] = 1; + const btVector3 p = btCross(d, axis); + if (p.length2() > 0) + { + appendvertice(*m_simplex, p); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + appendvertice(*m_simplex, -p); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + } + } + } + break; + case 3: + { + const btVector3 n = btCross(m_simplex->c[1]->w - m_simplex->c[0]->w, + m_simplex->c[2]->w - m_simplex->c[0]->w); + if (n.length2() > 0) + { + appendvertice(*m_simplex, n); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + appendvertice(*m_simplex, -n); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + } + } + break; + case 4: + { + if (btFabs(det(m_simplex->c[0]->w - m_simplex->c[3]->w, + m_simplex->c[1]->w - m_simplex->c[3]->w, + m_simplex->c[2]->w - m_simplex->c[3]->w)) > 0) + return (true); + } + break; + } + return (false); + } + /* Internals */ + void getsupport(const btVector3& d, sSV& sv) const + { + sv.d = d / d.length(); + sv.w = m_shape.Support(sv.d); + } + void removevertice(sSimplex& simplex) + { + m_free[m_nfree++] = simplex.c[--simplex.rank]; + } + void appendvertice(sSimplex& simplex, const btVector3& v) + { + simplex.p[simplex.rank] = 0; + simplex.c[simplex.rank] = m_free[--m_nfree]; + getsupport(v, *simplex.c[simplex.rank++]); + } + static btScalar det(const btVector3& a, const btVector3& b, const btVector3& c) + { + return (a.y() * b.z() * c.x() + a.z() * b.x() * c.y() - + a.x() * b.z() * c.y() - a.y() * b.x() * c.z() + + a.x() * b.y() * c.z() - a.z() * b.y() * c.x()); + } + static btScalar projectorigin(const btVector3& a, + const btVector3& b, + btScalar* w, U& m) + { + const btVector3 d = b - a; + const btScalar l = d.length2(); + if (l > GJK_SIMPLEX2_EPS) + { + const btScalar t(l > 0 ? -btDot(a, d) / l : 0); + if (t >= 1) + { + w[0] = 0; + w[1] = 1; + m = 2; + return (b.length2()); + } + else if (t <= 0) + { + w[0] = 1; + w[1] = 0; + m = 1; + return (a.length2()); + } + else + { + w[0] = 1 - (w[1] = t); + m = 3; + return ((a + d * t).length2()); + } + } + return (-1); + } + static btScalar projectorigin(const btVector3& a, + const btVector3& b, + const btVector3& c, + btScalar* w, U& m) + { + static const U imd3[] = {1, 2, 0}; + const btVector3* vt[] = {&a, &b, &c}; + const btVector3 dl[] = {a - b, b - c, c - a}; + const btVector3 n = btCross(dl[0], dl[1]); + const btScalar l = n.length2(); + if (l > GJK_SIMPLEX3_EPS) + { + btScalar mindist = -1; + btScalar subw[2] = {0.f, 0.f}; + U subm(0); + for (U i = 0; i < 3; ++i) + { + if (btDot(*vt[i], btCross(dl[i], n)) > 0) + { + const U j = imd3[i]; + const btScalar subd(projectorigin(*vt[i], *vt[j], subw, subm)); + if ((mindist < 0) || (subd < mindist)) + { + mindist = subd; + m = static_cast(((subm & 1) ? 1 << i : 0) + ((subm & 2) ? 1 << j : 0)); + w[i] = subw[0]; + w[j] = subw[1]; + w[imd3[j]] = 0; + } + } + } + if (mindist < 0) + { + const btScalar d = btDot(a, n); + const btScalar s = btSqrt(l); + const btVector3 p = n * (d / l); + mindist = p.length2(); + m = 7; + w[0] = (btCross(dl[1], b - p)).length() / s; + w[1] = (btCross(dl[2], c - p)).length() / s; + w[2] = 1 - (w[0] + w[1]); + } + return (mindist); + } + return (-1); + } + static btScalar projectorigin(const btVector3& a, + const btVector3& b, + const btVector3& c, + const btVector3& d, + btScalar* w, U& m) + { + static const U imd3[] = {1, 2, 0}; + const btVector3* vt[] = {&a, &b, &c, &d}; + const btVector3 dl[] = {a - d, b - d, c - d}; + const btScalar vl = det(dl[0], dl[1], dl[2]); + const bool ng = (vl * btDot(a, btCross(b - c, a - b))) <= 0; + if (ng && (btFabs(vl) > GJK_SIMPLEX4_EPS)) + { + btScalar mindist = -1; + btScalar subw[3] = {0.f, 0.f, 0.f}; + U subm(0); + for (U i = 0; i < 3; ++i) + { + const U j = imd3[i]; + const btScalar s = vl * btDot(d, btCross(dl[i], dl[j])); + if (s > 0) + { + const btScalar subd = projectorigin(*vt[i], *vt[j], d, subw, subm); + if ((mindist < 0) || (subd < mindist)) + { + mindist = subd; + m = static_cast((subm & 1 ? 1 << i : 0) + + (subm & 2 ? 1 << j : 0) + + (subm & 4 ? 8 : 0)); + w[i] = subw[0]; + w[j] = subw[1]; + w[imd3[j]] = 0; + w[3] = subw[2]; + } + } + } + if (mindist < 0) + { + mindist = 0; + m = 15; + w[0] = det(c, b, d) / vl; + w[1] = det(a, c, d) / vl; + w[2] = det(b, a, d) / vl; + w[3] = 1 - (w[0] + w[1] + w[2]); + } + return (mindist); + } + return (-1); + } +}; + +// EPA +struct EPA +{ + /* Types */ + typedef GJK::sSV sSV; + struct sFace + { + btVector3 n; + btScalar d; + sSV* c[3]; + sFace* f[3]; + sFace* l[2]; + U1 e[3]; + U1 pass; + }; + struct sList + { + sFace* root; + U count; + sList() : root(0), count(0) {} + }; + struct sHorizon + { + sFace* cf; + sFace* ff; + U nf; + sHorizon() : cf(0), ff(0), nf(0) {} + }; + struct eStatus + { + enum _ + { + Valid, + Touching, + Degenerated, + NonConvex, + InvalidHull, + OutOfFaces, + OutOfVertices, + AccuraryReached, + FallBack, + Failed + }; + }; + /* Fields */ + eStatus::_ m_status; + GJK::sSimplex m_result; + btVector3 m_normal; + btScalar m_depth; + sSV m_sv_store[EPA_MAX_VERTICES]; + sFace m_fc_store[EPA_MAX_FACES]; + U m_nextsv; + sList m_hull; + sList m_stock; + /* Methods */ + EPA() + { + Initialize(); + } + + static inline void bind(sFace* fa, U ea, sFace* fb, U eb) + { + fa->e[ea] = (U1)eb; + fa->f[ea] = fb; + fb->e[eb] = (U1)ea; + fb->f[eb] = fa; + } + static inline void append(sList& list, sFace* face) + { + face->l[0] = 0; + face->l[1] = list.root; + if (list.root) list.root->l[0] = face; + list.root = face; + ++list.count; + } + static inline void remove(sList& list, sFace* face) + { + if (face->l[1]) face->l[1]->l[0] = face->l[0]; + if (face->l[0]) face->l[0]->l[1] = face->l[1]; + if (face == list.root) list.root = face->l[1]; + --list.count; + } + + void Initialize() + { + m_status = eStatus::Failed; + m_normal = btVector3(0, 0, 0); + m_depth = 0; + m_nextsv = 0; + for (U i = 0; i < EPA_MAX_FACES; ++i) + { + append(m_stock, &m_fc_store[EPA_MAX_FACES - i - 1]); + } + } + eStatus::_ Evaluate(GJK& gjk, const btVector3& guess) + { + GJK::sSimplex& simplex = *gjk.m_simplex; + if ((simplex.rank > 1) && gjk.EncloseOrigin()) + { + /* Clean up */ + while (m_hull.root) + { + sFace* f = m_hull.root; + remove(m_hull, f); + append(m_stock, f); + } + m_status = eStatus::Valid; + m_nextsv = 0; + /* Orient simplex */ + if (gjk.det(simplex.c[0]->w - simplex.c[3]->w, + simplex.c[1]->w - simplex.c[3]->w, + simplex.c[2]->w - simplex.c[3]->w) < 0) + { + btSwap(simplex.c[0], simplex.c[1]); + btSwap(simplex.p[0], simplex.p[1]); + } + /* Build initial hull */ + sFace* tetra[] = {newface(simplex.c[0], simplex.c[1], simplex.c[2], true), + newface(simplex.c[1], simplex.c[0], simplex.c[3], true), + newface(simplex.c[2], simplex.c[1], simplex.c[3], true), + newface(simplex.c[0], simplex.c[2], simplex.c[3], true)}; + if (m_hull.count == 4) + { + sFace* best = findbest(); + sFace outer = *best; + U pass = 0; + U iterations = 0; + bind(tetra[0], 0, tetra[1], 0); + bind(tetra[0], 1, tetra[2], 0); + bind(tetra[0], 2, tetra[3], 0); + bind(tetra[1], 1, tetra[3], 2); + bind(tetra[1], 2, tetra[2], 1); + bind(tetra[2], 2, tetra[3], 1); + m_status = eStatus::Valid; + for (; iterations < EPA_MAX_ITERATIONS; ++iterations) + { + if (m_nextsv < EPA_MAX_VERTICES) + { + sHorizon horizon; + sSV* w = &m_sv_store[m_nextsv++]; + bool valid = true; + best->pass = (U1)(++pass); + gjk.getsupport(best->n, *w); + const btScalar wdist = btDot(best->n, w->w) - best->d; + if (wdist > EPA_ACCURACY) + { + for (U j = 0; (j < 3) && valid; ++j) + { + valid &= expand(pass, w, + best->f[j], best->e[j], + horizon); + } + if (valid && (horizon.nf >= 3)) + { + bind(horizon.cf, 1, horizon.ff, 2); + remove(m_hull, best); + append(m_stock, best); + best = findbest(); + outer = *best; + } + else + { + m_status = eStatus::InvalidHull; + break; + } + } + else + { + m_status = eStatus::AccuraryReached; + break; + } + } + else + { + m_status = eStatus::OutOfVertices; + break; + } + } + const btVector3 projection = outer.n * outer.d; + m_normal = outer.n; + m_depth = outer.d; + m_result.rank = 3; + m_result.c[0] = outer.c[0]; + m_result.c[1] = outer.c[1]; + m_result.c[2] = outer.c[2]; + m_result.p[0] = btCross(outer.c[1]->w - projection, + outer.c[2]->w - projection) + .length(); + m_result.p[1] = btCross(outer.c[2]->w - projection, + outer.c[0]->w - projection) + .length(); + m_result.p[2] = btCross(outer.c[0]->w - projection, + outer.c[1]->w - projection) + .length(); + const btScalar sum = m_result.p[0] + m_result.p[1] + m_result.p[2]; + m_result.p[0] /= sum; + m_result.p[1] /= sum; + m_result.p[2] /= sum; + return (m_status); + } + } + /* Fallback */ + m_status = eStatus::FallBack; + m_normal = -guess; + const btScalar nl = m_normal.length(); + if (nl > 0) + m_normal = m_normal / nl; + else + m_normal = btVector3(1, 0, 0); + m_depth = 0; + m_result.rank = 1; + m_result.c[0] = simplex.c[0]; + m_result.p[0] = 1; + return (m_status); + } + bool getedgedist(sFace* face, sSV* a, sSV* b, btScalar& dist) + { + const btVector3 ba = b->w - a->w; + const btVector3 n_ab = btCross(ba, face->n); // Outward facing edge normal direction, on triangle plane + const btScalar a_dot_nab = btDot(a->w, n_ab); // Only care about the sign to determine inside/outside, so not normalization required + + if (a_dot_nab < 0) + { + // Outside of edge a->b + + const btScalar ba_l2 = ba.length2(); + const btScalar a_dot_ba = btDot(a->w, ba); + const btScalar b_dot_ba = btDot(b->w, ba); + + if (a_dot_ba > 0) + { + // Pick distance vertex a + dist = a->w.length(); + } + else if (b_dot_ba < 0) + { + // Pick distance vertex b + dist = b->w.length(); + } + else + { + // Pick distance to edge a->b + const btScalar a_dot_b = btDot(a->w, b->w); + dist = btSqrt(btMax((a->w.length2() * b->w.length2() - a_dot_b * a_dot_b) / ba_l2, (btScalar)0)); + } + + return true; + } + + return false; + } + sFace* newface(sSV* a, sSV* b, sSV* c, bool forced) + { + if (m_stock.root) + { + sFace* face = m_stock.root; + remove(m_stock, face); + append(m_hull, face); + face->pass = 0; + face->c[0] = a; + face->c[1] = b; + face->c[2] = c; + face->n = btCross(b->w - a->w, c->w - a->w); + const btScalar l = face->n.length(); + const bool v = l > EPA_ACCURACY; + + if (v) + { + if (!(getedgedist(face, a, b, face->d) || + getedgedist(face, b, c, face->d) || + getedgedist(face, c, a, face->d))) + { + // Origin projects to the interior of the triangle + // Use distance to triangle plane + face->d = btDot(a->w, face->n) / l; + } + + face->n /= l; + if (forced || (face->d >= -EPA_PLANE_EPS)) + { + return face; + } + else + m_status = eStatus::NonConvex; + } + else + m_status = eStatus::Degenerated; + + remove(m_hull, face); + append(m_stock, face); + return 0; + } + m_status = m_stock.root ? eStatus::OutOfVertices : eStatus::OutOfFaces; + return 0; + } + sFace* findbest() + { + sFace* minf = m_hull.root; + btScalar mind = minf->d * minf->d; + for (sFace* f = minf->l[1]; f; f = f->l[1]) + { + const btScalar sqd = f->d * f->d; + if (sqd < mind) + { + minf = f; + mind = sqd; + } + } + return (minf); + } + bool expand(U pass, sSV* w, sFace* f, U e, sHorizon& horizon) + { + static const U i1m3[] = {1, 2, 0}; + static const U i2m3[] = {2, 0, 1}; + if (f->pass != pass) + { + const U e1 = i1m3[e]; + if ((btDot(f->n, w->w) - f->d) < -EPA_PLANE_EPS) + { + sFace* nf = newface(f->c[e1], f->c[e], w, false); + if (nf) + { + bind(nf, 0, f, e); + if (horizon.cf) + bind(horizon.cf, 1, nf, 2); + else + horizon.ff = nf; + horizon.cf = nf; + ++horizon.nf; + return (true); + } + } + else + { + const U e2 = i2m3[e]; + f->pass = (U1)pass; + if (expand(pass, w, f->f[e1], f->e[e1], horizon) && + expand(pass, w, f->f[e2], f->e[e2], horizon)) + { + remove(m_hull, f); + append(m_stock, f); + return (true); + } + } + } + return (false); + } +}; + +// +static void Initialize(const btConvexShape* shape0, const btTransform& wtrs0, + const btConvexShape* shape1, const btTransform& wtrs1, + btGjkEpaSolver2::sResults& results, + tShape& shape, + bool withmargins) +{ + /* Results */ + results.witnesses[0] = + results.witnesses[1] = btVector3(0, 0, 0); + results.status = btGjkEpaSolver2::sResults::Separated; + /* Shape */ + shape.m_shapes[0] = shape0; + shape.m_shapes[1] = shape1; + shape.m_toshape1 = wtrs1.getBasis().transposeTimes(wtrs0.getBasis()); + shape.m_toshape0 = wtrs0.inverseTimes(wtrs1); + shape.EnableMargin(withmargins); +} + +} // namespace gjkepa2_impl + +// +// Api +// + +using namespace gjkepa2_impl; + +// +int btGjkEpaSolver2::StackSizeRequirement() +{ + return (sizeof(GJK) + sizeof(EPA)); +} + +// +bool btGjkEpaSolver2::Distance(const btConvexShape* shape0, + const btTransform& wtrs0, + const btConvexShape* shape1, + const btTransform& wtrs1, + const btVector3& guess, + sResults& results) +{ + tShape shape; + Initialize(shape0, wtrs0, shape1, wtrs1, results, shape, false); + GJK gjk; + GJK::eStatus::_ gjk_status = gjk.Evaluate(shape, guess); + if (gjk_status == GJK::eStatus::Valid) + { + btVector3 w0 = btVector3(0, 0, 0); + btVector3 w1 = btVector3(0, 0, 0); + for (U i = 0; i < gjk.m_simplex->rank; ++i) + { + const btScalar p = gjk.m_simplex->p[i]; + w0 += shape.Support(gjk.m_simplex->c[i]->d, 0) * p; + w1 += shape.Support(-gjk.m_simplex->c[i]->d, 1) * p; + } + results.witnesses[0] = wtrs0 * w0; + results.witnesses[1] = wtrs0 * w1; + results.normal = w0 - w1; + results.distance = results.normal.length(); + results.normal /= results.distance > GJK_MIN_DISTANCE ? results.distance : 1; + return (true); + } + else + { + results.status = gjk_status == GJK::eStatus::Inside ? sResults::Penetrating : sResults::GJK_Failed; + return (false); + } +} + +// +bool btGjkEpaSolver2::Penetration(const btConvexShape* shape0, + const btTransform& wtrs0, + const btConvexShape* shape1, + const btTransform& wtrs1, + const btVector3& guess, + sResults& results, + bool usemargins) +{ + tShape shape; + Initialize(shape0, wtrs0, shape1, wtrs1, results, shape, usemargins); + GJK gjk; + GJK::eStatus::_ gjk_status = gjk.Evaluate(shape, -guess); + switch (gjk_status) + { + case GJK::eStatus::Inside: + { + EPA epa; + EPA::eStatus::_ epa_status = epa.Evaluate(gjk, -guess); + if (epa_status != EPA::eStatus::Failed) + { + btVector3 w0 = btVector3(0, 0, 0); + for (U i = 0; i < epa.m_result.rank; ++i) + { + w0 += shape.Support(epa.m_result.c[i]->d, 0) * epa.m_result.p[i]; + } + results.status = sResults::Penetrating; + results.witnesses[0] = wtrs0 * w0; + results.witnesses[1] = wtrs0 * (w0 - epa.m_normal * epa.m_depth); + results.normal = -epa.m_normal; + results.distance = -epa.m_depth; + return (true); + } + else + results.status = sResults::EPA_Failed; + } + break; + case GJK::eStatus::Failed: + results.status = sResults::GJK_Failed; + break; + default: + { + } + } + return (false); +} + +#ifndef __SPU__ +// +btScalar btGjkEpaSolver2::SignedDistance(const btVector3& position, + btScalar margin, + const btConvexShape* shape0, + const btTransform& wtrs0, + sResults& results) +{ + tShape shape; + btSphereShape shape1(margin); + btTransform wtrs1(btQuaternion(0, 0, 0, 1), position); + Initialize(shape0, wtrs0, &shape1, wtrs1, results, shape, false); + GJK gjk; + GJK::eStatus::_ gjk_status = gjk.Evaluate(shape, btVector3(1, 1, 1)); + if (gjk_status == GJK::eStatus::Valid) + { + btVector3 w0 = btVector3(0, 0, 0); + btVector3 w1 = btVector3(0, 0, 0); + for (U i = 0; i < gjk.m_simplex->rank; ++i) + { + const btScalar p = gjk.m_simplex->p[i]; + w0 += shape.Support(gjk.m_simplex->c[i]->d, 0) * p; + w1 += shape.Support(-gjk.m_simplex->c[i]->d, 1) * p; + } + results.witnesses[0] = wtrs0 * w0; + results.witnesses[1] = wtrs0 * w1; + const btVector3 delta = results.witnesses[1] - + results.witnesses[0]; + const btScalar margin = shape0->getMarginNonVirtual() + + shape1.getMarginNonVirtual(); + const btScalar length = delta.length(); + results.normal = delta / length; + results.witnesses[0] += results.normal * margin; + results.distance = length - margin; + return results.distance; + } + else + { + if (gjk_status == GJK::eStatus::Inside) + { + if (Penetration(shape0, wtrs0, &shape1, wtrs1, gjk.m_ray, results)) + { + const btVector3 delta = results.witnesses[0] - + results.witnesses[1]; + const btScalar length = delta.length(); + if (length >= SIMD_EPSILON) + results.normal = delta / length; + return (-length); + } + } + } + return (SIMD_INFINITY); +} + +// +bool btGjkEpaSolver2::SignedDistance(const btConvexShape* shape0, + const btTransform& wtrs0, + const btConvexShape* shape1, + const btTransform& wtrs1, + const btVector3& guess, + sResults& results) +{ + if (!Distance(shape0, wtrs0, shape1, wtrs1, guess, results)) + return (Penetration(shape0, wtrs0, shape1, wtrs1, guess, results, false)); + else + return (true); +} +#endif //__SPU__ + +/* Symbols cleanup */ + +#undef GJK_MAX_ITERATIONS +#undef GJK_ACCURACY +#undef GJK_MIN_DISTANCE +#undef GJK_DUPLICATED_EPS +#undef GJK_SIMPLEX2_EPS +#undef GJK_SIMPLEX3_EPS +#undef GJK_SIMPLEX4_EPS + +#undef EPA_MAX_VERTICES +#undef EPA_MAX_FACES +#undef EPA_MAX_ITERATIONS +#undef EPA_ACCURACY +#undef EPA_FALLBACK +#undef EPA_PLANE_EPS +#undef EPA_INSIDE_EPS diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp.i new file mode 100644 index 00000000..fb91d6c6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.h new file mode 100644 index 00000000..e2cf633a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.h @@ -0,0 +1,73 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the +use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not +claim that you wrote the original software. If you use this software in a +product, an acknowledgment in the product documentation would be appreciated +but is not required. +2. Altered source versions must be plainly marked as such, and must not be +misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +GJK-EPA collision solver by Nathanael Presson, 2008 +*/ +#ifndef BT_GJK_EPA2_H +#define BT_GJK_EPA2_H + +#include "BulletCollision/CollisionShapes/btConvexShape.h" + +///btGjkEpaSolver contributed under zlib by Nathanael Presson +struct btGjkEpaSolver2 +{ + struct sResults + { + enum eStatus + { + Separated, /* Shapes doesnt penetrate */ + Penetrating, /* Shapes are penetrating */ + GJK_Failed, /* GJK phase fail, no big issue, shapes are probably just 'touching' */ + EPA_Failed /* EPA phase fail, bigger problem, need to save parameters, and debug */ + } status; + btVector3 witnesses[2]; + btVector3 normal; + btScalar distance; + }; + + static int StackSizeRequirement(); + + static bool Distance(const btConvexShape* shape0, const btTransform& wtrs0, + const btConvexShape* shape1, const btTransform& wtrs1, + const btVector3& guess, + sResults& results); + + static bool Penetration(const btConvexShape* shape0, const btTransform& wtrs0, + const btConvexShape* shape1, const btTransform& wtrs1, + const btVector3& guess, + sResults& results, + bool usemargins = true); +#ifndef __SPU__ + static btScalar SignedDistance(const btVector3& position, + btScalar margin, + const btConvexShape* shape, + const btTransform& wtrs, + sResults& results); + + static bool SignedDistance(const btConvexShape* shape0, const btTransform& wtrs0, + const btConvexShape* shape1, const btTransform& wtrs1, + const btVector3& guess, + sResults& results); +#endif //__SPU__ +}; + +#endif //BT_GJK_EPA2_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.h.i new file mode 100644 index 00000000..6f49eeba --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa2.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btGjkEpa2.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa3.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa3.h new file mode 100644 index 00000000..fd67c375 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa3.h @@ -0,0 +1,1063 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2014 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the +use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not +claim that you wrote the original software. If you use this software in a +product, an acknowledgment in the product documentation would be appreciated +but is not required. +2. Altered source versions must be plainly marked as such, and must not be +misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +Initial GJK-EPA collision solver by Nathanael Presson, 2008 +Improvements and refactoring by Erwin Coumans, 2008-2014 +*/ +#ifndef BT_GJK_EPA3_H +#define BT_GJK_EPA3_H + +#include "LinearMath/btTransform.h" +#include "btGjkCollisionDescription.h" + +struct btGjkEpaSolver3 +{ + struct sResults + { + enum eStatus + { + Separated, /* Shapes doesnt penetrate */ + Penetrating, /* Shapes are penetrating */ + GJK_Failed, /* GJK phase fail, no big issue, shapes are probably just 'touching' */ + EPA_Failed /* EPA phase fail, bigger problem, need to save parameters, and debug */ + } status; + btVector3 witnesses[2]; + btVector3 normal; + btScalar distance; + }; +}; + +#if defined(DEBUG) || defined(_DEBUG) +#include //for debug printf +#ifdef __SPU__ +#include +#define printf spu_printf +#endif //__SPU__ +#endif + +// Config + +/* GJK */ +#define GJK_MAX_ITERATIONS 128 +#define GJK_ACCURARY ((btScalar)0.0001) +#define GJK_MIN_DISTANCE ((btScalar)0.0001) +#define GJK_DUPLICATED_EPS ((btScalar)0.0001) +#define GJK_SIMPLEX2_EPS ((btScalar)0.0) +#define GJK_SIMPLEX3_EPS ((btScalar)0.0) +#define GJK_SIMPLEX4_EPS ((btScalar)0.0) + +/* EPA */ +#define EPA_MAX_VERTICES 64 +#define EPA_MAX_FACES (EPA_MAX_VERTICES * 2) +#define EPA_MAX_ITERATIONS 255 +#define EPA_ACCURACY ((btScalar)0.0001) +#define EPA_FALLBACK (10 * EPA_ACCURACY) +#define EPA_PLANE_EPS ((btScalar)0.00001) +#define EPA_INSIDE_EPS ((btScalar)0.01) + +// Shorthands +typedef unsigned int U; +typedef unsigned char U1; + +// MinkowskiDiff +template +struct MinkowskiDiff +{ + const btConvexTemplate* m_convexAPtr; + const btConvexTemplate* m_convexBPtr; + + btMatrix3x3 m_toshape1; + btTransform m_toshape0; + + bool m_enableMargin; + + MinkowskiDiff(const btConvexTemplate& a, const btConvexTemplate& b) + : m_convexAPtr(&a), + m_convexBPtr(&b) + { + } + + void EnableMargin(bool enable) + { + m_enableMargin = enable; + } + inline btVector3 Support0(const btVector3& d) const + { + return m_convexAPtr->getLocalSupportWithMargin(d); + } + inline btVector3 Support1(const btVector3& d) const + { + return m_toshape0 * m_convexBPtr->getLocalSupportWithMargin(m_toshape1 * d); + } + + inline btVector3 Support(const btVector3& d) const + { + return (Support0(d) - Support1(-d)); + } + btVector3 Support(const btVector3& d, U index) const + { + if (index) + return (Support1(d)); + else + return (Support0(d)); + } +}; + +enum eGjkStatus +{ + eGjkValid, + eGjkInside, + eGjkFailed +}; + +// GJK +template +struct GJK +{ + /* Types */ + struct sSV + { + btVector3 d, w; + }; + struct sSimplex + { + sSV* c[4]; + btScalar p[4]; + U rank; + }; + + /* Fields */ + + MinkowskiDiff m_shape; + btVector3 m_ray; + btScalar m_distance; + sSimplex m_simplices[2]; + sSV m_store[4]; + sSV* m_free[4]; + U m_nfree; + U m_current; + sSimplex* m_simplex; + eGjkStatus m_status; + /* Methods */ + + GJK(const btConvexTemplate& a, const btConvexTemplate& b) + : m_shape(a, b) + { + Initialize(); + } + void Initialize() + { + m_ray = btVector3(0, 0, 0); + m_nfree = 0; + m_status = eGjkFailed; + m_current = 0; + m_distance = 0; + } + eGjkStatus Evaluate(const MinkowskiDiff& shapearg, const btVector3& guess) + { + U iterations = 0; + btScalar sqdist = 0; + btScalar alpha = 0; + btVector3 lastw[4]; + U clastw = 0; + /* Initialize solver */ + m_free[0] = &m_store[0]; + m_free[1] = &m_store[1]; + m_free[2] = &m_store[2]; + m_free[3] = &m_store[3]; + m_nfree = 4; + m_current = 0; + m_status = eGjkValid; + m_shape = shapearg; + m_distance = 0; + /* Initialize simplex */ + m_simplices[0].rank = 0; + m_ray = guess; + const btScalar sqrl = m_ray.length2(); + appendvertice(m_simplices[0], sqrl > 0 ? -m_ray : btVector3(1, 0, 0)); + m_simplices[0].p[0] = 1; + m_ray = m_simplices[0].c[0]->w; + sqdist = sqrl; + lastw[0] = + lastw[1] = + lastw[2] = + lastw[3] = m_ray; + /* Loop */ + do + { + const U next = 1 - m_current; + sSimplex& cs = m_simplices[m_current]; + sSimplex& ns = m_simplices[next]; + /* Check zero */ + const btScalar rl = m_ray.length(); + if (rl < GJK_MIN_DISTANCE) + { /* Touching or inside */ + m_status = eGjkInside; + break; + } + /* Append new vertice in -'v' direction */ + appendvertice(cs, -m_ray); + const btVector3& w = cs.c[cs.rank - 1]->w; + bool found = false; + for (U i = 0; i < 4; ++i) + { + if ((w - lastw[i]).length2() < GJK_DUPLICATED_EPS) + { + found = true; + break; + } + } + if (found) + { /* Return old simplex */ + removevertice(m_simplices[m_current]); + break; + } + else + { /* Update lastw */ + lastw[clastw = (clastw + 1) & 3] = w; + } + /* Check for termination */ + const btScalar omega = btDot(m_ray, w) / rl; + alpha = btMax(omega, alpha); + if (((rl - alpha) - (GJK_ACCURARY * rl)) <= 0) + { /* Return old simplex */ + removevertice(m_simplices[m_current]); + break; + } + /* Reduce simplex */ + btScalar weights[4]; + U mask = 0; + switch (cs.rank) + { + case 2: + sqdist = projectorigin(cs.c[0]->w, + cs.c[1]->w, + weights, mask); + break; + case 3: + sqdist = projectorigin(cs.c[0]->w, + cs.c[1]->w, + cs.c[2]->w, + weights, mask); + break; + case 4: + sqdist = projectorigin(cs.c[0]->w, + cs.c[1]->w, + cs.c[2]->w, + cs.c[3]->w, + weights, mask); + break; + } + if (sqdist >= 0) + { /* Valid */ + ns.rank = 0; + m_ray = btVector3(0, 0, 0); + m_current = next; + for (U i = 0, ni = cs.rank; i < ni; ++i) + { + if (mask & (1 << i)) + { + ns.c[ns.rank] = cs.c[i]; + ns.p[ns.rank++] = weights[i]; + m_ray += cs.c[i]->w * weights[i]; + } + else + { + m_free[m_nfree++] = cs.c[i]; + } + } + if (mask == 15) m_status = eGjkInside; + } + else + { /* Return old simplex */ + removevertice(m_simplices[m_current]); + break; + } + m_status = ((++iterations) < GJK_MAX_ITERATIONS) ? m_status : eGjkFailed; + } while (m_status == eGjkValid); + m_simplex = &m_simplices[m_current]; + switch (m_status) + { + case eGjkValid: + m_distance = m_ray.length(); + break; + case eGjkInside: + m_distance = 0; + break; + default: + { + } + } + return (m_status); + } + bool EncloseOrigin() + { + switch (m_simplex->rank) + { + case 1: + { + for (U i = 0; i < 3; ++i) + { + btVector3 axis = btVector3(0, 0, 0); + axis[i] = 1; + appendvertice(*m_simplex, axis); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + appendvertice(*m_simplex, -axis); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + } + } + break; + case 2: + { + const btVector3 d = m_simplex->c[1]->w - m_simplex->c[0]->w; + for (U i = 0; i < 3; ++i) + { + btVector3 axis = btVector3(0, 0, 0); + axis[i] = 1; + const btVector3 p = btCross(d, axis); + if (p.length2() > 0) + { + appendvertice(*m_simplex, p); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + appendvertice(*m_simplex, -p); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + } + } + } + break; + case 3: + { + const btVector3 n = btCross(m_simplex->c[1]->w - m_simplex->c[0]->w, + m_simplex->c[2]->w - m_simplex->c[0]->w); + if (n.length2() > 0) + { + appendvertice(*m_simplex, n); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + appendvertice(*m_simplex, -n); + if (EncloseOrigin()) return (true); + removevertice(*m_simplex); + } + } + break; + case 4: + { + if (btFabs(det(m_simplex->c[0]->w - m_simplex->c[3]->w, + m_simplex->c[1]->w - m_simplex->c[3]->w, + m_simplex->c[2]->w - m_simplex->c[3]->w)) > 0) + return (true); + } + break; + } + return (false); + } + /* Internals */ + void getsupport(const btVector3& d, sSV& sv) const + { + sv.d = d / d.length(); + sv.w = m_shape.Support(sv.d); + } + void removevertice(sSimplex& simplex) + { + m_free[m_nfree++] = simplex.c[--simplex.rank]; + } + void appendvertice(sSimplex& simplex, const btVector3& v) + { + simplex.p[simplex.rank] = 0; + simplex.c[simplex.rank] = m_free[--m_nfree]; + getsupport(v, *simplex.c[simplex.rank++]); + } + static btScalar det(const btVector3& a, const btVector3& b, const btVector3& c) + { + return (a.y() * b.z() * c.x() + a.z() * b.x() * c.y() - + a.x() * b.z() * c.y() - a.y() * b.x() * c.z() + + a.x() * b.y() * c.z() - a.z() * b.y() * c.x()); + } + static btScalar projectorigin(const btVector3& a, + const btVector3& b, + btScalar* w, U& m) + { + const btVector3 d = b - a; + const btScalar l = d.length2(); + if (l > GJK_SIMPLEX2_EPS) + { + const btScalar t(l > 0 ? -btDot(a, d) / l : 0); + if (t >= 1) + { + w[0] = 0; + w[1] = 1; + m = 2; + return (b.length2()); + } + else if (t <= 0) + { + w[0] = 1; + w[1] = 0; + m = 1; + return (a.length2()); + } + else + { + w[0] = 1 - (w[1] = t); + m = 3; + return ((a + d * t).length2()); + } + } + return (-1); + } + static btScalar projectorigin(const btVector3& a, + const btVector3& b, + const btVector3& c, + btScalar* w, U& m) + { + static const U imd3[] = {1, 2, 0}; + const btVector3* vt[] = {&a, &b, &c}; + const btVector3 dl[] = {a - b, b - c, c - a}; + const btVector3 n = btCross(dl[0], dl[1]); + const btScalar l = n.length2(); + if (l > GJK_SIMPLEX3_EPS) + { + btScalar mindist = -1; + btScalar subw[2] = {0.f, 0.f}; + U subm(0); + for (U i = 0; i < 3; ++i) + { + if (btDot(*vt[i], btCross(dl[i], n)) > 0) + { + const U j = imd3[i]; + const btScalar subd(projectorigin(*vt[i], *vt[j], subw, subm)); + if ((mindist < 0) || (subd < mindist)) + { + mindist = subd; + m = static_cast(((subm & 1) ? 1 << i : 0) + ((subm & 2) ? 1 << j : 0)); + w[i] = subw[0]; + w[j] = subw[1]; + w[imd3[j]] = 0; + } + } + } + if (mindist < 0) + { + const btScalar d = btDot(a, n); + const btScalar s = btSqrt(l); + const btVector3 p = n * (d / l); + mindist = p.length2(); + m = 7; + w[0] = (btCross(dl[1], b - p)).length() / s; + w[1] = (btCross(dl[2], c - p)).length() / s; + w[2] = 1 - (w[0] + w[1]); + } + return (mindist); + } + return (-1); + } + static btScalar projectorigin(const btVector3& a, + const btVector3& b, + const btVector3& c, + const btVector3& d, + btScalar* w, U& m) + { + static const U imd3[] = {1, 2, 0}; + const btVector3* vt[] = {&a, &b, &c, &d}; + const btVector3 dl[] = {a - d, b - d, c - d}; + const btScalar vl = det(dl[0], dl[1], dl[2]); + const bool ng = (vl * btDot(a, btCross(b - c, a - b))) <= 0; + if (ng && (btFabs(vl) > GJK_SIMPLEX4_EPS)) + { + btScalar mindist = -1; + btScalar subw[3] = {0.f, 0.f, 0.f}; + U subm(0); + for (U i = 0; i < 3; ++i) + { + const U j = imd3[i]; + const btScalar s = vl * btDot(d, btCross(dl[i], dl[j])); + if (s > 0) + { + const btScalar subd = projectorigin(*vt[i], *vt[j], d, subw, subm); + if ((mindist < 0) || (subd < mindist)) + { + mindist = subd; + m = static_cast((subm & 1 ? 1 << i : 0) + + (subm & 2 ? 1 << j : 0) + + (subm & 4 ? 8 : 0)); + w[i] = subw[0]; + w[j] = subw[1]; + w[imd3[j]] = 0; + w[3] = subw[2]; + } + } + } + if (mindist < 0) + { + mindist = 0; + m = 15; + w[0] = det(c, b, d) / vl; + w[1] = det(a, c, d) / vl; + w[2] = det(b, a, d) / vl; + w[3] = 1 - (w[0] + w[1] + w[2]); + } + return (mindist); + } + return (-1); + } +}; + +enum eEpaStatus +{ + eEpaValid, + eEpaTouching, + eEpaDegenerated, + eEpaNonConvex, + eEpaInvalidHull, + eEpaOutOfFaces, + eEpaOutOfVertices, + eEpaAccuraryReached, + eEpaFallBack, + eEpaFailed +}; + +// EPA +template +struct EPA +{ + /* Types */ + + struct sFace + { + btVector3 n; + btScalar d; + typename GJK::sSV* c[3]; + sFace* f[3]; + sFace* l[2]; + U1 e[3]; + U1 pass; + }; + struct sList + { + sFace* root; + U count; + sList() : root(0), count(0) {} + }; + struct sHorizon + { + sFace* cf; + sFace* ff; + U nf; + sHorizon() : cf(0), ff(0), nf(0) {} + }; + + /* Fields */ + eEpaStatus m_status; + typename GJK::sSimplex m_result; + btVector3 m_normal; + btScalar m_depth; + typename GJK::sSV m_sv_store[EPA_MAX_VERTICES]; + sFace m_fc_store[EPA_MAX_FACES]; + U m_nextsv; + sList m_hull; + sList m_stock; + /* Methods */ + EPA() + { + Initialize(); + } + + static inline void bind(sFace* fa, U ea, sFace* fb, U eb) + { + fa->e[ea] = (U1)eb; + fa->f[ea] = fb; + fb->e[eb] = (U1)ea; + fb->f[eb] = fa; + } + static inline void append(sList& list, sFace* face) + { + face->l[0] = 0; + face->l[1] = list.root; + if (list.root) list.root->l[0] = face; + list.root = face; + ++list.count; + } + static inline void remove(sList& list, sFace* face) + { + if (face->l[1]) face->l[1]->l[0] = face->l[0]; + if (face->l[0]) face->l[0]->l[1] = face->l[1]; + if (face == list.root) list.root = face->l[1]; + --list.count; + } + + void Initialize() + { + m_status = eEpaFailed; + m_normal = btVector3(0, 0, 0); + m_depth = 0; + m_nextsv = 0; + for (U i = 0; i < EPA_MAX_FACES; ++i) + { + append(m_stock, &m_fc_store[EPA_MAX_FACES - i - 1]); + } + } + eEpaStatus Evaluate(GJK& gjk, const btVector3& guess) + { + typename GJK::sSimplex& simplex = *gjk.m_simplex; + if ((simplex.rank > 1) && gjk.EncloseOrigin()) + { + /* Clean up */ + while (m_hull.root) + { + sFace* f = m_hull.root; + remove(m_hull, f); + append(m_stock, f); + } + m_status = eEpaValid; + m_nextsv = 0; + /* Orient simplex */ + if (gjk.det(simplex.c[0]->w - simplex.c[3]->w, + simplex.c[1]->w - simplex.c[3]->w, + simplex.c[2]->w - simplex.c[3]->w) < 0) + { + btSwap(simplex.c[0], simplex.c[1]); + btSwap(simplex.p[0], simplex.p[1]); + } + /* Build initial hull */ + sFace* tetra[] = {newface(simplex.c[0], simplex.c[1], simplex.c[2], true), + newface(simplex.c[1], simplex.c[0], simplex.c[3], true), + newface(simplex.c[2], simplex.c[1], simplex.c[3], true), + newface(simplex.c[0], simplex.c[2], simplex.c[3], true)}; + if (m_hull.count == 4) + { + sFace* best = findbest(); + sFace outer = *best; + U pass = 0; + U iterations = 0; + bind(tetra[0], 0, tetra[1], 0); + bind(tetra[0], 1, tetra[2], 0); + bind(tetra[0], 2, tetra[3], 0); + bind(tetra[1], 1, tetra[3], 2); + bind(tetra[1], 2, tetra[2], 1); + bind(tetra[2], 2, tetra[3], 1); + m_status = eEpaValid; + for (; iterations < EPA_MAX_ITERATIONS; ++iterations) + { + if (m_nextsv < EPA_MAX_VERTICES) + { + sHorizon horizon; + typename GJK::sSV* w = &m_sv_store[m_nextsv++]; + bool valid = true; + best->pass = (U1)(++pass); + gjk.getsupport(best->n, *w); + const btScalar wdist = btDot(best->n, w->w) - best->d; + if (wdist > EPA_ACCURACY) + { + for (U j = 0; (j < 3) && valid; ++j) + { + valid &= expand(pass, w, + best->f[j], best->e[j], + horizon); + } + if (valid && (horizon.nf >= 3)) + { + bind(horizon.cf, 1, horizon.ff, 2); + remove(m_hull, best); + append(m_stock, best); + best = findbest(); + outer = *best; + } + else + { + m_status = eEpaInvalidHull; + break; + } + } + else + { + m_status = eEpaAccuraryReached; + break; + } + } + else + { + m_status = eEpaOutOfVertices; + break; + } + } + const btVector3 projection = outer.n * outer.d; + m_normal = outer.n; + m_depth = outer.d; + m_result.rank = 3; + m_result.c[0] = outer.c[0]; + m_result.c[1] = outer.c[1]; + m_result.c[2] = outer.c[2]; + m_result.p[0] = btCross(outer.c[1]->w - projection, + outer.c[2]->w - projection) + .length(); + m_result.p[1] = btCross(outer.c[2]->w - projection, + outer.c[0]->w - projection) + .length(); + m_result.p[2] = btCross(outer.c[0]->w - projection, + outer.c[1]->w - projection) + .length(); + const btScalar sum = m_result.p[0] + m_result.p[1] + m_result.p[2]; + m_result.p[0] /= sum; + m_result.p[1] /= sum; + m_result.p[2] /= sum; + return (m_status); + } + } + /* Fallback */ + m_status = eEpaFallBack; + m_normal = -guess; + const btScalar nl = m_normal.length(); + if (nl > 0) + m_normal = m_normal / nl; + else + m_normal = btVector3(1, 0, 0); + m_depth = 0; + m_result.rank = 1; + m_result.c[0] = simplex.c[0]; + m_result.p[0] = 1; + return (m_status); + } + bool getedgedist(sFace* face, typename GJK::sSV* a, typename GJK::sSV* b, btScalar& dist) + { + const btVector3 ba = b->w - a->w; + const btVector3 n_ab = btCross(ba, face->n); // Outward facing edge normal direction, on triangle plane + const btScalar a_dot_nab = btDot(a->w, n_ab); // Only care about the sign to determine inside/outside, so not normalization required + + if (a_dot_nab < 0) + { + // Outside of edge a->b + + const btScalar ba_l2 = ba.length2(); + const btScalar a_dot_ba = btDot(a->w, ba); + const btScalar b_dot_ba = btDot(b->w, ba); + + if (a_dot_ba > 0) + { + // Pick distance vertex a + dist = a->w.length(); + } + else if (b_dot_ba < 0) + { + // Pick distance vertex b + dist = b->w.length(); + } + else + { + // Pick distance to edge a->b + const btScalar a_dot_b = btDot(a->w, b->w); + dist = btSqrt(btMax((a->w.length2() * b->w.length2() - a_dot_b * a_dot_b) / ba_l2, (btScalar)0)); + } + + return true; + } + + return false; + } + sFace* newface(typename GJK::sSV* a, typename GJK::sSV* b, typename GJK::sSV* c, bool forced) + { + if (m_stock.root) + { + sFace* face = m_stock.root; + remove(m_stock, face); + append(m_hull, face); + face->pass = 0; + face->c[0] = a; + face->c[1] = b; + face->c[2] = c; + face->n = btCross(b->w - a->w, c->w - a->w); + const btScalar l = face->n.length(); + const bool v = l > EPA_ACCURACY; + + if (v) + { + if (!(getedgedist(face, a, b, face->d) || + getedgedist(face, b, c, face->d) || + getedgedist(face, c, a, face->d))) + { + // Origin projects to the interior of the triangle + // Use distance to triangle plane + face->d = btDot(a->w, face->n) / l; + } + + face->n /= l; + if (forced || (face->d >= -EPA_PLANE_EPS)) + { + return face; + } + else + m_status = eEpaNonConvex; + } + else + m_status = eEpaDegenerated; + + remove(m_hull, face); + append(m_stock, face); + return 0; + } + m_status = m_stock.root ? eEpaOutOfVertices : eEpaOutOfFaces; + return 0; + } + sFace* findbest() + { + sFace* minf = m_hull.root; + btScalar mind = minf->d * minf->d; + for (sFace* f = minf->l[1]; f; f = f->l[1]) + { + const btScalar sqd = f->d * f->d; + if (sqd < mind) + { + minf = f; + mind = sqd; + } + } + return (minf); + } + bool expand(U pass, typename GJK::sSV* w, sFace* f, U e, sHorizon& horizon) + { + static const U i1m3[] = {1, 2, 0}; + static const U i2m3[] = {2, 0, 1}; + if (f->pass != pass) + { + const U e1 = i1m3[e]; + if ((btDot(f->n, w->w) - f->d) < -EPA_PLANE_EPS) + { + sFace* nf = newface(f->c[e1], f->c[e], w, false); + if (nf) + { + bind(nf, 0, f, e); + if (horizon.cf) + bind(horizon.cf, 1, nf, 2); + else + horizon.ff = nf; + horizon.cf = nf; + ++horizon.nf; + return (true); + } + } + else + { + const U e2 = i2m3[e]; + f->pass = (U1)pass; + if (expand(pass, w, f->f[e1], f->e[e1], horizon) && + expand(pass, w, f->f[e2], f->e[e2], horizon)) + { + remove(m_hull, f); + append(m_stock, f); + return (true); + } + } + } + return (false); + } +}; + +template +static void Initialize(const btConvexTemplate& a, const btConvexTemplate& b, + btGjkEpaSolver3::sResults& results, + MinkowskiDiff& shape) +{ + /* Results */ + results.witnesses[0] = + results.witnesses[1] = btVector3(0, 0, 0); + results.status = btGjkEpaSolver3::sResults::Separated; + /* Shape */ + + shape.m_toshape1 = b.getWorldTransform().getBasis().transposeTimes(a.getWorldTransform().getBasis()); + shape.m_toshape0 = a.getWorldTransform().inverseTimes(b.getWorldTransform()); +} + +// +// Api +// + +// +template +bool btGjkEpaSolver3_Distance(const btConvexTemplate& a, const btConvexTemplate& b, + const btVector3& guess, + btGjkEpaSolver3::sResults& results) +{ + MinkowskiDiff shape(a, b); + Initialize(a, b, results, shape); + GJK gjk(a, b); + eGjkStatus gjk_status = gjk.Evaluate(shape, guess); + if (gjk_status == eGjkValid) + { + btVector3 w0 = btVector3(0, 0, 0); + btVector3 w1 = btVector3(0, 0, 0); + for (U i = 0; i < gjk.m_simplex->rank; ++i) + { + const btScalar p = gjk.m_simplex->p[i]; + w0 += shape.Support(gjk.m_simplex->c[i]->d, 0) * p; + w1 += shape.Support(-gjk.m_simplex->c[i]->d, 1) * p; + } + results.witnesses[0] = a.getWorldTransform() * w0; + results.witnesses[1] = a.getWorldTransform() * w1; + results.normal = w0 - w1; + results.distance = results.normal.length(); + results.normal /= results.distance > GJK_MIN_DISTANCE ? results.distance : 1; + return (true); + } + else + { + results.status = gjk_status == eGjkInside ? btGjkEpaSolver3::sResults::Penetrating : btGjkEpaSolver3::sResults::GJK_Failed; + return (false); + } +} + +template +bool btGjkEpaSolver3_Penetration(const btConvexTemplate& a, + const btConvexTemplate& b, + const btVector3& guess, + btGjkEpaSolver3::sResults& results) +{ + MinkowskiDiff shape(a, b); + Initialize(a, b, results, shape); + GJK gjk(a, b); + eGjkStatus gjk_status = gjk.Evaluate(shape, -guess); + switch (gjk_status) + { + case eGjkInside: + { + EPA epa; + eEpaStatus epa_status = epa.Evaluate(gjk, -guess); + if (epa_status != eEpaFailed) + { + btVector3 w0 = btVector3(0, 0, 0); + for (U i = 0; i < epa.m_result.rank; ++i) + { + w0 += shape.Support(epa.m_result.c[i]->d, 0) * epa.m_result.p[i]; + } + results.status = btGjkEpaSolver3::sResults::Penetrating; + results.witnesses[0] = a.getWorldTransform() * w0; + results.witnesses[1] = a.getWorldTransform() * (w0 - epa.m_normal * epa.m_depth); + results.normal = -epa.m_normal; + results.distance = -epa.m_depth; + return (true); + } + else + results.status = btGjkEpaSolver3::sResults::EPA_Failed; + } + break; + case eGjkFailed: + results.status = btGjkEpaSolver3::sResults::GJK_Failed; + break; + default: + { + } + } + return (false); +} + +#if 0 +int btComputeGjkEpaPenetration2(const btCollisionDescription& colDesc, btDistanceInfo* distInfo) +{ + btGjkEpaSolver3::sResults results; + btVector3 guess = colDesc.m_firstDir; + + bool res = btGjkEpaSolver3::Penetration(colDesc.m_objA,colDesc.m_objB, + colDesc.m_transformA,colDesc.m_transformB, + colDesc.m_localSupportFuncA,colDesc.m_localSupportFuncB, + guess, + results); + if (res) + { + if ((results.status==btGjkEpaSolver3::sResults::Penetrating) || results.status==GJK::eStatus::Inside) + { + //normal could be 'swapped' + + distInfo->m_distance = results.distance; + distInfo->m_normalBtoA = results.normal; + btVector3 tmpNormalInB = results.witnesses[1]-results.witnesses[0]; + btScalar lenSqr = tmpNormalInB.length2(); + if (lenSqr <= (SIMD_EPSILON*SIMD_EPSILON)) + { + tmpNormalInB = results.normal; + lenSqr = results.normal.length2(); + } + + if (lenSqr > (SIMD_EPSILON*SIMD_EPSILON)) + { + tmpNormalInB /= btSqrt(lenSqr); + btScalar distance2 = -(results.witnesses[0]-results.witnesses[1]).length(); + //only replace valid penetrations when the result is deeper (check) + //if ((distance2 < results.distance)) + { + distInfo->m_distance = distance2; + distInfo->m_pointOnA= results.witnesses[0]; + distInfo->m_pointOnB= results.witnesses[1]; + distInfo->m_normalBtoA= tmpNormalInB; + return 0; + } + } + } + + } + + return -1; +} +#endif + +template +int btComputeGjkDistance(const btConvexTemplate& a, const btConvexTemplate& b, + const btGjkCollisionDescription& colDesc, btDistanceInfoTemplate* distInfo) +{ + btGjkEpaSolver3::sResults results; + btVector3 guess = colDesc.m_firstDir; + + bool isSeparated = btGjkEpaSolver3_Distance(a, b, + guess, + results); + if (isSeparated) + { + distInfo->m_distance = results.distance; + distInfo->m_pointOnA = results.witnesses[0]; + distInfo->m_pointOnB = results.witnesses[1]; + distInfo->m_normalBtoA = results.normal; + return 0; + } + + return -1; +} + +/* Symbols cleanup */ + +#undef GJK_MAX_ITERATIONS +#undef GJK_ACCURARY +#undef GJK_MIN_DISTANCE +#undef GJK_DUPLICATED_EPS +#undef GJK_SIMPLEX2_EPS +#undef GJK_SIMPLEX3_EPS +#undef GJK_SIMPLEX4_EPS + +#undef EPA_MAX_VERTICES +#undef EPA_MAX_FACES +#undef EPA_MAX_ITERATIONS +#undef EPA_ACCURACY +#undef EPA_FALLBACK +#undef EPA_PLANE_EPS +#undef EPA_INSIDE_EPS + +#endif //BT_GJK_EPA3_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa3.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa3.h.i new file mode 100644 index 00000000..62d5a071 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpa3.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btGjkEpa3.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btGjkEpa3.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btGjkEpa3.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp new file mode 100644 index 00000000..3b79ddf8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp @@ -0,0 +1,81 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +EPA Copyright (c) Ricardo Padrela 2006 + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "btGjkEpaPenetrationDepthSolver.h" + +#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h" + +bool btGjkEpaPenetrationDepthSolver::calcPenDepth(btSimplexSolverInterface& simplexSolver, + const btConvexShape* pConvexA, const btConvexShape* pConvexB, + const btTransform& transformA, const btTransform& transformB, + btVector3& v, btVector3& wWitnessOnA, btVector3& wWitnessOnB, + class btIDebugDraw* debugDraw) +{ + (void)debugDraw; + (void)v; + (void)simplexSolver; + + btVector3 guessVectors[] = { + btVector3(transformB.getOrigin() - transformA.getOrigin()).safeNormalize(), + btVector3(transformA.getOrigin() - transformB.getOrigin()).safeNormalize(), + btVector3(0, 0, 1), + btVector3(0, 1, 0), + btVector3(1, 0, 0), + btVector3(1, 1, 0), + btVector3(1, 1, 1), + btVector3(0, 1, 1), + btVector3(1, 0, 1), + }; + + int numVectors = sizeof(guessVectors) / sizeof(btVector3); + + for (int i = 0; i < numVectors; i++) + { + simplexSolver.reset(); + btVector3 guessVector = guessVectors[i]; + + btGjkEpaSolver2::sResults results; + + if (btGjkEpaSolver2::Penetration(pConvexA, transformA, + pConvexB, transformB, + guessVector, results)) + + { + wWitnessOnA = results.witnesses[0]; + wWitnessOnB = results.witnesses[1]; + v = results.normal; + return true; + } + else + { + if (btGjkEpaSolver2::Distance(pConvexA, transformA, pConvexB, transformB, guessVector, results)) + { + wWitnessOnA = results.witnesses[0]; + wWitnessOnB = results.witnesses[1]; + v = results.normal; + return false; + } + } + } + + //failed to find a distance/penetration + wWitnessOnA.setValue(0, 0, 0); + wWitnessOnB.setValue(0, 0, 0); + v.setValue(0, 0, 0); + return false; +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp.i new file mode 100644 index 00000000..e58cf9f7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp ---------------- + +// %include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h new file mode 100644 index 00000000..90f0c174 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h @@ -0,0 +1,40 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +EPA Copyright (c) Ricardo Padrela 2006 + +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_GJP_EPA_PENETRATION_DEPTH_H +#define BT_GJP_EPA_PENETRATION_DEPTH_H + +#include "btConvexPenetrationDepthSolver.h" + +///EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to +///calculate the penetration depth between two convex shapes. +class btGjkEpaPenetrationDepthSolver : public btConvexPenetrationDepthSolver +{ +public: + btGjkEpaPenetrationDepthSolver() + { + } + + bool calcPenDepth(btSimplexSolverInterface& simplexSolver, + const btConvexShape* pConvexA, const btConvexShape* pConvexB, + const btTransform& transformA, const btTransform& transformB, + btVector3& v, btVector3& wWitnessOnA, btVector3& wWitnessOnB, + class btIDebugDraw* debugDraw); + +private: +}; + +#endif // BT_GJP_EPA_PENETRATION_DEPTH_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h.i new file mode 100644 index 00000000..41f817c0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp new file mode 100644 index 00000000..bee8c330 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp @@ -0,0 +1,1183 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btGjkPairDetector.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h" +#include "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h" + +#if defined(DEBUG) || defined(_DEBUG) +//#define TEST_NON_VIRTUAL 1 +#include //for debug printf +#ifdef __SPU__ +#include +#define printf spu_printf +#endif //__SPU__ +#endif + +//must be above the machine epsilon +#ifdef BT_USE_DOUBLE_PRECISION +#define REL_ERROR2 btScalar(1.0e-12) +btScalar gGjkEpaPenetrationTolerance = 1.0e-12; +#else +#define REL_ERROR2 btScalar(1.0e-6) +btScalar gGjkEpaPenetrationTolerance = 0.001; +#endif + + +btGjkPairDetector::btGjkPairDetector(const btConvexShape *objectA, const btConvexShape *objectB, btSimplexSolverInterface *simplexSolver, btConvexPenetrationDepthSolver *penetrationDepthSolver) + : m_cachedSeparatingAxis(btScalar(0.), btScalar(1.), btScalar(0.)), + m_penetrationDepthSolver(penetrationDepthSolver), + m_simplexSolver(simplexSolver), + m_minkowskiA(objectA), + m_minkowskiB(objectB), + m_shapeTypeA(objectA->getShapeType()), + m_shapeTypeB(objectB->getShapeType()), + m_marginA(objectA->getMargin()), + m_marginB(objectB->getMargin()), + m_ignoreMargin(false), + m_lastUsedMethod(-1), + m_catchDegeneracies(1), + m_fixContactNormalDirection(1) +{ +} +btGjkPairDetector::btGjkPairDetector(const btConvexShape *objectA, const btConvexShape *objectB, int shapeTypeA, int shapeTypeB, btScalar marginA, btScalar marginB, btSimplexSolverInterface *simplexSolver, btConvexPenetrationDepthSolver *penetrationDepthSolver) + : m_cachedSeparatingAxis(btScalar(0.), btScalar(1.), btScalar(0.)), + m_penetrationDepthSolver(penetrationDepthSolver), + m_simplexSolver(simplexSolver), + m_minkowskiA(objectA), + m_minkowskiB(objectB), + m_shapeTypeA(shapeTypeA), + m_shapeTypeB(shapeTypeB), + m_marginA(marginA), + m_marginB(marginB), + m_ignoreMargin(false), + m_lastUsedMethod(-1), + m_catchDegeneracies(1), + m_fixContactNormalDirection(1) +{ +} + +void btGjkPairDetector::getClosestPoints(const ClosestPointInput &input, Result &output, class btIDebugDraw *debugDraw, bool swapResults) +{ + (void)swapResults; + + getClosestPointsNonVirtual(input, output, debugDraw); +} + +static void btComputeSupport(const btConvexShape *convexA, const btTransform &localTransA, const btConvexShape *convexB, const btTransform &localTransB, const btVector3 &dir, bool check2d, btVector3 &supAworld, btVector3 &supBworld, btVector3 &aMinb) +{ + btVector3 separatingAxisInA = (dir)*localTransA.getBasis(); + btVector3 separatingAxisInB = (-dir) * localTransB.getBasis(); + + btVector3 pInANoMargin = convexA->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInA); + btVector3 qInBNoMargin = convexB->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInB); + + btVector3 pInA = pInANoMargin; + btVector3 qInB = qInBNoMargin; + + supAworld = localTransA(pInA); + supBworld = localTransB(qInB); + + if (check2d) + { + supAworld[2] = 0.f; + supBworld[2] = 0.f; + } + + aMinb = supAworld - supBworld; +} + +struct btSupportVector +{ + btVector3 v; //!< Support point in minkowski sum + btVector3 v1; //!< Support point in obj1 + btVector3 v2; //!< Support point in obj2 +}; + +struct btSimplex +{ + btSupportVector ps[4]; + int last; //!< index of last added point +}; + +static btVector3 ccd_vec3_origin(0, 0, 0); + +inline void btSimplexInit(btSimplex *s) +{ + s->last = -1; +} + +inline int btSimplexSize(const btSimplex *s) +{ + return s->last + 1; +} + +inline const btSupportVector *btSimplexPoint(const btSimplex *s, int idx) +{ + // here is no check on boundaries + return &s->ps[idx]; +} +inline void btSupportCopy(btSupportVector *d, const btSupportVector *s) +{ + *d = *s; +} + +inline void btVec3Copy(btVector3 *v, const btVector3 *w) +{ + *v = *w; +} + +inline void ccdVec3Add(btVector3 *v, const btVector3 *w) +{ + v->m_floats[0] += w->m_floats[0]; + v->m_floats[1] += w->m_floats[1]; + v->m_floats[2] += w->m_floats[2]; +} + +inline void ccdVec3Sub(btVector3 *v, const btVector3 *w) +{ + *v -= *w; +} +inline void btVec3Sub2(btVector3 *d, const btVector3 *v, const btVector3 *w) +{ + *d = (*v) - (*w); +} +inline btScalar btVec3Dot(const btVector3 *a, const btVector3 *b) +{ + btScalar dot; + dot = a->dot(*b); + + return dot; +} + +inline btScalar ccdVec3Dist2(const btVector3 *a, const btVector3 *b) +{ + btVector3 ab; + btVec3Sub2(&ab, a, b); + return btVec3Dot(&ab, &ab); +} + +inline void btVec3Scale(btVector3 *d, btScalar k) +{ + d->m_floats[0] *= k; + d->m_floats[1] *= k; + d->m_floats[2] *= k; +} + +inline void btVec3Cross(btVector3 *d, const btVector3 *a, const btVector3 *b) +{ + d->m_floats[0] = (a->m_floats[1] * b->m_floats[2]) - (a->m_floats[2] * b->m_floats[1]); + d->m_floats[1] = (a->m_floats[2] * b->m_floats[0]) - (a->m_floats[0] * b->m_floats[2]); + d->m_floats[2] = (a->m_floats[0] * b->m_floats[1]) - (a->m_floats[1] * b->m_floats[0]); +} + +inline void btTripleCross(const btVector3 *a, const btVector3 *b, + const btVector3 *c, btVector3 *d) +{ + btVector3 e; + btVec3Cross(&e, a, b); + btVec3Cross(d, &e, c); +} + +inline int ccdEq(btScalar _a, btScalar _b) +{ + btScalar ab; + btScalar a, b; + + ab = btFabs(_a - _b); + if (btFabs(ab) < SIMD_EPSILON) + return 1; + + a = btFabs(_a); + b = btFabs(_b); + if (b > a) + { + return ab < SIMD_EPSILON * b; + } + else + { + return ab < SIMD_EPSILON * a; + } +} + +btScalar ccdVec3X(const btVector3 *v) +{ + return v->x(); +} + +btScalar ccdVec3Y(const btVector3 *v) +{ + return v->y(); +} + +btScalar ccdVec3Z(const btVector3 *v) +{ + return v->z(); +} +inline int btVec3Eq(const btVector3 *a, const btVector3 *b) +{ + return ccdEq(ccdVec3X(a), ccdVec3X(b)) && ccdEq(ccdVec3Y(a), ccdVec3Y(b)) && ccdEq(ccdVec3Z(a), ccdVec3Z(b)); +} + +inline void btSimplexAdd(btSimplex *s, const btSupportVector *v) +{ + // here is no check on boundaries in sake of speed + ++s->last; + btSupportCopy(s->ps + s->last, v); +} + +inline void btSimplexSet(btSimplex *s, size_t pos, const btSupportVector *a) +{ + btSupportCopy(s->ps + pos, a); +} + +inline void btSimplexSetSize(btSimplex *s, int size) +{ + s->last = size - 1; +} + +inline const btSupportVector *ccdSimplexLast(const btSimplex *s) +{ + return btSimplexPoint(s, s->last); +} + +inline int ccdSign(btScalar val) +{ + if (btFuzzyZero(val)) + { + return 0; + } + else if (val < btScalar(0)) + { + return -1; + } + return 1; +} + +inline btScalar btVec3PointSegmentDist2(const btVector3 *P, + const btVector3 *x0, + const btVector3 *b, + btVector3 *witness) +{ + // The computation comes from solving equation of segment: + // S(t) = x0 + t.d + // where - x0 is initial point of segment + // - d is direction of segment from x0 (|d| > 0) + // - t belongs to <0, 1> interval + // + // Than, distance from a segment to some point P can be expressed: + // D(t) = |x0 + t.d - P|^2 + // which is distance from any point on segment. Minimization + // of this function brings distance from P to segment. + // Minimization of D(t) leads to simple quadratic equation that's + // solving is straightforward. + // + // Bonus of this method is witness point for free. + + btScalar dist, t; + btVector3 d, a; + + // direction of segment + btVec3Sub2(&d, b, x0); + + // precompute vector from P to x0 + btVec3Sub2(&a, x0, P); + + t = -btScalar(1.) * btVec3Dot(&a, &d); + t /= btVec3Dot(&d, &d); + + if (t < btScalar(0) || btFuzzyZero(t)) + { + dist = ccdVec3Dist2(x0, P); + if (witness) + btVec3Copy(witness, x0); + } + else if (t > btScalar(1) || ccdEq(t, btScalar(1))) + { + dist = ccdVec3Dist2(b, P); + if (witness) + btVec3Copy(witness, b); + } + else + { + if (witness) + { + btVec3Copy(witness, &d); + btVec3Scale(witness, t); + ccdVec3Add(witness, x0); + dist = ccdVec3Dist2(witness, P); + } + else + { + // recycling variables + btVec3Scale(&d, t); + ccdVec3Add(&d, &a); + dist = btVec3Dot(&d, &d); + } + } + + return dist; +} + +btScalar btVec3PointTriDist2(const btVector3 *P, + const btVector3 *x0, const btVector3 *B, + const btVector3 *C, + btVector3 *witness) +{ + // Computation comes from analytic expression for triangle (x0, B, C) + // T(s, t) = x0 + s.d1 + t.d2, where d1 = B - x0 and d2 = C - x0 and + // Then equation for distance is: + // D(s, t) = | T(s, t) - P |^2 + // This leads to minimization of quadratic function of two variables. + // The solution from is taken only if s is between 0 and 1, t is + // between 0 and 1 and t + s < 1, otherwise distance from segment is + // computed. + + btVector3 d1, d2, a; + double u, v, w, p, q, r; + double s, t, dist, dist2; + btVector3 witness2; + + btVec3Sub2(&d1, B, x0); + btVec3Sub2(&d2, C, x0); + btVec3Sub2(&a, x0, P); + + u = btVec3Dot(&a, &a); + v = btVec3Dot(&d1, &d1); + w = btVec3Dot(&d2, &d2); + p = btVec3Dot(&a, &d1); + q = btVec3Dot(&a, &d2); + r = btVec3Dot(&d1, &d2); + + s = (q * r - w * p) / (w * v - r * r); + t = (-s * r - q) / w; + + if ((btFuzzyZero(s) || s > btScalar(0)) && (ccdEq(s, btScalar(1)) || s < btScalar(1)) && (btFuzzyZero(t) || t > btScalar(0)) && (ccdEq(t, btScalar(1)) || t < btScalar(1)) && (ccdEq(t + s, btScalar(1)) || t + s < btScalar(1))) + { + if (witness) + { + btVec3Scale(&d1, s); + btVec3Scale(&d2, t); + btVec3Copy(witness, x0); + ccdVec3Add(witness, &d1); + ccdVec3Add(witness, &d2); + + dist = ccdVec3Dist2(witness, P); + } + else + { + dist = s * s * v; + dist += t * t * w; + dist += btScalar(2.) * s * t * r; + dist += btScalar(2.) * s * p; + dist += btScalar(2.) * t * q; + dist += u; + } + } + else + { + dist = btVec3PointSegmentDist2(P, x0, B, witness); + + dist2 = btVec3PointSegmentDist2(P, x0, C, &witness2); + if (dist2 < dist) + { + dist = dist2; + if (witness) + btVec3Copy(witness, &witness2); + } + + dist2 = btVec3PointSegmentDist2(P, B, C, &witness2); + if (dist2 < dist) + { + dist = dist2; + if (witness) + btVec3Copy(witness, &witness2); + } + } + + return dist; +} + +static int btDoSimplex2(btSimplex *simplex, btVector3 *dir) +{ + const btSupportVector *A, *B; + btVector3 AB, AO, tmp; + btScalar dot; + + // get last added as A + A = ccdSimplexLast(simplex); + // get the other point + B = btSimplexPoint(simplex, 0); + // compute AB oriented segment + btVec3Sub2(&AB, &B->v, &A->v); + // compute AO vector + btVec3Copy(&AO, &A->v); + btVec3Scale(&AO, -btScalar(1)); + + // dot product AB . AO + dot = btVec3Dot(&AB, &AO); + + // check if origin doesn't lie on AB segment + btVec3Cross(&tmp, &AB, &AO); + if (btFuzzyZero(btVec3Dot(&tmp, &tmp)) && dot > btScalar(0)) + { + return 1; + } + + // check if origin is in area where AB segment is + if (btFuzzyZero(dot) || dot < btScalar(0)) + { + // origin is in outside are of A + btSimplexSet(simplex, 0, A); + btSimplexSetSize(simplex, 1); + btVec3Copy(dir, &AO); + } + else + { + // origin is in area where AB segment is + + // keep simplex untouched and set direction to + // AB x AO x AB + btTripleCross(&AB, &AO, &AB, dir); + } + + return 0; +} + +static int btDoSimplex3(btSimplex *simplex, btVector3 *dir) +{ + const btSupportVector *A, *B, *C; + btVector3 AO, AB, AC, ABC, tmp; + btScalar dot, dist; + + // get last added as A + A = ccdSimplexLast(simplex); + // get the other points + B = btSimplexPoint(simplex, 1); + C = btSimplexPoint(simplex, 0); + + // check touching contact + dist = btVec3PointTriDist2(&ccd_vec3_origin, &A->v, &B->v, &C->v, 0); + if (btFuzzyZero(dist)) + { + return 1; + } + + // check if triangle is really triangle (has area > 0) + // if not simplex can't be expanded and thus no itersection is found + if (btVec3Eq(&A->v, &B->v) || btVec3Eq(&A->v, &C->v)) + { + return -1; + } + + // compute AO vector + btVec3Copy(&AO, &A->v); + btVec3Scale(&AO, -btScalar(1)); + + // compute AB and AC segments and ABC vector (perpendircular to triangle) + btVec3Sub2(&AB, &B->v, &A->v); + btVec3Sub2(&AC, &C->v, &A->v); + btVec3Cross(&ABC, &AB, &AC); + + btVec3Cross(&tmp, &ABC, &AC); + dot = btVec3Dot(&tmp, &AO); + if (btFuzzyZero(dot) || dot > btScalar(0)) + { + dot = btVec3Dot(&AC, &AO); + if (btFuzzyZero(dot) || dot > btScalar(0)) + { + // C is already in place + btSimplexSet(simplex, 1, A); + btSimplexSetSize(simplex, 2); + btTripleCross(&AC, &AO, &AC, dir); + } + else + { + dot = btVec3Dot(&AB, &AO); + if (btFuzzyZero(dot) || dot > btScalar(0)) + { + btSimplexSet(simplex, 0, B); + btSimplexSet(simplex, 1, A); + btSimplexSetSize(simplex, 2); + btTripleCross(&AB, &AO, &AB, dir); + } + else + { + btSimplexSet(simplex, 0, A); + btSimplexSetSize(simplex, 1); + btVec3Copy(dir, &AO); + } + } + } + else + { + btVec3Cross(&tmp, &AB, &ABC); + dot = btVec3Dot(&tmp, &AO); + if (btFuzzyZero(dot) || dot > btScalar(0)) + { + dot = btVec3Dot(&AB, &AO); + if (btFuzzyZero(dot) || dot > btScalar(0)) + { + btSimplexSet(simplex, 0, B); + btSimplexSet(simplex, 1, A); + btSimplexSetSize(simplex, 2); + btTripleCross(&AB, &AO, &AB, dir); + } + else + { + btSimplexSet(simplex, 0, A); + btSimplexSetSize(simplex, 1); + btVec3Copy(dir, &AO); + } + } + else + { + dot = btVec3Dot(&ABC, &AO); + if (btFuzzyZero(dot) || dot > btScalar(0)) + { + btVec3Copy(dir, &ABC); + } + else + { + btSupportVector tmp; + btSupportCopy(&tmp, C); + btSimplexSet(simplex, 0, B); + btSimplexSet(simplex, 1, &tmp); + + btVec3Copy(dir, &ABC); + btVec3Scale(dir, -btScalar(1)); + } + } + } + + return 0; +} + +static int btDoSimplex4(btSimplex *simplex, btVector3 *dir) +{ + const btSupportVector *A, *B, *C, *D; + btVector3 AO, AB, AC, AD, ABC, ACD, ADB; + int B_on_ACD, C_on_ADB, D_on_ABC; + int AB_O, AC_O, AD_O; + btScalar dist; + + // get last added as A + A = ccdSimplexLast(simplex); + // get the other points + B = btSimplexPoint(simplex, 2); + C = btSimplexPoint(simplex, 1); + D = btSimplexPoint(simplex, 0); + + // check if tetrahedron is really tetrahedron (has volume > 0) + // if it is not simplex can't be expanded and thus no intersection is + // found + dist = btVec3PointTriDist2(&A->v, &B->v, &C->v, &D->v, 0); + if (btFuzzyZero(dist)) + { + return -1; + } + + // check if origin lies on some of tetrahedron's face - if so objects + // intersect + dist = btVec3PointTriDist2(&ccd_vec3_origin, &A->v, &B->v, &C->v, 0); + if (btFuzzyZero(dist)) + return 1; + dist = btVec3PointTriDist2(&ccd_vec3_origin, &A->v, &C->v, &D->v, 0); + if (btFuzzyZero(dist)) + return 1; + dist = btVec3PointTriDist2(&ccd_vec3_origin, &A->v, &B->v, &D->v, 0); + if (btFuzzyZero(dist)) + return 1; + dist = btVec3PointTriDist2(&ccd_vec3_origin, &B->v, &C->v, &D->v, 0); + if (btFuzzyZero(dist)) + return 1; + + // compute AO, AB, AC, AD segments and ABC, ACD, ADB normal vectors + btVec3Copy(&AO, &A->v); + btVec3Scale(&AO, -btScalar(1)); + btVec3Sub2(&AB, &B->v, &A->v); + btVec3Sub2(&AC, &C->v, &A->v); + btVec3Sub2(&AD, &D->v, &A->v); + btVec3Cross(&ABC, &AB, &AC); + btVec3Cross(&ACD, &AC, &AD); + btVec3Cross(&ADB, &AD, &AB); + + // side (positive or negative) of B, C, D relative to planes ACD, ADB + // and ABC respectively + B_on_ACD = ccdSign(btVec3Dot(&ACD, &AB)); + C_on_ADB = ccdSign(btVec3Dot(&ADB, &AC)); + D_on_ABC = ccdSign(btVec3Dot(&ABC, &AD)); + + // whether origin is on same side of ACD, ADB, ABC as B, C, D + // respectively + AB_O = ccdSign(btVec3Dot(&ACD, &AO)) == B_on_ACD; + AC_O = ccdSign(btVec3Dot(&ADB, &AO)) == C_on_ADB; + AD_O = ccdSign(btVec3Dot(&ABC, &AO)) == D_on_ABC; + + if (AB_O && AC_O && AD_O) + { + // origin is in tetrahedron + return 1; + // rearrange simplex to triangle and call btDoSimplex3() + } + else if (!AB_O) + { + // B is farthest from the origin among all of the tetrahedron's + // points, so remove it from the list and go on with the triangle + // case + + // D and C are in place + btSimplexSet(simplex, 2, A); + btSimplexSetSize(simplex, 3); + } + else if (!AC_O) + { + // C is farthest + btSimplexSet(simplex, 1, D); + btSimplexSet(simplex, 0, B); + btSimplexSet(simplex, 2, A); + btSimplexSetSize(simplex, 3); + } + else + { // (!AD_O) + btSimplexSet(simplex, 0, C); + btSimplexSet(simplex, 1, B); + btSimplexSet(simplex, 2, A); + btSimplexSetSize(simplex, 3); + } + + return btDoSimplex3(simplex, dir); +} + +static int btDoSimplex(btSimplex *simplex, btVector3 *dir) +{ + if (btSimplexSize(simplex) == 2) + { + // simplex contains segment only one segment + return btDoSimplex2(simplex, dir); + } + else if (btSimplexSize(simplex) == 3) + { + // simplex contains triangle + return btDoSimplex3(simplex, dir); + } + else + { // btSimplexSize(simplex) == 4 + // tetrahedron - this is the only shape which can encapsule origin + // so btDoSimplex4() also contains test on it + return btDoSimplex4(simplex, dir); + } +} + +#ifdef __SPU__ +void btGjkPairDetector::getClosestPointsNonVirtual(const ClosestPointInput &input, Result &output, class btIDebugDraw *debugDraw) +#else +void btGjkPairDetector::getClosestPointsNonVirtual(const ClosestPointInput &input, Result &output, class btIDebugDraw *debugDraw) +#endif +{ + m_cachedSeparatingDistance = 0.f; + + btScalar distance = btScalar(0.); + btVector3 normalInB(btScalar(0.), btScalar(0.), btScalar(0.)); + + btVector3 pointOnA, pointOnB; + btTransform localTransA = input.m_transformA; + btTransform localTransB = input.m_transformB; + btVector3 positionOffset = (localTransA.getOrigin() + localTransB.getOrigin()) * btScalar(0.5); + localTransA.getOrigin() -= positionOffset; + localTransB.getOrigin() -= positionOffset; + + bool check2d = m_minkowskiA->isConvex2d() && m_minkowskiB->isConvex2d(); + + btScalar marginA = m_marginA; + btScalar marginB = m_marginB; + + + //for CCD we don't use margins + if (m_ignoreMargin) + { + marginA = btScalar(0.); + marginB = btScalar(0.); + } + + m_curIter = 0; + int gGjkMaxIter = 1000; //this is to catch invalid input, perhaps check for #NaN? + m_cachedSeparatingAxis.setValue(0, 1, 0); + + bool isValid = false; + bool checkSimplex = false; + bool checkPenetration = true; + m_degenerateSimplex = 0; + + m_lastUsedMethod = -1; + int status = -2; + btVector3 orgNormalInB(0, 0, 0); + btScalar margin = marginA + marginB; + + //we add a separate implementation to check if the convex shapes intersect + //See also "Real-time Collision Detection with Implicit Objects" by Leif Olvang + //Todo: integrate the simplex penetration check directly inside the Bullet btVoronoiSimplexSolver + //and remove this temporary code from libCCD + //this fixes issue https://github.com/bulletphysics/bullet3/issues/1703 + //note, for large differences in shapes, use double precision build! + { + btScalar squaredDistance = BT_LARGE_FLOAT; + btScalar delta = btScalar(0.); + + btSimplex simplex1; + btSimplex *simplex = &simplex1; + btSimplexInit(simplex); + + btVector3 dir(1, 0, 0); + + { + btVector3 lastSupV; + btVector3 supAworld; + btVector3 supBworld; + btComputeSupport(m_minkowskiA, localTransA, m_minkowskiB, localTransB, dir, check2d, supAworld, supBworld, lastSupV); + + btSupportVector last; + last.v = lastSupV; + last.v1 = supAworld; + last.v2 = supBworld; + + btSimplexAdd(simplex, &last); + + dir = -lastSupV; + + // start iterations + for (int iterations = 0; iterations < gGjkMaxIter; iterations++) + { + // obtain support point + btComputeSupport(m_minkowskiA, localTransA, m_minkowskiB, localTransB, dir, check2d, supAworld, supBworld, lastSupV); + + // check if farthest point in Minkowski difference in direction dir + // isn't somewhere before origin (the test on negative dot product) + // - because if it is, objects are not intersecting at all. + btScalar delta = lastSupV.dot(dir); + if (delta < 0) + { + //no intersection, besides margin + status = -1; + break; + } + + // add last support vector to simplex + last.v = lastSupV; + last.v1 = supAworld; + last.v2 = supBworld; + + btSimplexAdd(simplex, &last); + + // if btDoSimplex returns 1 if objects intersect, -1 if objects don't + // intersect and 0 if algorithm should continue + + btVector3 newDir; + int do_simplex_res = btDoSimplex(simplex, &dir); + + if (do_simplex_res == 1) + { + status = 0; // intersection found + break; + } + else if (do_simplex_res == -1) + { + // intersection not found + status = -1; + break; + } + + if (btFuzzyZero(btVec3Dot(&dir, &dir))) + { + // intersection not found + status = -1; + } + + if (dir.length2() < SIMD_EPSILON) + { + //no intersection, besides margin + status = -1; + break; + } + + if (dir.fuzzyZero()) + { + // intersection not found + status = -1; + break; + } + } + } + + m_simplexSolver->reset(); + if (status == 0) + { + //status = 0; + //printf("Intersect!\n"); + } + + if (status == -1) + { + //printf("not intersect\n"); + } + //printf("dir=%f,%f,%f\n",dir[0],dir[1],dir[2]); + if (1) + { + for (;;) + //while (true) + { + btVector3 separatingAxisInA = (-m_cachedSeparatingAxis) * localTransA.getBasis(); + btVector3 separatingAxisInB = m_cachedSeparatingAxis * localTransB.getBasis(); + + btVector3 pInA = m_minkowskiA->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInA); + btVector3 qInB = m_minkowskiB->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInB); + + btVector3 pWorld = localTransA(pInA); + btVector3 qWorld = localTransB(qInB); + + if (check2d) + { + pWorld[2] = 0.f; + qWorld[2] = 0.f; + } + + btVector3 w = pWorld - qWorld; + delta = m_cachedSeparatingAxis.dot(w); + + // potential exit, they don't overlap + if ((delta > btScalar(0.0)) && (delta * delta > squaredDistance * input.m_maximumDistanceSquared)) + { + m_degenerateSimplex = 10; + checkSimplex = true; + //checkPenetration = false; + break; + } + + //exit 0: the new point is already in the simplex, or we didn't come any closer + if (m_simplexSolver->inSimplex(w)) + { + m_degenerateSimplex = 1; + checkSimplex = true; + break; + } + // are we getting any closer ? + btScalar f0 = squaredDistance - delta; + btScalar f1 = squaredDistance * REL_ERROR2; + + if (f0 <= f1) + { + if (f0 <= btScalar(0.)) + { + m_degenerateSimplex = 2; + } + else + { + m_degenerateSimplex = 11; + } + checkSimplex = true; + break; + } + + //add current vertex to simplex + m_simplexSolver->addVertex(w, pWorld, qWorld); + btVector3 newCachedSeparatingAxis; + + //calculate the closest point to the origin (update vector v) + if (!m_simplexSolver->closest(newCachedSeparatingAxis)) + { + m_degenerateSimplex = 3; + checkSimplex = true; + break; + } + + if (newCachedSeparatingAxis.length2() < REL_ERROR2) + { + m_cachedSeparatingAxis = newCachedSeparatingAxis; + m_degenerateSimplex = 6; + checkSimplex = true; + break; + } + + btScalar previousSquaredDistance = squaredDistance; + squaredDistance = newCachedSeparatingAxis.length2(); +#if 0 + ///warning: this termination condition leads to some problems in 2d test case see Bullet/Demos/Box2dDemo + if (squaredDistance > previousSquaredDistance) + { + m_degenerateSimplex = 7; + squaredDistance = previousSquaredDistance; + checkSimplex = false; + break; + } +#endif // + + //redundant m_simplexSolver->compute_points(pointOnA, pointOnB); + + //are we getting any closer ? + if (previousSquaredDistance - squaredDistance <= SIMD_EPSILON * previousSquaredDistance) + { + // m_simplexSolver->backup_closest(m_cachedSeparatingAxis); + checkSimplex = true; + m_degenerateSimplex = 12; + + break; + } + + m_cachedSeparatingAxis = newCachedSeparatingAxis; + + //degeneracy, this is typically due to invalid/uninitialized worldtransforms for a btCollisionObject + if (m_curIter++ > gGjkMaxIter) + { +#if defined(DEBUG) || defined(_DEBUG) + + printf("btGjkPairDetector maxIter exceeded:%i\n", m_curIter); + printf("sepAxis=(%f,%f,%f), squaredDistance = %f, shapeTypeA=%i,shapeTypeB=%i\n", + m_cachedSeparatingAxis.getX(), + m_cachedSeparatingAxis.getY(), + m_cachedSeparatingAxis.getZ(), + squaredDistance, + m_minkowskiA->getShapeType(), + m_minkowskiB->getShapeType()); + +#endif + break; + } + + bool check = (!m_simplexSolver->fullSimplex()); + //bool check = (!m_simplexSolver->fullSimplex() && squaredDistance > SIMD_EPSILON * m_simplexSolver->maxVertex()); + + if (!check) + { + //do we need this backup_closest here ? + // m_simplexSolver->backup_closest(m_cachedSeparatingAxis); + m_degenerateSimplex = 13; + break; + } + } + + if (checkSimplex) + { + m_simplexSolver->compute_points(pointOnA, pointOnB); + normalInB = m_cachedSeparatingAxis; + + btScalar lenSqr = m_cachedSeparatingAxis.length2(); + + //valid normal + if (lenSqr < REL_ERROR2) + { + m_degenerateSimplex = 5; + } + if (lenSqr > SIMD_EPSILON * SIMD_EPSILON) + { + btScalar rlen = btScalar(1.) / btSqrt(lenSqr); + normalInB *= rlen; //normalize + + btScalar s = btSqrt(squaredDistance); + + btAssert(s > btScalar(0.0)); + pointOnA -= m_cachedSeparatingAxis * (marginA / s); + pointOnB += m_cachedSeparatingAxis * (marginB / s); + distance = ((btScalar(1.) / rlen) - margin); + isValid = true; + orgNormalInB = normalInB; + + m_lastUsedMethod = 1; + } + else + { + m_lastUsedMethod = 2; + } + } + } + + bool catchDegeneratePenetrationCase = + (m_catchDegeneracies && m_penetrationDepthSolver && m_degenerateSimplex && ((distance + margin) < gGjkEpaPenetrationTolerance)); + + //if (checkPenetration && !isValid) + if ((checkPenetration && (!isValid || catchDegeneratePenetrationCase)) || (status == 0)) + { + //penetration case + + //if there is no way to handle penetrations, bail out + if (m_penetrationDepthSolver) + { + // Penetration depth case. + btVector3 tmpPointOnA, tmpPointOnB; + + m_cachedSeparatingAxis.setZero(); + + bool isValid2 = m_penetrationDepthSolver->calcPenDepth( + *m_simplexSolver, + m_minkowskiA, m_minkowskiB, + localTransA, localTransB, + m_cachedSeparatingAxis, tmpPointOnA, tmpPointOnB, + debugDraw); + + if (m_cachedSeparatingAxis.length2()) + { + if (isValid2) + { + btVector3 tmpNormalInB = tmpPointOnB - tmpPointOnA; + btScalar lenSqr = tmpNormalInB.length2(); + if (lenSqr <= (SIMD_EPSILON * SIMD_EPSILON)) + { + tmpNormalInB = m_cachedSeparatingAxis; + lenSqr = m_cachedSeparatingAxis.length2(); + } + + if (lenSqr > (SIMD_EPSILON * SIMD_EPSILON)) + { + tmpNormalInB /= btSqrt(lenSqr); + btScalar distance2 = -(tmpPointOnA - tmpPointOnB).length(); + m_lastUsedMethod = 3; + //only replace valid penetrations when the result is deeper (check) + if (!isValid || (distance2 < distance)) + { + distance = distance2; + pointOnA = tmpPointOnA; + pointOnB = tmpPointOnB; + normalInB = tmpNormalInB; + isValid = true; + } + else + { + m_lastUsedMethod = 8; + } + } + else + { + m_lastUsedMethod = 9; + } + } + else + + { + ///this is another degenerate case, where the initial GJK calculation reports a degenerate case + ///EPA reports no penetration, and the second GJK (using the supporting vector without margin) + ///reports a valid positive distance. Use the results of the second GJK instead of failing. + ///thanks to Jacob.Langford for the reproduction case + ///http://code.google.com/p/bullet/issues/detail?id=250 + + if (m_cachedSeparatingAxis.length2() > btScalar(0.)) + { + btScalar distance2 = (tmpPointOnA - tmpPointOnB).length() - margin; + //only replace valid distances when the distance is less + if (!isValid || (distance2 < distance)) + { + distance = distance2; + pointOnA = tmpPointOnA; + pointOnB = tmpPointOnB; + pointOnA -= m_cachedSeparatingAxis * marginA; + pointOnB += m_cachedSeparatingAxis * marginB; + normalInB = m_cachedSeparatingAxis; + normalInB.normalize(); + + isValid = true; + m_lastUsedMethod = 6; + } + else + { + m_lastUsedMethod = 5; + } + } + } + } + else + { + //printf("EPA didn't return a valid value\n"); + } + } + } + } + + if (isValid && ((distance < 0) || (distance * distance < input.m_maximumDistanceSquared))) + { + m_cachedSeparatingAxis = normalInB; + m_cachedSeparatingDistance = distance; + if (1) + { + ///todo: need to track down this EPA penetration solver degeneracy + ///the penetration solver reports penetration but the contact normal + ///connecting the contact points is pointing in the opposite direction + ///until then, detect the issue and revert the normal + + btScalar d2 = 0.f; + { + btVector3 separatingAxisInA = (-orgNormalInB) * localTransA.getBasis(); + btVector3 separatingAxisInB = orgNormalInB * localTransB.getBasis(); + + btVector3 pInA = m_minkowskiA->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInA); + btVector3 qInB = m_minkowskiB->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInB); + + btVector3 pWorld = localTransA(pInA); + btVector3 qWorld = localTransB(qInB); + btVector3 w = pWorld - qWorld; + d2 = orgNormalInB.dot(w) - margin; + } + + btScalar d1 = 0; + { + btVector3 separatingAxisInA = (normalInB)*localTransA.getBasis(); + btVector3 separatingAxisInB = -normalInB * localTransB.getBasis(); + + btVector3 pInA = m_minkowskiA->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInA); + btVector3 qInB = m_minkowskiB->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInB); + + btVector3 pWorld = localTransA(pInA); + btVector3 qWorld = localTransB(qInB); + btVector3 w = pWorld - qWorld; + d1 = (-normalInB).dot(w) - margin; + } + btScalar d0 = 0.f; + { + btVector3 separatingAxisInA = (-normalInB) * input.m_transformA.getBasis(); + btVector3 separatingAxisInB = normalInB * input.m_transformB.getBasis(); + + btVector3 pInA = m_minkowskiA->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInA); + btVector3 qInB = m_minkowskiB->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInB); + + btVector3 pWorld = localTransA(pInA); + btVector3 qWorld = localTransB(qInB); + btVector3 w = pWorld - qWorld; + d0 = normalInB.dot(w) - margin; + } + + if (d1 > d0) + { + m_lastUsedMethod = 10; + normalInB *= -1; + } + + if (orgNormalInB.length2()) + { + if (d2 > d0 && d2 > d1 && d2 > distance) + { + normalInB = orgNormalInB; + distance = d2; + } + } + } + + output.addContactPoint( + normalInB, + pointOnB + positionOffset, + distance); + } + else + { + //printf("invalid gjk query\n"); + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp.i new file mode 100644 index 00000000..56ad040e --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp ---------------- + +// %include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h new file mode 100644 index 00000000..eee2f7da --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h @@ -0,0 +1,93 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_GJK_PAIR_DETECTOR_H +#define BT_GJK_PAIR_DETECTOR_H + +#include "btDiscreteCollisionDetectorInterface.h" +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" + +class btConvexShape; +#include "btSimplexSolverInterface.h" +class btConvexPenetrationDepthSolver; + +/// btGjkPairDetector uses GJK to implement the btDiscreteCollisionDetectorInterface +class btGjkPairDetector : public btDiscreteCollisionDetectorInterface +{ + btVector3 m_cachedSeparatingAxis; + btConvexPenetrationDepthSolver* m_penetrationDepthSolver; + btSimplexSolverInterface* m_simplexSolver; + const btConvexShape* m_minkowskiA; + const btConvexShape* m_minkowskiB; + int m_shapeTypeA; + int m_shapeTypeB; + btScalar m_marginA; + btScalar m_marginB; + + bool m_ignoreMargin; + btScalar m_cachedSeparatingDistance; + +public: + //some debugging to fix degeneracy problems + int m_lastUsedMethod; + int m_curIter; + int m_degenerateSimplex; + int m_catchDegeneracies; + int m_fixContactNormalDirection; + + btGjkPairDetector(const btConvexShape* objectA, const btConvexShape* objectB, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* penetrationDepthSolver); + btGjkPairDetector(const btConvexShape* objectA, const btConvexShape* objectB, int shapeTypeA, int shapeTypeB, btScalar marginA, btScalar marginB, btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* penetrationDepthSolver); + virtual ~btGjkPairDetector(){}; + + virtual void getClosestPoints(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw, bool swapResults = false); + + void getClosestPointsNonVirtual(const ClosestPointInput& input, Result& output, class btIDebugDraw* debugDraw); + + void setMinkowskiA(const btConvexShape* minkA) + { + m_minkowskiA = minkA; + } + + void setMinkowskiB(const btConvexShape* minkB) + { + m_minkowskiB = minkB; + } + void setCachedSeparatingAxis(const btVector3& separatingAxis) + { + m_cachedSeparatingAxis = separatingAxis; + } + + const btVector3& getCachedSeparatingAxis() const + { + return m_cachedSeparatingAxis; + } + btScalar getCachedSeparatingDistance() const + { + return m_cachedSeparatingDistance; + } + + void setPenetrationDepthSolver(btConvexPenetrationDepthSolver* penetrationDepthSolver) + { + m_penetrationDepthSolver = penetrationDepthSolver; + } + + ///don't use setIgnoreMargin, it's for Bullet's internal use + void setIgnoreMargin(bool ignoreMargin) + { + m_ignoreMargin = ignoreMargin; + } +}; + +#endif //BT_GJK_PAIR_DETECTOR_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h.i new file mode 100644 index 00000000..b4af58a2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h new file mode 100644 index 00000000..31323282 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h @@ -0,0 +1,182 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_MANIFOLD_CONTACT_POINT_H +#define BT_MANIFOLD_CONTACT_POINT_H + +#include "LinearMath/btVector3.h" +#include "LinearMath/btTransformUtil.h" + +#ifdef PFX_USE_FREE_VECTORMATH +#include "physics_effects/base_level/solver/pfx_constraint_row.h" +typedef sce::PhysicsEffects::PfxConstraintRow btConstraintRow; +#else +// Don't change following order of parameters +ATTRIBUTE_ALIGNED16(struct) +btConstraintRow +{ + btScalar m_normal[3]; + btScalar m_rhs; + btScalar m_jacDiagInv; + btScalar m_lowerLimit; + btScalar m_upperLimit; + btScalar m_accumImpulse; +}; +typedef btConstraintRow PfxConstraintRow; +#endif //PFX_USE_FREE_VECTORMATH + +enum btContactPointFlags +{ + BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED = 1, + BT_CONTACT_FLAG_HAS_CONTACT_CFM = 2, + BT_CONTACT_FLAG_HAS_CONTACT_ERP = 4, + BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING = 8, + BT_CONTACT_FLAG_FRICTION_ANCHOR = 16, +}; + +/// ManifoldContactPoint collects and maintains persistent contactpoints. +/// used to improve stability and performance of rigidbody dynamics response. +class btManifoldPoint +{ +public: + btManifoldPoint() + : m_userPersistentData(0), + m_contactPointFlags(0), + m_appliedImpulse(0.f), + m_prevRHS(0.f), + m_appliedImpulseLateral1(0.f), + m_appliedImpulseLateral2(0.f), + m_contactMotion1(0.f), + m_contactMotion2(0.f), + m_contactCFM(0.f), + m_contactERP(0.f), + m_frictionCFM(0.f), + m_lifeTime(0) + { + } + + btManifoldPoint(const btVector3& pointA, const btVector3& pointB, + const btVector3& normal, + btScalar distance) : m_localPointA(pointA), + m_localPointB(pointB), + m_positionWorldOnB(0,0,0), + m_positionWorldOnA(0,0,0), + m_normalWorldOnB(normal), + m_distance1(distance), + m_combinedFriction(btScalar(0.)), + m_combinedRollingFriction(btScalar(0.)), + m_combinedSpinningFriction(btScalar(0.)), + m_combinedRestitution(btScalar(0.)), + m_partId0(-1), + m_partId1(-1), + m_index0(-1), + m_index1(-1), + m_userPersistentData(0), + m_contactPointFlags(0), + m_appliedImpulse(0.f), + m_prevRHS(0.f), + m_appliedImpulseLateral1(0.f), + m_appliedImpulseLateral2(0.f), + m_contactMotion1(0.f), + m_contactMotion2(0.f), + m_contactCFM(0.f), + m_contactERP(0.f), + m_frictionCFM(0.f), + m_lifeTime(0), + m_lateralFrictionDir1(0,0,0), + m_lateralFrictionDir2(0,0,0) + { + } + + btVector3 m_localPointA; + btVector3 m_localPointB; + btVector3 m_positionWorldOnB; + ///m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity + btVector3 m_positionWorldOnA; + btVector3 m_normalWorldOnB; + + btScalar m_distance1; + btScalar m_combinedFriction; + btScalar m_combinedRollingFriction; //torsional friction orthogonal to contact normal, useful to make spheres stop rolling forever + btScalar m_combinedSpinningFriction; //torsional friction around contact normal, useful for grasping objects + btScalar m_combinedRestitution; + + //BP mod, store contact triangles. + int m_partId0; + int m_partId1; + int m_index0; + int m_index1; + + mutable void* m_userPersistentData; + //bool m_lateralFrictionInitialized; + int m_contactPointFlags; + + btScalar m_appliedImpulse; + btScalar m_prevRHS; + btScalar m_appliedImpulseLateral1; + btScalar m_appliedImpulseLateral2; + btScalar m_contactMotion1; + btScalar m_contactMotion2; + + union { + btScalar m_contactCFM; + btScalar m_combinedContactStiffness1; + }; + + union { + btScalar m_contactERP; + btScalar m_combinedContactDamping1; + }; + + btScalar m_frictionCFM; + + int m_lifeTime; //lifetime of the contactpoint in frames + + btVector3 m_lateralFrictionDir1; + btVector3 m_lateralFrictionDir2; + + btScalar getDistance() const + { + return m_distance1; + } + int getLifeTime() const + { + return m_lifeTime; + } + + const btVector3& getPositionWorldOnA() const + { + return m_positionWorldOnA; + // return m_positionWorldOnB + m_normalWorldOnB * m_distance1; + } + + const btVector3& getPositionWorldOnB() const + { + return m_positionWorldOnB; + } + + void setDistance(btScalar dist) + { + m_distance1 = dist; + } + + ///this returns the most recent applied impulse, to satisfy contact constraints by the constraint solver + btScalar getAppliedImpulse() const + { + return m_appliedImpulse; + } +}; + +#endif //BT_MANIFOLD_CONTACT_POINT_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h.i new file mode 100644 index 00000000..595c94a3 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btManifoldPoint.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp new file mode 100644 index 00000000..dcb29808 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp @@ -0,0 +1,336 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btMinkowskiPenetrationDepthSolver.h" +#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h" +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" + +#define NUM_UNITSPHERE_POINTS 42 + +bool btMinkowskiPenetrationDepthSolver::calcPenDepth(btSimplexSolverInterface& simplexSolver, + const btConvexShape* convexA, const btConvexShape* convexB, + const btTransform& transA, const btTransform& transB, + btVector3& v, btVector3& pa, btVector3& pb, + class btIDebugDraw* debugDraw) +{ + (void)v; + + bool check2d = convexA->isConvex2d() && convexB->isConvex2d(); + + struct btIntermediateResult : public btDiscreteCollisionDetectorInterface::Result + { + btIntermediateResult() : m_hasResult(false) + { + } + + btVector3 m_normalOnBInWorld; + btVector3 m_pointInWorld; + btScalar m_depth; + bool m_hasResult; + + virtual void setShapeIdentifiersA(int partId0, int index0) + { + (void)partId0; + (void)index0; + } + virtual void setShapeIdentifiersB(int partId1, int index1) + { + (void)partId1; + (void)index1; + } + void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth) + { + m_normalOnBInWorld = normalOnBInWorld; + m_pointInWorld = pointInWorld; + m_depth = depth; + m_hasResult = true; + } + }; + + //just take fixed number of orientation, and sample the penetration depth in that direction + btScalar minProj = btScalar(BT_LARGE_FLOAT); + btVector3 minNorm(btScalar(0.), btScalar(0.), btScalar(0.)); + btVector3 minA, minB; + btVector3 separatingAxisInA, separatingAxisInB; + btVector3 pInA, qInB, pWorld, qWorld, w; + +#ifndef __SPU__ +#define USE_BATCHED_SUPPORT 1 +#endif +#ifdef USE_BATCHED_SUPPORT + + btVector3 supportVerticesABatch[NUM_UNITSPHERE_POINTS + MAX_PREFERRED_PENETRATION_DIRECTIONS * 2]; + btVector3 supportVerticesBBatch[NUM_UNITSPHERE_POINTS + MAX_PREFERRED_PENETRATION_DIRECTIONS * 2]; + btVector3 separatingAxisInABatch[NUM_UNITSPHERE_POINTS + MAX_PREFERRED_PENETRATION_DIRECTIONS * 2]; + btVector3 separatingAxisInBBatch[NUM_UNITSPHERE_POINTS + MAX_PREFERRED_PENETRATION_DIRECTIONS * 2]; + int i; + + int numSampleDirections = NUM_UNITSPHERE_POINTS; + + for (i = 0; i < numSampleDirections; i++) + { + btVector3 norm = getPenetrationDirections()[i]; + separatingAxisInABatch[i] = (-norm) * transA.getBasis(); + separatingAxisInBBatch[i] = norm * transB.getBasis(); + } + + { + int numPDA = convexA->getNumPreferredPenetrationDirections(); + if (numPDA) + { + for (int i = 0; i < numPDA; i++) + { + btVector3 norm; + convexA->getPreferredPenetrationDirection(i, norm); + norm = transA.getBasis() * norm; + getPenetrationDirections()[numSampleDirections] = norm; + separatingAxisInABatch[numSampleDirections] = (-norm) * transA.getBasis(); + separatingAxisInBBatch[numSampleDirections] = norm * transB.getBasis(); + numSampleDirections++; + } + } + } + + { + int numPDB = convexB->getNumPreferredPenetrationDirections(); + if (numPDB) + { + for (int i = 0; i < numPDB; i++) + { + btVector3 norm; + convexB->getPreferredPenetrationDirection(i, norm); + norm = transB.getBasis() * norm; + getPenetrationDirections()[numSampleDirections] = norm; + separatingAxisInABatch[numSampleDirections] = (-norm) * transA.getBasis(); + separatingAxisInBBatch[numSampleDirections] = norm * transB.getBasis(); + numSampleDirections++; + } + } + } + + convexA->batchedUnitVectorGetSupportingVertexWithoutMargin(separatingAxisInABatch, supportVerticesABatch, numSampleDirections); + convexB->batchedUnitVectorGetSupportingVertexWithoutMargin(separatingAxisInBBatch, supportVerticesBBatch, numSampleDirections); + + for (i = 0; i < numSampleDirections; i++) + { + btVector3 norm = getPenetrationDirections()[i]; + if (check2d) + { + norm[2] = 0.f; + } + if (norm.length2() > 0.01) + { + separatingAxisInA = separatingAxisInABatch[i]; + separatingAxisInB = separatingAxisInBBatch[i]; + + pInA = supportVerticesABatch[i]; + qInB = supportVerticesBBatch[i]; + + pWorld = transA(pInA); + qWorld = transB(qInB); + if (check2d) + { + pWorld[2] = 0.f; + qWorld[2] = 0.f; + } + + w = qWorld - pWorld; + btScalar delta = norm.dot(w); + //find smallest delta + if (delta < minProj) + { + minProj = delta; + minNorm = norm; + minA = pWorld; + minB = qWorld; + } + } + } +#else + + int numSampleDirections = NUM_UNITSPHERE_POINTS; + +#ifndef __SPU__ + { + int numPDA = convexA->getNumPreferredPenetrationDirections(); + if (numPDA) + { + for (int i = 0; i < numPDA; i++) + { + btVector3 norm; + convexA->getPreferredPenetrationDirection(i, norm); + norm = transA.getBasis() * norm; + getPenetrationDirections()[numSampleDirections] = norm; + numSampleDirections++; + } + } + } + + { + int numPDB = convexB->getNumPreferredPenetrationDirections(); + if (numPDB) + { + for (int i = 0; i < numPDB; i++) + { + btVector3 norm; + convexB->getPreferredPenetrationDirection(i, norm); + norm = transB.getBasis() * norm; + getPenetrationDirections()[numSampleDirections] = norm; + numSampleDirections++; + } + } + } +#endif // __SPU__ + + for (int i = 0; i < numSampleDirections; i++) + { + const btVector3& norm = getPenetrationDirections()[i]; + separatingAxisInA = (-norm) * transA.getBasis(); + separatingAxisInB = norm * transB.getBasis(); + pInA = convexA->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInA); + qInB = convexB->localGetSupportVertexWithoutMarginNonVirtual(separatingAxisInB); + pWorld = transA(pInA); + qWorld = transB(qInB); + w = qWorld - pWorld; + btScalar delta = norm.dot(w); + //find smallest delta + if (delta < minProj) + { + minProj = delta; + minNorm = norm; + minA = pWorld; + minB = qWorld; + } + } +#endif //USE_BATCHED_SUPPORT + + //add the margins + + minA += minNorm * convexA->getMarginNonVirtual(); + minB -= minNorm * convexB->getMarginNonVirtual(); + //no penetration + if (minProj < btScalar(0.)) + return false; + + btScalar extraSeparation = 0.5f; ///scale dependent + minProj += extraSeparation + (convexA->getMarginNonVirtual() + convexB->getMarginNonVirtual()); + +//#define DEBUG_DRAW 1 +#ifdef DEBUG_DRAW + if (debugDraw) + { + btVector3 color(0, 1, 0); + debugDraw->drawLine(minA, minB, color); + color = btVector3(1, 1, 1); + btVector3 vec = minB - minA; + btScalar prj2 = minNorm.dot(vec); + debugDraw->drawLine(minA, minA + (minNorm * minProj), color); + } +#endif //DEBUG_DRAW + + btGjkPairDetector gjkdet(convexA, convexB, &simplexSolver, 0); + + btScalar offsetDist = minProj; + btVector3 offset = minNorm * offsetDist; + + btGjkPairDetector::ClosestPointInput input; + + btVector3 newOrg = transA.getOrigin() + offset; + + btTransform displacedTrans = transA; + displacedTrans.setOrigin(newOrg); + + input.m_transformA = displacedTrans; + input.m_transformB = transB; + input.m_maximumDistanceSquared = btScalar(BT_LARGE_FLOAT); //minProj; + + btIntermediateResult res; + gjkdet.setCachedSeparatingAxis(-minNorm); + gjkdet.getClosestPoints(input, res, debugDraw); + + btScalar correctedMinNorm = minProj - res.m_depth; + + //the penetration depth is over-estimated, relax it + btScalar penetration_relaxation = btScalar(1.); + minNorm *= penetration_relaxation; + + if (res.m_hasResult) + { + pa = res.m_pointInWorld - minNorm * correctedMinNorm; + pb = res.m_pointInWorld; + v = minNorm; + +#ifdef DEBUG_DRAW + if (debugDraw) + { + btVector3 color(1, 0, 0); + debugDraw->drawLine(pa, pb, color); + } +#endif //DEBUG_DRAW + } + return res.m_hasResult; +} + +btVector3* btMinkowskiPenetrationDepthSolver::getPenetrationDirections() +{ + static btVector3 sPenetrationDirections[NUM_UNITSPHERE_POINTS + MAX_PREFERRED_PENETRATION_DIRECTIONS * 2] = + { + btVector3(btScalar(0.000000), btScalar(-0.000000), btScalar(-1.000000)), + btVector3(btScalar(0.723608), btScalar(-0.525725), btScalar(-0.447219)), + btVector3(btScalar(-0.276388), btScalar(-0.850649), btScalar(-0.447219)), + btVector3(btScalar(-0.894426), btScalar(-0.000000), btScalar(-0.447216)), + btVector3(btScalar(-0.276388), btScalar(0.850649), btScalar(-0.447220)), + btVector3(btScalar(0.723608), btScalar(0.525725), btScalar(-0.447219)), + btVector3(btScalar(0.276388), btScalar(-0.850649), btScalar(0.447220)), + btVector3(btScalar(-0.723608), btScalar(-0.525725), btScalar(0.447219)), + btVector3(btScalar(-0.723608), btScalar(0.525725), btScalar(0.447219)), + btVector3(btScalar(0.276388), btScalar(0.850649), btScalar(0.447219)), + btVector3(btScalar(0.894426), btScalar(0.000000), btScalar(0.447216)), + btVector3(btScalar(-0.000000), btScalar(0.000000), btScalar(1.000000)), + btVector3(btScalar(0.425323), btScalar(-0.309011), btScalar(-0.850654)), + btVector3(btScalar(-0.162456), btScalar(-0.499995), btScalar(-0.850654)), + btVector3(btScalar(0.262869), btScalar(-0.809012), btScalar(-0.525738)), + btVector3(btScalar(0.425323), btScalar(0.309011), btScalar(-0.850654)), + btVector3(btScalar(0.850648), btScalar(-0.000000), btScalar(-0.525736)), + btVector3(btScalar(-0.525730), btScalar(-0.000000), btScalar(-0.850652)), + btVector3(btScalar(-0.688190), btScalar(-0.499997), btScalar(-0.525736)), + btVector3(btScalar(-0.162456), btScalar(0.499995), btScalar(-0.850654)), + btVector3(btScalar(-0.688190), btScalar(0.499997), btScalar(-0.525736)), + btVector3(btScalar(0.262869), btScalar(0.809012), btScalar(-0.525738)), + btVector3(btScalar(0.951058), btScalar(0.309013), btScalar(0.000000)), + btVector3(btScalar(0.951058), btScalar(-0.309013), btScalar(0.000000)), + btVector3(btScalar(0.587786), btScalar(-0.809017), btScalar(0.000000)), + btVector3(btScalar(0.000000), btScalar(-1.000000), btScalar(0.000000)), + btVector3(btScalar(-0.587786), btScalar(-0.809017), btScalar(0.000000)), + btVector3(btScalar(-0.951058), btScalar(-0.309013), btScalar(-0.000000)), + btVector3(btScalar(-0.951058), btScalar(0.309013), btScalar(-0.000000)), + btVector3(btScalar(-0.587786), btScalar(0.809017), btScalar(-0.000000)), + btVector3(btScalar(-0.000000), btScalar(1.000000), btScalar(-0.000000)), + btVector3(btScalar(0.587786), btScalar(0.809017), btScalar(-0.000000)), + btVector3(btScalar(0.688190), btScalar(-0.499997), btScalar(0.525736)), + btVector3(btScalar(-0.262869), btScalar(-0.809012), btScalar(0.525738)), + btVector3(btScalar(-0.850648), btScalar(0.000000), btScalar(0.525736)), + btVector3(btScalar(-0.262869), btScalar(0.809012), btScalar(0.525738)), + btVector3(btScalar(0.688190), btScalar(0.499997), btScalar(0.525736)), + btVector3(btScalar(0.525730), btScalar(0.000000), btScalar(0.850652)), + btVector3(btScalar(0.162456), btScalar(-0.499995), btScalar(0.850654)), + btVector3(btScalar(-0.425323), btScalar(-0.309011), btScalar(0.850654)), + btVector3(btScalar(-0.425323), btScalar(0.309011), btScalar(0.850654)), + btVector3(btScalar(0.162456), btScalar(0.499995), btScalar(0.850654))}; + + return sPenetrationDirections; +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp.i new file mode 100644 index 00000000..0246da6b --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp ---------------- + +// %include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h new file mode 100644 index 00000000..2ad663b1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h @@ -0,0 +1,36 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H +#define BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H + +#include "btConvexPenetrationDepthSolver.h" + +///MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation. +///Implementation is based on sampling the depth using support mapping, and using GJK step to get the witness points. +class btMinkowskiPenetrationDepthSolver : public btConvexPenetrationDepthSolver +{ +protected: + static btVector3* getPenetrationDirections(); + +public: + virtual bool calcPenDepth(btSimplexSolverInterface& simplexSolver, + const btConvexShape* convexA, const btConvexShape* convexB, + const btTransform& transA, const btTransform& transB, + btVector3& v, btVector3& pa, btVector3& pb, + class btIDebugDraw* debugDraw); +}; + +#endif //BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h.i new file mode 100644 index 00000000..340d1f7f --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMprPenetration.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMprPenetration.h new file mode 100644 index 00000000..534a66d3 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMprPenetration.h @@ -0,0 +1,884 @@ + +/*** + * --------------------------------- + * Copyright (c)2012 Daniel Fiser + * + * This file was ported from mpr.c file, part of libccd. + * The Minkoski Portal Refinement implementation was ported + * to OpenCL by Erwin Coumans for the Bullet 3 Physics library. + * The original MPR idea and implementation is by Gary Snethen + * in XenoCollide, see http://github.com/erwincoumans/xenocollide + * + * Distributed under the OSI-approved BSD License (the "License"); + * see . + * This software is distributed WITHOUT ANY WARRANTY; without even the + * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the License for more information. + */ + +///2014 Oct, Erwin Coumans, Use templates to avoid void* casts + +#ifndef BT_MPR_PENETRATION_H +#define BT_MPR_PENETRATION_H + +#define BT_DEBUG_MPR1 + +#include "LinearMath/btTransform.h" +#include "LinearMath/btAlignedObjectArray.h" + +//#define MPR_AVERAGE_CONTACT_POSITIONS + +struct btMprCollisionDescription +{ + btVector3 m_firstDir; + int m_maxGjkIterations; + btScalar m_maximumDistanceSquared; + btScalar m_gjkRelError2; + + btMprCollisionDescription() + : m_firstDir(0, 1, 0), + m_maxGjkIterations(1000), + m_maximumDistanceSquared(1e30f), + m_gjkRelError2(1.0e-6) + { + } + virtual ~btMprCollisionDescription() + { + } +}; + +struct btMprDistanceInfo +{ + btVector3 m_pointOnA; + btVector3 m_pointOnB; + btVector3 m_normalBtoA; + btScalar m_distance; +}; + +#ifdef __cplusplus +#define BT_MPR_SQRT sqrtf +#else +#define BT_MPR_SQRT sqrt +#endif +#define BT_MPR_FMIN(x, y) ((x) < (y) ? (x) : (y)) +#define BT_MPR_FABS fabs + +#define BT_MPR_TOLERANCE 1E-6f +#define BT_MPR_MAX_ITERATIONS 1000 + +struct _btMprSupport_t +{ + btVector3 v; //!< Support point in minkowski sum + btVector3 v1; //!< Support point in obj1 + btVector3 v2; //!< Support point in obj2 +}; +typedef struct _btMprSupport_t btMprSupport_t; + +struct _btMprSimplex_t +{ + btMprSupport_t ps[4]; + int last; //!< index of last added point +}; +typedef struct _btMprSimplex_t btMprSimplex_t; + +inline btMprSupport_t *btMprSimplexPointW(btMprSimplex_t *s, int idx) +{ + return &s->ps[idx]; +} + +inline void btMprSimplexSetSize(btMprSimplex_t *s, int size) +{ + s->last = size - 1; +} + +#ifdef DEBUG_MPR +inline void btPrintPortalVertex(_btMprSimplex_t *portal, int index) +{ + printf("portal[%d].v = %f,%f,%f, v1=%f,%f,%f, v2=%f,%f,%f\n", index, portal->ps[index].v.x(), portal->ps[index].v.y(), portal->ps[index].v.z(), + portal->ps[index].v1.x(), portal->ps[index].v1.y(), portal->ps[index].v1.z(), + portal->ps[index].v2.x(), portal->ps[index].v2.y(), portal->ps[index].v2.z()); +} +#endif //DEBUG_MPR + +inline int btMprSimplexSize(const btMprSimplex_t *s) +{ + return s->last + 1; +} + +inline const btMprSupport_t *btMprSimplexPoint(const btMprSimplex_t *s, int idx) +{ + // here is no check on boundaries + return &s->ps[idx]; +} + +inline void btMprSupportCopy(btMprSupport_t *d, const btMprSupport_t *s) +{ + *d = *s; +} + +inline void btMprSimplexSet(btMprSimplex_t *s, size_t pos, const btMprSupport_t *a) +{ + btMprSupportCopy(s->ps + pos, a); +} + +inline void btMprSimplexSwap(btMprSimplex_t *s, size_t pos1, size_t pos2) +{ + btMprSupport_t supp; + + btMprSupportCopy(&supp, &s->ps[pos1]); + btMprSupportCopy(&s->ps[pos1], &s->ps[pos2]); + btMprSupportCopy(&s->ps[pos2], &supp); +} + +inline int btMprIsZero(float val) +{ + return BT_MPR_FABS(val) < FLT_EPSILON; +} + +inline int btMprEq(float _a, float _b) +{ + float ab; + float a, b; + + ab = BT_MPR_FABS(_a - _b); + if (BT_MPR_FABS(ab) < FLT_EPSILON) + return 1; + + a = BT_MPR_FABS(_a); + b = BT_MPR_FABS(_b); + if (b > a) + { + return ab < FLT_EPSILON * b; + } + else + { + return ab < FLT_EPSILON * a; + } +} + +inline int btMprVec3Eq(const btVector3 *a, const btVector3 *b) +{ + return btMprEq((*a).x(), (*b).x()) && btMprEq((*a).y(), (*b).y()) && btMprEq((*a).z(), (*b).z()); +} + +template +inline void btFindOrigin(const btConvexTemplate &a, const btConvexTemplate &b, const btMprCollisionDescription &colDesc, btMprSupport_t *center) +{ + center->v1 = a.getObjectCenterInWorld(); + center->v2 = b.getObjectCenterInWorld(); + center->v = center->v1 - center->v2; +} + +inline void btMprVec3Set(btVector3 *v, float x, float y, float z) +{ + v->setValue(x, y, z); +} + +inline void btMprVec3Add(btVector3 *v, const btVector3 *w) +{ + *v += *w; +} + +inline void btMprVec3Copy(btVector3 *v, const btVector3 *w) +{ + *v = *w; +} + +inline void btMprVec3Scale(btVector3 *d, float k) +{ + *d *= k; +} + +inline float btMprVec3Dot(const btVector3 *a, const btVector3 *b) +{ + float dot; + + dot = btDot(*a, *b); + return dot; +} + +inline float btMprVec3Len2(const btVector3 *v) +{ + return btMprVec3Dot(v, v); +} + +inline void btMprVec3Normalize(btVector3 *d) +{ + float k = 1.f / BT_MPR_SQRT(btMprVec3Len2(d)); + btMprVec3Scale(d, k); +} + +inline void btMprVec3Cross(btVector3 *d, const btVector3 *a, const btVector3 *b) +{ + *d = btCross(*a, *b); +} + +inline void btMprVec3Sub2(btVector3 *d, const btVector3 *v, const btVector3 *w) +{ + *d = *v - *w; +} + +inline void btPortalDir(const btMprSimplex_t *portal, btVector3 *dir) +{ + btVector3 v2v1, v3v1; + + btMprVec3Sub2(&v2v1, &btMprSimplexPoint(portal, 2)->v, + &btMprSimplexPoint(portal, 1)->v); + btMprVec3Sub2(&v3v1, &btMprSimplexPoint(portal, 3)->v, + &btMprSimplexPoint(portal, 1)->v); + btMprVec3Cross(dir, &v2v1, &v3v1); + btMprVec3Normalize(dir); +} + +inline int portalEncapsulesOrigin(const btMprSimplex_t *portal, + const btVector3 *dir) +{ + float dot; + dot = btMprVec3Dot(dir, &btMprSimplexPoint(portal, 1)->v); + return btMprIsZero(dot) || dot > 0.f; +} + +inline int portalReachTolerance(const btMprSimplex_t *portal, + const btMprSupport_t *v4, + const btVector3 *dir) +{ + float dv1, dv2, dv3, dv4; + float dot1, dot2, dot3; + + // find the smallest dot product of dir and {v1-v4, v2-v4, v3-v4} + + dv1 = btMprVec3Dot(&btMprSimplexPoint(portal, 1)->v, dir); + dv2 = btMprVec3Dot(&btMprSimplexPoint(portal, 2)->v, dir); + dv3 = btMprVec3Dot(&btMprSimplexPoint(portal, 3)->v, dir); + dv4 = btMprVec3Dot(&v4->v, dir); + + dot1 = dv4 - dv1; + dot2 = dv4 - dv2; + dot3 = dv4 - dv3; + + dot1 = BT_MPR_FMIN(dot1, dot2); + dot1 = BT_MPR_FMIN(dot1, dot3); + + return btMprEq(dot1, BT_MPR_TOLERANCE) || dot1 < BT_MPR_TOLERANCE; +} + +inline int portalCanEncapsuleOrigin(const btMprSimplex_t *portal, + const btMprSupport_t *v4, + const btVector3 *dir) +{ + float dot; + dot = btMprVec3Dot(&v4->v, dir); + return btMprIsZero(dot) || dot > 0.f; +} + +inline void btExpandPortal(btMprSimplex_t *portal, + const btMprSupport_t *v4) +{ + float dot; + btVector3 v4v0; + + btMprVec3Cross(&v4v0, &v4->v, &btMprSimplexPoint(portal, 0)->v); + dot = btMprVec3Dot(&btMprSimplexPoint(portal, 1)->v, &v4v0); + if (dot > 0.f) + { + dot = btMprVec3Dot(&btMprSimplexPoint(portal, 2)->v, &v4v0); + if (dot > 0.f) + { + btMprSimplexSet(portal, 1, v4); + } + else + { + btMprSimplexSet(portal, 3, v4); + } + } + else + { + dot = btMprVec3Dot(&btMprSimplexPoint(portal, 3)->v, &v4v0); + if (dot > 0.f) + { + btMprSimplexSet(portal, 2, v4); + } + else + { + btMprSimplexSet(portal, 1, v4); + } + } +} +template +inline void btMprSupport(const btConvexTemplate &a, const btConvexTemplate &b, + const btMprCollisionDescription &colDesc, + const btVector3 &dir, btMprSupport_t *supp) +{ + btVector3 separatingAxisInA = dir * a.getWorldTransform().getBasis(); + btVector3 separatingAxisInB = -dir * b.getWorldTransform().getBasis(); + + btVector3 pInA = a.getLocalSupportWithMargin(separatingAxisInA); + btVector3 qInB = b.getLocalSupportWithMargin(separatingAxisInB); + + supp->v1 = a.getWorldTransform()(pInA); + supp->v2 = b.getWorldTransform()(qInB); + supp->v = supp->v1 - supp->v2; +} + +template +static int btDiscoverPortal(const btConvexTemplate &a, const btConvexTemplate &b, + const btMprCollisionDescription &colDesc, + btMprSimplex_t *portal) +{ + btVector3 dir, va, vb; + float dot; + int cont; + + // vertex 0 is center of portal + btFindOrigin(a, b, colDesc, btMprSimplexPointW(portal, 0)); + + // vertex 0 is center of portal + btMprSimplexSetSize(portal, 1); + + btVector3 zero = btVector3(0, 0, 0); + btVector3 *org = &zero; + + if (btMprVec3Eq(&btMprSimplexPoint(portal, 0)->v, org)) + { + // Portal's center lies on origin (0,0,0) => we know that objects + // intersect but we would need to know penetration info. + // So move center little bit... + btMprVec3Set(&va, FLT_EPSILON * 10.f, 0.f, 0.f); + btMprVec3Add(&btMprSimplexPointW(portal, 0)->v, &va); + } + + // vertex 1 = support in direction of origin + btMprVec3Copy(&dir, &btMprSimplexPoint(portal, 0)->v); + btMprVec3Scale(&dir, -1.f); + btMprVec3Normalize(&dir); + + btMprSupport(a, b, colDesc, dir, btMprSimplexPointW(portal, 1)); + + btMprSimplexSetSize(portal, 2); + + // test if origin isn't outside of v1 + dot = btMprVec3Dot(&btMprSimplexPoint(portal, 1)->v, &dir); + + if (btMprIsZero(dot) || dot < 0.f) + return -1; + + // vertex 2 + btMprVec3Cross(&dir, &btMprSimplexPoint(portal, 0)->v, + &btMprSimplexPoint(portal, 1)->v); + if (btMprIsZero(btMprVec3Len2(&dir))) + { + if (btMprVec3Eq(&btMprSimplexPoint(portal, 1)->v, org)) + { + // origin lies on v1 + return 1; + } + else + { + // origin lies on v0-v1 segment + return 2; + } + } + + btMprVec3Normalize(&dir); + btMprSupport(a, b, colDesc, dir, btMprSimplexPointW(portal, 2)); + + dot = btMprVec3Dot(&btMprSimplexPoint(portal, 2)->v, &dir); + if (btMprIsZero(dot) || dot < 0.f) + return -1; + + btMprSimplexSetSize(portal, 3); + + // vertex 3 direction + btMprVec3Sub2(&va, &btMprSimplexPoint(portal, 1)->v, + &btMprSimplexPoint(portal, 0)->v); + btMprVec3Sub2(&vb, &btMprSimplexPoint(portal, 2)->v, + &btMprSimplexPoint(portal, 0)->v); + btMprVec3Cross(&dir, &va, &vb); + btMprVec3Normalize(&dir); + + // it is better to form portal faces to be oriented "outside" origin + dot = btMprVec3Dot(&dir, &btMprSimplexPoint(portal, 0)->v); + if (dot > 0.f) + { + btMprSimplexSwap(portal, 1, 2); + btMprVec3Scale(&dir, -1.f); + } + + while (btMprSimplexSize(portal) < 4) + { + btMprSupport(a, b, colDesc, dir, btMprSimplexPointW(portal, 3)); + + dot = btMprVec3Dot(&btMprSimplexPoint(portal, 3)->v, &dir); + if (btMprIsZero(dot) || dot < 0.f) + return -1; + + cont = 0; + + // test if origin is outside (v1, v0, v3) - set v2 as v3 and + // continue + btMprVec3Cross(&va, &btMprSimplexPoint(portal, 1)->v, + &btMprSimplexPoint(portal, 3)->v); + dot = btMprVec3Dot(&va, &btMprSimplexPoint(portal, 0)->v); + if (dot < 0.f && !btMprIsZero(dot)) + { + btMprSimplexSet(portal, 2, btMprSimplexPoint(portal, 3)); + cont = 1; + } + + if (!cont) + { + // test if origin is outside (v3, v0, v2) - set v1 as v3 and + // continue + btMprVec3Cross(&va, &btMprSimplexPoint(portal, 3)->v, + &btMprSimplexPoint(portal, 2)->v); + dot = btMprVec3Dot(&va, &btMprSimplexPoint(portal, 0)->v); + if (dot < 0.f && !btMprIsZero(dot)) + { + btMprSimplexSet(portal, 1, btMprSimplexPoint(portal, 3)); + cont = 1; + } + } + + if (cont) + { + btMprVec3Sub2(&va, &btMprSimplexPoint(portal, 1)->v, + &btMprSimplexPoint(portal, 0)->v); + btMprVec3Sub2(&vb, &btMprSimplexPoint(portal, 2)->v, + &btMprSimplexPoint(portal, 0)->v); + btMprVec3Cross(&dir, &va, &vb); + btMprVec3Normalize(&dir); + } + else + { + btMprSimplexSetSize(portal, 4); + } + } + + return 0; +} + +template +static int btRefinePortal(const btConvexTemplate &a, const btConvexTemplate &b, const btMprCollisionDescription &colDesc, + btMprSimplex_t *portal) +{ + btVector3 dir; + btMprSupport_t v4; + + for (int i = 0; i < BT_MPR_MAX_ITERATIONS; i++) + //while (1) + { + // compute direction outside the portal (from v0 through v1,v2,v3 + // face) + btPortalDir(portal, &dir); + + // test if origin is inside the portal + if (portalEncapsulesOrigin(portal, &dir)) + return 0; + + // get next support point + + btMprSupport(a, b, colDesc, dir, &v4); + + // test if v4 can expand portal to contain origin and if portal + // expanding doesn't reach given tolerance + if (!portalCanEncapsuleOrigin(portal, &v4, &dir) || portalReachTolerance(portal, &v4, &dir)) + { + return -1; + } + + // v1-v2-v3 triangle must be rearranged to face outside Minkowski + // difference (direction from v0). + btExpandPortal(portal, &v4); + } + + return -1; +} + +static void btFindPos(const btMprSimplex_t *portal, btVector3 *pos) +{ + btVector3 zero = btVector3(0, 0, 0); + btVector3 *origin = &zero; + + btVector3 dir; + size_t i; + float b[4], sum, inv; + btVector3 vec, p1, p2; + + btPortalDir(portal, &dir); + + // use barycentric coordinates of tetrahedron to find origin + btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 1)->v, + &btMprSimplexPoint(portal, 2)->v); + b[0] = btMprVec3Dot(&vec, &btMprSimplexPoint(portal, 3)->v); + + btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 3)->v, + &btMprSimplexPoint(portal, 2)->v); + b[1] = btMprVec3Dot(&vec, &btMprSimplexPoint(portal, 0)->v); + + btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 0)->v, + &btMprSimplexPoint(portal, 1)->v); + b[2] = btMprVec3Dot(&vec, &btMprSimplexPoint(portal, 3)->v); + + btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 2)->v, + &btMprSimplexPoint(portal, 1)->v); + b[3] = btMprVec3Dot(&vec, &btMprSimplexPoint(portal, 0)->v); + + sum = b[0] + b[1] + b[2] + b[3]; + + if (btMprIsZero(sum) || sum < 0.f) + { + b[0] = 0.f; + + btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 2)->v, + &btMprSimplexPoint(portal, 3)->v); + b[1] = btMprVec3Dot(&vec, &dir); + btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 3)->v, + &btMprSimplexPoint(portal, 1)->v); + b[2] = btMprVec3Dot(&vec, &dir); + btMprVec3Cross(&vec, &btMprSimplexPoint(portal, 1)->v, + &btMprSimplexPoint(portal, 2)->v); + b[3] = btMprVec3Dot(&vec, &dir); + + sum = b[1] + b[2] + b[3]; + } + + inv = 1.f / sum; + + btMprVec3Copy(&p1, origin); + btMprVec3Copy(&p2, origin); + for (i = 0; i < 4; i++) + { + btMprVec3Copy(&vec, &btMprSimplexPoint(portal, i)->v1); + btMprVec3Scale(&vec, b[i]); + btMprVec3Add(&p1, &vec); + + btMprVec3Copy(&vec, &btMprSimplexPoint(portal, i)->v2); + btMprVec3Scale(&vec, b[i]); + btMprVec3Add(&p2, &vec); + } + btMprVec3Scale(&p1, inv); + btMprVec3Scale(&p2, inv); +#ifdef MPR_AVERAGE_CONTACT_POSITIONS + btMprVec3Copy(pos, &p1); + btMprVec3Add(pos, &p2); + btMprVec3Scale(pos, 0.5); +#else + btMprVec3Copy(pos, &p2); +#endif //MPR_AVERAGE_CONTACT_POSITIONS +} + +inline float btMprVec3Dist2(const btVector3 *a, const btVector3 *b) +{ + btVector3 ab; + btMprVec3Sub2(&ab, a, b); + return btMprVec3Len2(&ab); +} + +inline float _btMprVec3PointSegmentDist2(const btVector3 *P, + const btVector3 *x0, + const btVector3 *b, + btVector3 *witness) +{ + // The computation comes from solving equation of segment: + // S(t) = x0 + t.d + // where - x0 is initial point of segment + // - d is direction of segment from x0 (|d| > 0) + // - t belongs to <0, 1> interval + // + // Than, distance from a segment to some point P can be expressed: + // D(t) = |x0 + t.d - P|^2 + // which is distance from any point on segment. Minimization + // of this function brings distance from P to segment. + // Minimization of D(t) leads to simple quadratic equation that's + // solving is straightforward. + // + // Bonus of this method is witness point for free. + + float dist, t; + btVector3 d, a; + + // direction of segment + btMprVec3Sub2(&d, b, x0); + + // precompute vector from P to x0 + btMprVec3Sub2(&a, x0, P); + + t = -1.f * btMprVec3Dot(&a, &d); + t /= btMprVec3Len2(&d); + + if (t < 0.f || btMprIsZero(t)) + { + dist = btMprVec3Dist2(x0, P); + if (witness) + btMprVec3Copy(witness, x0); + } + else if (t > 1.f || btMprEq(t, 1.f)) + { + dist = btMprVec3Dist2(b, P); + if (witness) + btMprVec3Copy(witness, b); + } + else + { + if (witness) + { + btMprVec3Copy(witness, &d); + btMprVec3Scale(witness, t); + btMprVec3Add(witness, x0); + dist = btMprVec3Dist2(witness, P); + } + else + { + // recycling variables + btMprVec3Scale(&d, t); + btMprVec3Add(&d, &a); + dist = btMprVec3Len2(&d); + } + } + + return dist; +} + +inline float btMprVec3PointTriDist2(const btVector3 *P, + const btVector3 *x0, const btVector3 *B, + const btVector3 *C, + btVector3 *witness) +{ + // Computation comes from analytic expression for triangle (x0, B, C) + // T(s, t) = x0 + s.d1 + t.d2, where d1 = B - x0 and d2 = C - x0 and + // Then equation for distance is: + // D(s, t) = | T(s, t) - P |^2 + // This leads to minimization of quadratic function of two variables. + // The solution from is taken only if s is between 0 and 1, t is + // between 0 and 1 and t + s < 1, otherwise distance from segment is + // computed. + + btVector3 d1, d2, a; + float u, v, w, p, q, r; + float s, t, dist, dist2; + btVector3 witness2; + + btMprVec3Sub2(&d1, B, x0); + btMprVec3Sub2(&d2, C, x0); + btMprVec3Sub2(&a, x0, P); + + u = btMprVec3Dot(&a, &a); + v = btMprVec3Dot(&d1, &d1); + w = btMprVec3Dot(&d2, &d2); + p = btMprVec3Dot(&a, &d1); + q = btMprVec3Dot(&a, &d2); + r = btMprVec3Dot(&d1, &d2); + + btScalar div = (w * v - r * r); + if (btMprIsZero(div)) + { + s = -1; + } + else + { + s = (q * r - w * p) / div; + t = (-s * r - q) / w; + } + + if ((btMprIsZero(s) || s > 0.f) && (btMprEq(s, 1.f) || s < 1.f) && (btMprIsZero(t) || t > 0.f) && (btMprEq(t, 1.f) || t < 1.f) && (btMprEq(t + s, 1.f) || t + s < 1.f)) + { + if (witness) + { + btMprVec3Scale(&d1, s); + btMprVec3Scale(&d2, t); + btMprVec3Copy(witness, x0); + btMprVec3Add(witness, &d1); + btMprVec3Add(witness, &d2); + + dist = btMprVec3Dist2(witness, P); + } + else + { + dist = s * s * v; + dist += t * t * w; + dist += 2.f * s * t * r; + dist += 2.f * s * p; + dist += 2.f * t * q; + dist += u; + } + } + else + { + dist = _btMprVec3PointSegmentDist2(P, x0, B, witness); + + dist2 = _btMprVec3PointSegmentDist2(P, x0, C, &witness2); + if (dist2 < dist) + { + dist = dist2; + if (witness) + btMprVec3Copy(witness, &witness2); + } + + dist2 = _btMprVec3PointSegmentDist2(P, B, C, &witness2); + if (dist2 < dist) + { + dist = dist2; + if (witness) + btMprVec3Copy(witness, &witness2); + } + } + + return dist; +} + +template +static void btFindPenetr(const btConvexTemplate &a, const btConvexTemplate &b, + const btMprCollisionDescription &colDesc, + btMprSimplex_t *portal, + float *depth, btVector3 *pdir, btVector3 *pos) +{ + btVector3 dir; + btMprSupport_t v4; + unsigned long iterations; + + btVector3 zero = btVector3(0, 0, 0); + btVector3 *origin = &zero; + + iterations = 1UL; + for (int i = 0; i < BT_MPR_MAX_ITERATIONS; i++) + //while (1) + { + // compute portal direction and obtain next support point + btPortalDir(portal, &dir); + + btMprSupport(a, b, colDesc, dir, &v4); + + // reached tolerance -> find penetration info + if (portalReachTolerance(portal, &v4, &dir) || iterations == BT_MPR_MAX_ITERATIONS) + { + *depth = btMprVec3PointTriDist2(origin, &btMprSimplexPoint(portal, 1)->v, &btMprSimplexPoint(portal, 2)->v, &btMprSimplexPoint(portal, 3)->v, pdir); + *depth = BT_MPR_SQRT(*depth); + + if (btMprIsZero((*pdir).x()) && btMprIsZero((*pdir).y()) && btMprIsZero((*pdir).z())) + { + *pdir = dir; + } + btMprVec3Normalize(pdir); + + // barycentric coordinates: + btFindPos(portal, pos); + + return; + } + + btExpandPortal(portal, &v4); + + iterations++; + } +} + +static void btFindPenetrTouch(btMprSimplex_t *portal, float *depth, btVector3 *dir, btVector3 *pos) +{ + // Touching contact on portal's v1 - so depth is zero and direction + // is unimportant and pos can be guessed + *depth = 0.f; + btVector3 zero = btVector3(0, 0, 0); + btVector3 *origin = &zero; + + btMprVec3Copy(dir, origin); +#ifdef MPR_AVERAGE_CONTACT_POSITIONS + btMprVec3Copy(pos, &btMprSimplexPoint(portal, 1)->v1); + btMprVec3Add(pos, &btMprSimplexPoint(portal, 1)->v2); + btMprVec3Scale(pos, 0.5); +#else + btMprVec3Copy(pos, &btMprSimplexPoint(portal, 1)->v2); +#endif +} + +static void btFindPenetrSegment(btMprSimplex_t *portal, + float *depth, btVector3 *dir, btVector3 *pos) +{ + // Origin lies on v0-v1 segment. + // Depth is distance to v1, direction also and position must be + // computed +#ifdef MPR_AVERAGE_CONTACT_POSITIONS + btMprVec3Copy(pos, &btMprSimplexPoint(portal, 1)->v1); + btMprVec3Add(pos, &btMprSimplexPoint(portal, 1)->v2); + btMprVec3Scale(pos, 0.5f); +#else + btMprVec3Copy(pos, &btMprSimplexPoint(portal, 1)->v2); +#endif //MPR_AVERAGE_CONTACT_POSITIONS + + btMprVec3Copy(dir, &btMprSimplexPoint(portal, 1)->v); + *depth = BT_MPR_SQRT(btMprVec3Len2(dir)); + btMprVec3Normalize(dir); +} + +template +inline int btMprPenetration(const btConvexTemplate &a, const btConvexTemplate &b, + const btMprCollisionDescription &colDesc, + float *depthOut, btVector3 *dirOut, btVector3 *posOut) +{ + btMprSimplex_t portal; + + // Phase 1: Portal discovery + int result = btDiscoverPortal(a, b, colDesc, &portal); + + //sepAxis[pairIndex] = *pdir;//or -dir? + + switch (result) + { + case 0: + { + // Phase 2: Portal refinement + + result = btRefinePortal(a, b, colDesc, &portal); + if (result < 0) + return -1; + + // Phase 3. Penetration info + btFindPenetr(a, b, colDesc, &portal, depthOut, dirOut, posOut); + + break; + } + case 1: + { + // Touching contact on portal's v1. + btFindPenetrTouch(&portal, depthOut, dirOut, posOut); + result = 0; + break; + } + case 2: + { + btFindPenetrSegment(&portal, depthOut, dirOut, posOut); + result = 0; + break; + } + default: + { + //if (res < 0) + //{ + // Origin isn't inside portal - no collision. + result = -1; + //} + } + }; + + return result; +}; + +template +inline int btComputeMprPenetration(const btConvexTemplate &a, const btConvexTemplate &b, const btMprCollisionDescription &colDesc, btMprDistanceTemplate *distInfo) +{ + btVector3 dir, pos; + float depth; + + int res = btMprPenetration(a, b, colDesc, &depth, &dir, &pos); + if (res == 0) + { + distInfo->m_distance = -depth; + distInfo->m_pointOnB = pos; + distInfo->m_normalBtoA = -dir; + distInfo->m_pointOnA = pos - distInfo->m_distance * dir; + return 0; + } + + return -1; +} + +#endif //BT_MPR_PENETRATION_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMprPenetration.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMprPenetration.h.i new file mode 100644 index 00000000..1f277e43 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btMprPenetration.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btMprPenetration.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btMprPenetration.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btMprPenetration.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp new file mode 100644 index 00000000..366cf155 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp @@ -0,0 +1,450 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btPersistentManifold.h" +#include "LinearMath/btTransform.h" +#include "LinearMath/btSerializer.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define btCollisionObjectData btCollisionObjectDoubleData +#else +#define btCollisionObjectData btCollisionObjectFloatData +#endif + +btScalar gContactBreakingThreshold = btScalar(0.02); +ContactDestroyedCallback gContactDestroyedCallback = 0; +ContactProcessedCallback gContactProcessedCallback = 0; +ContactStartedCallback gContactStartedCallback = 0; +ContactEndedCallback gContactEndedCallback = 0; +///gContactCalcArea3Points will approximate the convex hull area using 3 points +///when setting it to false, it will use 4 points to compute the area: it is more accurate but slower +bool gContactCalcArea3Points = true; + +btPersistentManifold::btPersistentManifold() + : btTypedObject(BT_PERSISTENT_MANIFOLD_TYPE), + m_body0(0), + m_body1(0), + m_cachedPoints(0), + m_companionIdA(0), + m_companionIdB(0), + m_index1a(0) +{ +} + +#ifdef DEBUG_PERSISTENCY +#include +void btPersistentManifold::DebugPersistency() +{ + int i; + printf("DebugPersistency : numPoints %d\n", m_cachedPoints); + for (i = 0; i < m_cachedPoints; i++) + { + printf("m_pointCache[%d].m_userPersistentData = %x\n", i, m_pointCache[i].m_userPersistentData); + } +} +#endif //DEBUG_PERSISTENCY + +void btPersistentManifold::clearUserCache(btManifoldPoint& pt) +{ + void* oldPtr = pt.m_userPersistentData; + if (oldPtr) + { +#ifdef DEBUG_PERSISTENCY + int i; + int occurance = 0; + for (i = 0; i < m_cachedPoints; i++) + { + if (m_pointCache[i].m_userPersistentData == oldPtr) + { + occurance++; + if (occurance > 1) + printf("error in clearUserCache\n"); + } + } + btAssert(occurance <= 0); +#endif //DEBUG_PERSISTENCY + + if (pt.m_userPersistentData && gContactDestroyedCallback) + { + (*gContactDestroyedCallback)(pt.m_userPersistentData); + pt.m_userPersistentData = 0; + } + +#ifdef DEBUG_PERSISTENCY + DebugPersistency(); +#endif + } +} + +static inline btScalar calcArea4Points(const btVector3& p0, const btVector3& p1, const btVector3& p2, const btVector3& p3) +{ + // It calculates possible 3 area constructed from random 4 points and returns the biggest one. + + btVector3 a[3], b[3]; + a[0] = p0 - p1; + a[1] = p0 - p2; + a[2] = p0 - p3; + b[0] = p2 - p3; + b[1] = p1 - p3; + b[2] = p1 - p2; + + //todo: Following 3 cross production can be easily optimized by SIMD. + btVector3 tmp0 = a[0].cross(b[0]); + btVector3 tmp1 = a[1].cross(b[1]); + btVector3 tmp2 = a[2].cross(b[2]); + + return btMax(btMax(tmp0.length2(), tmp1.length2()), tmp2.length2()); +} + +int btPersistentManifold::sortCachedPoints(const btManifoldPoint& pt) +{ + //calculate 4 possible cases areas, and take biggest area + //also need to keep 'deepest' + + int maxPenetrationIndex = -1; +#define KEEP_DEEPEST_POINT 1 +#ifdef KEEP_DEEPEST_POINT + btScalar maxPenetration = pt.getDistance(); + for (int i = 0; i < 4; i++) + { + if (m_pointCache[i].getDistance() < maxPenetration) + { + maxPenetrationIndex = i; + maxPenetration = m_pointCache[i].getDistance(); + } + } +#endif //KEEP_DEEPEST_POINT + + btScalar res0(btScalar(0.)), res1(btScalar(0.)), res2(btScalar(0.)), res3(btScalar(0.)); + + if (gContactCalcArea3Points) + { + if (maxPenetrationIndex != 0) + { + btVector3 a0 = pt.m_localPointA - m_pointCache[1].m_localPointA; + btVector3 b0 = m_pointCache[3].m_localPointA - m_pointCache[2].m_localPointA; + btVector3 cross = a0.cross(b0); + res0 = cross.length2(); + } + if (maxPenetrationIndex != 1) + { + btVector3 a1 = pt.m_localPointA - m_pointCache[0].m_localPointA; + btVector3 b1 = m_pointCache[3].m_localPointA - m_pointCache[2].m_localPointA; + btVector3 cross = a1.cross(b1); + res1 = cross.length2(); + } + + if (maxPenetrationIndex != 2) + { + btVector3 a2 = pt.m_localPointA - m_pointCache[0].m_localPointA; + btVector3 b2 = m_pointCache[3].m_localPointA - m_pointCache[1].m_localPointA; + btVector3 cross = a2.cross(b2); + res2 = cross.length2(); + } + + if (maxPenetrationIndex != 3) + { + btVector3 a3 = pt.m_localPointA - m_pointCache[0].m_localPointA; + btVector3 b3 = m_pointCache[2].m_localPointA - m_pointCache[1].m_localPointA; + btVector3 cross = a3.cross(b3); + res3 = cross.length2(); + } + } + else + { + if (maxPenetrationIndex != 0) + { + res0 = calcArea4Points(pt.m_localPointA, m_pointCache[1].m_localPointA, m_pointCache[2].m_localPointA, m_pointCache[3].m_localPointA); + } + + if (maxPenetrationIndex != 1) + { + res1 = calcArea4Points(pt.m_localPointA, m_pointCache[0].m_localPointA, m_pointCache[2].m_localPointA, m_pointCache[3].m_localPointA); + } + + if (maxPenetrationIndex != 2) + { + res2 = calcArea4Points(pt.m_localPointA, m_pointCache[0].m_localPointA, m_pointCache[1].m_localPointA, m_pointCache[3].m_localPointA); + } + + if (maxPenetrationIndex != 3) + { + res3 = calcArea4Points(pt.m_localPointA, m_pointCache[0].m_localPointA, m_pointCache[1].m_localPointA, m_pointCache[2].m_localPointA); + } + } + btVector4 maxvec(res0, res1, res2, res3); + int biggestarea = maxvec.closestAxis4(); + return biggestarea; +} + +int btPersistentManifold::getCacheEntry(const btManifoldPoint& newPoint) const +{ + btScalar shortestDist = getContactBreakingThreshold() * getContactBreakingThreshold(); + int size = getNumContacts(); + int nearestPoint = -1; + for (int i = 0; i < size; i++) + { + const btManifoldPoint& mp = m_pointCache[i]; + + btVector3 diffA = mp.m_localPointA - newPoint.m_localPointA; + const btScalar distToManiPoint = diffA.dot(diffA); + if (distToManiPoint < shortestDist) + { + shortestDist = distToManiPoint; + nearestPoint = i; + } + } + return nearestPoint; +} + +int btPersistentManifold::addManifoldPoint(const btManifoldPoint& newPoint, bool isPredictive) +{ + if (!isPredictive) + { + btAssert(validContactDistance(newPoint)); + } + + int insertIndex = getNumContacts(); + if (insertIndex == MANIFOLD_CACHE_SIZE) + { +#if MANIFOLD_CACHE_SIZE >= 4 + //sort cache so best points come first, based on area + insertIndex = sortCachedPoints(newPoint); +#else + insertIndex = 0; +#endif + clearUserCache(m_pointCache[insertIndex]); + } + else + { + m_cachedPoints++; + } + if (insertIndex < 0) + insertIndex = 0; + + btAssert(m_pointCache[insertIndex].m_userPersistentData == 0); + m_pointCache[insertIndex] = newPoint; + return insertIndex; +} + +btScalar btPersistentManifold::getContactBreakingThreshold() const +{ + return m_contactBreakingThreshold; +} + +void btPersistentManifold::refreshContactPoints(const btTransform& trA, const btTransform& trB) +{ + int i; +#ifdef DEBUG_PERSISTENCY + printf("refreshContactPoints posA = (%f,%f,%f) posB = (%f,%f,%f)\n", + trA.getOrigin().getX(), + trA.getOrigin().getY(), + trA.getOrigin().getZ(), + trB.getOrigin().getX(), + trB.getOrigin().getY(), + trB.getOrigin().getZ()); +#endif //DEBUG_PERSISTENCY + /// first refresh worldspace positions and distance + for (i = getNumContacts() - 1; i >= 0; i--) + { + btManifoldPoint& manifoldPoint = m_pointCache[i]; + manifoldPoint.m_positionWorldOnA = trA(manifoldPoint.m_localPointA); + manifoldPoint.m_positionWorldOnB = trB(manifoldPoint.m_localPointB); + manifoldPoint.m_distance1 = (manifoldPoint.m_positionWorldOnA - manifoldPoint.m_positionWorldOnB).dot(manifoldPoint.m_normalWorldOnB); + manifoldPoint.m_lifeTime++; + } + + /// then + btScalar distance2d; + btVector3 projectedDifference, projectedPoint; + for (i = getNumContacts() - 1; i >= 0; i--) + { + btManifoldPoint& manifoldPoint = m_pointCache[i]; + //contact becomes invalid when signed distance exceeds margin (projected on contactnormal direction) + if (!validContactDistance(manifoldPoint)) + { + removeContactPoint(i); + } + else + { + //todo: friction anchor may require the contact to be around a bit longer + //contact also becomes invalid when relative movement orthogonal to normal exceeds margin + projectedPoint = manifoldPoint.m_positionWorldOnA - manifoldPoint.m_normalWorldOnB * manifoldPoint.m_distance1; + projectedDifference = manifoldPoint.m_positionWorldOnB - projectedPoint; + distance2d = projectedDifference.dot(projectedDifference); + if (distance2d > getContactBreakingThreshold() * getContactBreakingThreshold()) + { + removeContactPoint(i); + } + else + { + //contact point processed callback + if (gContactProcessedCallback) + (*gContactProcessedCallback)(manifoldPoint, (void*)m_body0, (void*)m_body1); + } + } + } +#ifdef DEBUG_PERSISTENCY + DebugPersistency(); +#endif // +} + +int btPersistentManifold::calculateSerializeBufferSize() const +{ + return sizeof(btPersistentManifoldData); +} + +const char* btPersistentManifold::serialize(const class btPersistentManifold* manifold, void* dataBuffer, class btSerializer* serializer) const +{ + btPersistentManifoldData* dataOut = (btPersistentManifoldData*)dataBuffer; + memset(dataOut, 0, sizeof(btPersistentManifoldData)); + + dataOut->m_body0 = (btCollisionObjectData*)serializer->getUniquePointer((void*)manifold->getBody0()); + dataOut->m_body1 = (btCollisionObjectData*)serializer->getUniquePointer((void*)manifold->getBody1()); + dataOut->m_contactBreakingThreshold = manifold->getContactBreakingThreshold(); + dataOut->m_contactProcessingThreshold = manifold->getContactProcessingThreshold(); + dataOut->m_numCachedPoints = manifold->getNumContacts(); + dataOut->m_companionIdA = manifold->m_companionIdA; + dataOut->m_companionIdB = manifold->m_companionIdB; + dataOut->m_index1a = manifold->m_index1a; + dataOut->m_objectType = manifold->m_objectType; + + for (int i = 0; i < this->getNumContacts(); i++) + { + const btManifoldPoint& pt = manifold->getContactPoint(i); + dataOut->m_pointCacheAppliedImpulse[i] = pt.m_appliedImpulse; + dataOut->m_pointCachePrevRHS[i] = pt.m_prevRHS; + dataOut->m_pointCacheAppliedImpulseLateral1[i] = pt.m_appliedImpulseLateral1; + dataOut->m_pointCacheAppliedImpulseLateral2[i] = pt.m_appliedImpulseLateral2; + pt.m_localPointA.serialize(dataOut->m_pointCacheLocalPointA[i]); + pt.m_localPointB.serialize(dataOut->m_pointCacheLocalPointB[i]); + pt.m_normalWorldOnB.serialize(dataOut->m_pointCacheNormalWorldOnB[i]); + dataOut->m_pointCacheDistance[i] = pt.m_distance1; + dataOut->m_pointCacheCombinedContactDamping1[i] = pt.m_combinedContactDamping1; + dataOut->m_pointCacheCombinedContactStiffness1[i] = pt.m_combinedContactStiffness1; + dataOut->m_pointCacheLifeTime[i] = pt.m_lifeTime; + dataOut->m_pointCacheFrictionCFM[i] = pt.m_frictionCFM; + dataOut->m_pointCacheContactERP[i] = pt.m_contactERP; + dataOut->m_pointCacheContactCFM[i] = pt.m_contactCFM; + dataOut->m_pointCacheContactPointFlags[i] = pt.m_contactPointFlags; + dataOut->m_pointCacheIndex0[i] = pt.m_index0; + dataOut->m_pointCacheIndex1[i] = pt.m_index1; + dataOut->m_pointCachePartId0[i] = pt.m_partId0; + dataOut->m_pointCachePartId1[i] = pt.m_partId1; + pt.m_positionWorldOnA.serialize(dataOut->m_pointCachePositionWorldOnA[i]); + pt.m_positionWorldOnB.serialize(dataOut->m_pointCachePositionWorldOnB[i]); + dataOut->m_pointCacheCombinedFriction[i] = pt.m_combinedFriction; + pt.m_lateralFrictionDir1.serialize(dataOut->m_pointCacheLateralFrictionDir1[i]); + pt.m_lateralFrictionDir2.serialize(dataOut->m_pointCacheLateralFrictionDir2[i]); + dataOut->m_pointCacheCombinedRollingFriction[i] = pt.m_combinedRollingFriction; + dataOut->m_pointCacheCombinedSpinningFriction[i] = pt.m_combinedSpinningFriction; + dataOut->m_pointCacheCombinedRestitution[i] = pt.m_combinedRestitution; + dataOut->m_pointCacheContactMotion1[i] = pt.m_contactMotion1; + dataOut->m_pointCacheContactMotion2[i] = pt.m_contactMotion2; + } + return btPersistentManifoldDataName; +} + +void btPersistentManifold::deSerialize(const struct btPersistentManifoldDoubleData* manifoldDataPtr) +{ + m_contactBreakingThreshold = manifoldDataPtr->m_contactBreakingThreshold; + m_contactProcessingThreshold = manifoldDataPtr->m_contactProcessingThreshold; + m_cachedPoints = manifoldDataPtr->m_numCachedPoints; + m_companionIdA = manifoldDataPtr->m_companionIdA; + m_companionIdB = manifoldDataPtr->m_companionIdB; + //m_index1a = manifoldDataPtr->m_index1a; + m_objectType = manifoldDataPtr->m_objectType; + + for (int i = 0; i < this->getNumContacts(); i++) + { + btManifoldPoint& pt = m_pointCache[i]; + + pt.m_appliedImpulse = manifoldDataPtr->m_pointCacheAppliedImpulse[i]; + pt.m_prevRHS = manifoldDataPtr->m_pointCachePrevRHS[i]; + pt.m_appliedImpulseLateral1 = manifoldDataPtr->m_pointCacheAppliedImpulseLateral1[i]; + pt.m_appliedImpulseLateral2 = manifoldDataPtr->m_pointCacheAppliedImpulseLateral2[i]; + pt.m_localPointA.deSerializeDouble(manifoldDataPtr->m_pointCacheLocalPointA[i]); + pt.m_localPointB.deSerializeDouble(manifoldDataPtr->m_pointCacheLocalPointB[i]); + pt.m_normalWorldOnB.deSerializeDouble(manifoldDataPtr->m_pointCacheNormalWorldOnB[i]); + pt.m_distance1 = manifoldDataPtr->m_pointCacheDistance[i]; + pt.m_combinedContactDamping1 = manifoldDataPtr->m_pointCacheCombinedContactDamping1[i]; + pt.m_combinedContactStiffness1 = manifoldDataPtr->m_pointCacheCombinedContactStiffness1[i]; + pt.m_lifeTime = manifoldDataPtr->m_pointCacheLifeTime[i]; + pt.m_frictionCFM = manifoldDataPtr->m_pointCacheFrictionCFM[i]; + pt.m_contactERP = manifoldDataPtr->m_pointCacheContactERP[i]; + pt.m_contactCFM = manifoldDataPtr->m_pointCacheContactCFM[i]; + pt.m_contactPointFlags = manifoldDataPtr->m_pointCacheContactPointFlags[i]; + pt.m_index0 = manifoldDataPtr->m_pointCacheIndex0[i]; + pt.m_index1 = manifoldDataPtr->m_pointCacheIndex1[i]; + pt.m_partId0 = manifoldDataPtr->m_pointCachePartId0[i]; + pt.m_partId1 = manifoldDataPtr->m_pointCachePartId1[i]; + pt.m_positionWorldOnA.deSerializeDouble(manifoldDataPtr->m_pointCachePositionWorldOnA[i]); + pt.m_positionWorldOnB.deSerializeDouble(manifoldDataPtr->m_pointCachePositionWorldOnB[i]); + pt.m_combinedFriction = manifoldDataPtr->m_pointCacheCombinedFriction[i]; + pt.m_lateralFrictionDir1.deSerializeDouble(manifoldDataPtr->m_pointCacheLateralFrictionDir1[i]); + pt.m_lateralFrictionDir2.deSerializeDouble(manifoldDataPtr->m_pointCacheLateralFrictionDir2[i]); + pt.m_combinedRollingFriction = manifoldDataPtr->m_pointCacheCombinedRollingFriction[i]; + pt.m_combinedSpinningFriction = manifoldDataPtr->m_pointCacheCombinedSpinningFriction[i]; + pt.m_combinedRestitution = manifoldDataPtr->m_pointCacheCombinedRestitution[i]; + pt.m_contactMotion1 = manifoldDataPtr->m_pointCacheContactMotion1[i]; + pt.m_contactMotion2 = manifoldDataPtr->m_pointCacheContactMotion2[i]; + } +} + +void btPersistentManifold::deSerialize(const struct btPersistentManifoldFloatData* manifoldDataPtr) +{ + m_contactBreakingThreshold = manifoldDataPtr->m_contactBreakingThreshold; + m_contactProcessingThreshold = manifoldDataPtr->m_contactProcessingThreshold; + m_cachedPoints = manifoldDataPtr->m_numCachedPoints; + m_companionIdA = manifoldDataPtr->m_companionIdA; + m_companionIdB = manifoldDataPtr->m_companionIdB; + //m_index1a = manifoldDataPtr->m_index1a; + m_objectType = manifoldDataPtr->m_objectType; + + for (int i = 0; i < this->getNumContacts(); i++) + { + btManifoldPoint& pt = m_pointCache[i]; + + pt.m_appliedImpulse = manifoldDataPtr->m_pointCacheAppliedImpulse[i]; + pt.m_prevRHS = manifoldDataPtr->m_pointCachePrevRHS[i]; + pt.m_appliedImpulseLateral1 = manifoldDataPtr->m_pointCacheAppliedImpulseLateral1[i]; + pt.m_appliedImpulseLateral2 = manifoldDataPtr->m_pointCacheAppliedImpulseLateral2[i]; + pt.m_localPointA.deSerialize(manifoldDataPtr->m_pointCacheLocalPointA[i]); + pt.m_localPointB.deSerialize(manifoldDataPtr->m_pointCacheLocalPointB[i]); + pt.m_normalWorldOnB.deSerialize(manifoldDataPtr->m_pointCacheNormalWorldOnB[i]); + pt.m_distance1 = manifoldDataPtr->m_pointCacheDistance[i]; + pt.m_combinedContactDamping1 = manifoldDataPtr->m_pointCacheCombinedContactDamping1[i]; + pt.m_combinedContactStiffness1 = manifoldDataPtr->m_pointCacheCombinedContactStiffness1[i]; + pt.m_lifeTime = manifoldDataPtr->m_pointCacheLifeTime[i]; + pt.m_frictionCFM = manifoldDataPtr->m_pointCacheFrictionCFM[i]; + pt.m_contactERP = manifoldDataPtr->m_pointCacheContactERP[i]; + pt.m_contactCFM = manifoldDataPtr->m_pointCacheContactCFM[i]; + pt.m_contactPointFlags = manifoldDataPtr->m_pointCacheContactPointFlags[i]; + pt.m_index0 = manifoldDataPtr->m_pointCacheIndex0[i]; + pt.m_index1 = manifoldDataPtr->m_pointCacheIndex1[i]; + pt.m_partId0 = manifoldDataPtr->m_pointCachePartId0[i]; + pt.m_partId1 = manifoldDataPtr->m_pointCachePartId1[i]; + pt.m_positionWorldOnA.deSerialize(manifoldDataPtr->m_pointCachePositionWorldOnA[i]); + pt.m_positionWorldOnB.deSerialize(manifoldDataPtr->m_pointCachePositionWorldOnB[i]); + pt.m_combinedFriction = manifoldDataPtr->m_pointCacheCombinedFriction[i]; + pt.m_lateralFrictionDir1.deSerialize(manifoldDataPtr->m_pointCacheLateralFrictionDir1[i]); + pt.m_lateralFrictionDir2.deSerialize(manifoldDataPtr->m_pointCacheLateralFrictionDir2[i]); + pt.m_combinedRollingFriction = manifoldDataPtr->m_pointCacheCombinedRollingFriction[i]; + pt.m_combinedSpinningFriction = manifoldDataPtr->m_pointCacheCombinedSpinningFriction[i]; + pt.m_combinedRestitution = manifoldDataPtr->m_pointCacheCombinedRestitution[i]; + pt.m_contactMotion1 = manifoldDataPtr->m_pointCacheContactMotion1[i]; + pt.m_contactMotion2 = manifoldDataPtr->m_pointCacheContactMotion2[i]; + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp.i new file mode 100644 index 00000000..0b2c5b36 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp ---------------- + +// %include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h new file mode 100644 index 00000000..b07e4868 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h @@ -0,0 +1,374 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_PERSISTENT_MANIFOLD_H +#define BT_PERSISTENT_MANIFOLD_H + +#include "LinearMath/btVector3.h" +#include "LinearMath/btTransform.h" +#include "btManifoldPoint.h" +class btCollisionObject; +#include "LinearMath/btAlignedAllocator.h" + +struct btCollisionResult; +struct btCollisionObjectDoubleData; +struct btCollisionObjectFloatData; + +///maximum contact breaking and merging threshold +extern btScalar gContactBreakingThreshold; + +#ifndef SWIG +class btPersistentManifold; + +typedef bool (*ContactDestroyedCallback)(void* userPersistentData); +typedef bool (*ContactProcessedCallback)(btManifoldPoint& cp, void* body0, void* body1); +typedef void (*ContactStartedCallback)(btPersistentManifold* const& manifold); +typedef void (*ContactEndedCallback)(btPersistentManifold* const& manifold); +extern ContactDestroyedCallback gContactDestroyedCallback; +extern ContactProcessedCallback gContactProcessedCallback; +extern ContactStartedCallback gContactStartedCallback; +extern ContactEndedCallback gContactEndedCallback; +#endif //SWIG + +//the enum starts at 1024 to avoid type conflicts with btTypedConstraint +enum btContactManifoldTypes +{ + MIN_CONTACT_MANIFOLD_TYPE = 1024, + BT_PERSISTENT_MANIFOLD_TYPE +}; + +#define MANIFOLD_CACHE_SIZE 4 + +///btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase. +///Those contact points are created by the collision narrow phase. +///The cache can be empty, or hold 1,2,3 or 4 points. Some collision algorithms (GJK) might only add one point at a time. +///updates/refreshes old contact points, and throw them away if necessary (distance becomes too large) +///reduces the cache to 4 points, when more then 4 points are added, using following rules: +///the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points +///note that some pairs of objects might have more then one contact manifold. + +//ATTRIBUTE_ALIGNED128( class) btPersistentManifold : public btTypedObject +ATTRIBUTE_ALIGNED16(class) +btPersistentManifold : public btTypedObject +{ + btManifoldPoint m_pointCache[MANIFOLD_CACHE_SIZE]; + + /// this two body pointers can point to the physics rigidbody class. + const btCollisionObject* m_body0; + const btCollisionObject* m_body1; + + int m_cachedPoints; + + btScalar m_contactBreakingThreshold; + btScalar m_contactProcessingThreshold; + + /// sort cached points so most isolated points come first + int sortCachedPoints(const btManifoldPoint& pt); + + int findContactPoint(const btManifoldPoint* unUsed, int numUnused, const btManifoldPoint& pt); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + int m_companionIdA; + int m_companionIdB; + + int m_index1a; + + btPersistentManifold(); + + btPersistentManifold(const btCollisionObject* body0, const btCollisionObject* body1, int, btScalar contactBreakingThreshold, btScalar contactProcessingThreshold) + : btTypedObject(BT_PERSISTENT_MANIFOLD_TYPE), + m_body0(body0), + m_body1(body1), + m_cachedPoints(0), + m_contactBreakingThreshold(contactBreakingThreshold), + m_contactProcessingThreshold(contactProcessingThreshold), + m_companionIdA(0), + m_companionIdB(0), + m_index1a(0) + { + } + + SIMD_FORCE_INLINE const btCollisionObject* getBody0() const { return m_body0; } + SIMD_FORCE_INLINE const btCollisionObject* getBody1() const { return m_body1; } + + void setBodies(const btCollisionObject* body0, const btCollisionObject* body1) + { + m_body0 = body0; + m_body1 = body1; + } + + void clearUserCache(btManifoldPoint & pt); + +#ifdef DEBUG_PERSISTENCY + void DebugPersistency(); +#endif // + + SIMD_FORCE_INLINE int getNumContacts() const + { + return m_cachedPoints; + } + /// the setNumContacts API is usually not used, except when you gather/fill all contacts manually + void setNumContacts(int cachedPoints) + { + m_cachedPoints = cachedPoints; + } + + SIMD_FORCE_INLINE const btManifoldPoint& getContactPoint(int index) const + { + btAssert(index < m_cachedPoints); + return m_pointCache[index]; + } + + SIMD_FORCE_INLINE btManifoldPoint& getContactPoint(int index) + { + btAssert(index < m_cachedPoints); + return m_pointCache[index]; + } + + ///@todo: get this margin from the current physics / collision environment + btScalar getContactBreakingThreshold() const; + + btScalar getContactProcessingThreshold() const + { + return m_contactProcessingThreshold; + } + + void setContactBreakingThreshold(btScalar contactBreakingThreshold) + { + m_contactBreakingThreshold = contactBreakingThreshold; + } + + void setContactProcessingThreshold(btScalar contactProcessingThreshold) + { + m_contactProcessingThreshold = contactProcessingThreshold; + } + + int getCacheEntry(const btManifoldPoint& newPoint) const; + + int addManifoldPoint(const btManifoldPoint& newPoint, bool isPredictive = false); + + void removeContactPoint(int index) + { + clearUserCache(m_pointCache[index]); + + int lastUsedIndex = getNumContacts() - 1; + // m_pointCache[index] = m_pointCache[lastUsedIndex]; + if (index != lastUsedIndex) + { + m_pointCache[index] = m_pointCache[lastUsedIndex]; + //get rid of duplicated userPersistentData pointer + m_pointCache[lastUsedIndex].m_userPersistentData = 0; + m_pointCache[lastUsedIndex].m_appliedImpulse = 0.f; + m_pointCache[lastUsedIndex].m_prevRHS = 0.f; + m_pointCache[lastUsedIndex].m_contactPointFlags = 0; + m_pointCache[lastUsedIndex].m_appliedImpulseLateral1 = 0.f; + m_pointCache[lastUsedIndex].m_appliedImpulseLateral2 = 0.f; + m_pointCache[lastUsedIndex].m_lifeTime = 0; + } + + btAssert(m_pointCache[lastUsedIndex].m_userPersistentData == 0); + m_cachedPoints--; + + if (gContactEndedCallback && m_cachedPoints == 0) + { + gContactEndedCallback(this); + } + } + void replaceContactPoint(const btManifoldPoint& newPoint, int insertIndex) + { + btAssert(validContactDistance(newPoint)); + +#define MAINTAIN_PERSISTENCY 1 +#ifdef MAINTAIN_PERSISTENCY + int lifeTime = m_pointCache[insertIndex].getLifeTime(); + btScalar appliedImpulse = m_pointCache[insertIndex].m_appliedImpulse; + btScalar prevRHS = m_pointCache[insertIndex].m_prevRHS; + btScalar appliedLateralImpulse1 = m_pointCache[insertIndex].m_appliedImpulseLateral1; + btScalar appliedLateralImpulse2 = m_pointCache[insertIndex].m_appliedImpulseLateral2; + + bool replacePoint = true; + ///we keep existing contact points for friction anchors + ///if the friction force is within the Coulomb friction cone + if (newPoint.m_contactPointFlags & BT_CONTACT_FLAG_FRICTION_ANCHOR) + { + // printf("appliedImpulse=%f\n", appliedImpulse); + // printf("appliedLateralImpulse1=%f\n", appliedLateralImpulse1); + // printf("appliedLateralImpulse2=%f\n", appliedLateralImpulse2); + // printf("mu = %f\n", m_pointCache[insertIndex].m_combinedFriction); + btScalar mu = m_pointCache[insertIndex].m_combinedFriction; + btScalar eps = 0; //we could allow to enlarge or shrink the tolerance to check against the friction cone a bit, say 1e-7 + btScalar a = appliedLateralImpulse1 * appliedLateralImpulse1 + appliedLateralImpulse2 * appliedLateralImpulse2; + btScalar b = eps + mu * appliedImpulse; + b = b * b; + replacePoint = (a) > (b); + } + + if (replacePoint) + { + btAssert(lifeTime >= 0); + void* cache = m_pointCache[insertIndex].m_userPersistentData; + + m_pointCache[insertIndex] = newPoint; + m_pointCache[insertIndex].m_userPersistentData = cache; + m_pointCache[insertIndex].m_appliedImpulse = appliedImpulse; + m_pointCache[insertIndex].m_prevRHS = prevRHS; + m_pointCache[insertIndex].m_appliedImpulseLateral1 = appliedLateralImpulse1; + m_pointCache[insertIndex].m_appliedImpulseLateral2 = appliedLateralImpulse2; + } + + m_pointCache[insertIndex].m_lifeTime = lifeTime; +#else + clearUserCache(m_pointCache[insertIndex]); + m_pointCache[insertIndex] = newPoint; + +#endif + } + + bool validContactDistance(const btManifoldPoint& pt) const + { + return pt.m_distance1 <= getContactBreakingThreshold(); + } + /// calculated new worldspace coordinates and depth, and reject points that exceed the collision margin + void refreshContactPoints(const btTransform& trA, const btTransform& trB); + + SIMD_FORCE_INLINE void clearManifold() + { + int i; + for (i = 0; i < m_cachedPoints; i++) + { + clearUserCache(m_pointCache[i]); + } + + if (gContactEndedCallback && m_cachedPoints) + { + gContactEndedCallback(this); + } + m_cachedPoints = 0; + } + + int calculateSerializeBufferSize() const; + const char* serialize(const class btPersistentManifold* manifold, void* dataBuffer, class btSerializer* serializer) const; + void deSerialize(const struct btPersistentManifoldDoubleData* manifoldDataPtr); + void deSerialize(const struct btPersistentManifoldFloatData* manifoldDataPtr); +}; + +// clang-format off + +struct btPersistentManifoldDoubleData +{ + btVector3DoubleData m_pointCacheLocalPointA[4]; + btVector3DoubleData m_pointCacheLocalPointB[4]; + btVector3DoubleData m_pointCachePositionWorldOnA[4]; + btVector3DoubleData m_pointCachePositionWorldOnB[4]; + btVector3DoubleData m_pointCacheNormalWorldOnB[4]; + btVector3DoubleData m_pointCacheLateralFrictionDir1[4]; + btVector3DoubleData m_pointCacheLateralFrictionDir2[4]; + double m_pointCacheDistance[4]; + double m_pointCacheAppliedImpulse[4]; + double m_pointCachePrevRHS[4]; + double m_pointCacheCombinedFriction[4]; + double m_pointCacheCombinedRollingFriction[4]; + double m_pointCacheCombinedSpinningFriction[4]; + double m_pointCacheCombinedRestitution[4]; + int m_pointCachePartId0[4]; + int m_pointCachePartId1[4]; + int m_pointCacheIndex0[4]; + int m_pointCacheIndex1[4]; + int m_pointCacheContactPointFlags[4]; + double m_pointCacheAppliedImpulseLateral1[4]; + double m_pointCacheAppliedImpulseLateral2[4]; + double m_pointCacheContactMotion1[4]; + double m_pointCacheContactMotion2[4]; + double m_pointCacheContactCFM[4]; + double m_pointCacheCombinedContactStiffness1[4]; + double m_pointCacheContactERP[4]; + double m_pointCacheCombinedContactDamping1[4]; + double m_pointCacheFrictionCFM[4]; + int m_pointCacheLifeTime[4]; + + int m_numCachedPoints; + int m_companionIdA; + int m_companionIdB; + int m_index1a; + + int m_objectType; + double m_contactBreakingThreshold; + double m_contactProcessingThreshold; + int m_padding; + + btCollisionObjectDoubleData *m_body0; + btCollisionObjectDoubleData *m_body1; +}; + + +struct btPersistentManifoldFloatData +{ + btVector3FloatData m_pointCacheLocalPointA[4]; + btVector3FloatData m_pointCacheLocalPointB[4]; + btVector3FloatData m_pointCachePositionWorldOnA[4]; + btVector3FloatData m_pointCachePositionWorldOnB[4]; + btVector3FloatData m_pointCacheNormalWorldOnB[4]; + btVector3FloatData m_pointCacheLateralFrictionDir1[4]; + btVector3FloatData m_pointCacheLateralFrictionDir2[4]; + float m_pointCacheDistance[4]; + float m_pointCacheAppliedImpulse[4]; + float m_pointCachePrevRHS[4]; + float m_pointCacheCombinedFriction[4]; + float m_pointCacheCombinedRollingFriction[4]; + float m_pointCacheCombinedSpinningFriction[4]; + float m_pointCacheCombinedRestitution[4]; + int m_pointCachePartId0[4]; + int m_pointCachePartId1[4]; + int m_pointCacheIndex0[4]; + int m_pointCacheIndex1[4]; + int m_pointCacheContactPointFlags[4]; + float m_pointCacheAppliedImpulseLateral1[4]; + float m_pointCacheAppliedImpulseLateral2[4]; + float m_pointCacheContactMotion1[4]; + float m_pointCacheContactMotion2[4]; + float m_pointCacheContactCFM[4]; + float m_pointCacheCombinedContactStiffness1[4]; + float m_pointCacheContactERP[4]; + float m_pointCacheCombinedContactDamping1[4]; + float m_pointCacheFrictionCFM[4]; + int m_pointCacheLifeTime[4]; + + int m_numCachedPoints; + int m_companionIdA; + int m_companionIdB; + int m_index1a; + + int m_objectType; + float m_contactBreakingThreshold; + float m_contactProcessingThreshold; + int m_padding; + + btCollisionObjectFloatData *m_body0; + btCollisionObjectFloatData *m_body1; +}; + +// clang-format on + +#ifdef BT_USE_DOUBLE_PRECISION +#define btPersistentManifoldData btPersistentManifoldDoubleData +#define btPersistentManifoldDataName "btPersistentManifoldDoubleData" +#else +#define btPersistentManifoldData btPersistentManifoldFloatData +#define btPersistentManifoldDataName "btPersistentManifoldFloatData" +#endif //BT_USE_DOUBLE_PRECISION + +#endif //BT_PERSISTENT_MANIFOLD_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h.i new file mode 100644 index 00000000..d214d0cd --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btPersistentManifold.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPointCollector.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPointCollector.h new file mode 100644 index 00000000..adebcbee --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPointCollector.h @@ -0,0 +1,58 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_POINT_COLLECTOR_H +#define BT_POINT_COLLECTOR_H + +#include "btDiscreteCollisionDetectorInterface.h" + +struct btPointCollector : public btDiscreteCollisionDetectorInterface::Result +{ + btVector3 m_normalOnBInWorld; + btVector3 m_pointInWorld; + btScalar m_distance; //negative means penetration + + bool m_hasResult; + + btPointCollector() + : m_distance(btScalar(BT_LARGE_FLOAT)), m_hasResult(false) + { + } + + virtual void setShapeIdentifiersA(int partId0, int index0) + { + (void)partId0; + (void)index0; + } + virtual void setShapeIdentifiersB(int partId1, int index1) + { + (void)partId1; + (void)index1; + } + + virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth) + { + if (depth < m_distance) + { + m_hasResult = true; + m_normalOnBInWorld = normalOnBInWorld; + m_pointInWorld = pointInWorld; + //negative means penetration + m_distance = depth; + } + } +}; + +#endif //BT_POINT_COLLECTOR_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPointCollector.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPointCollector.h.i new file mode 100644 index 00000000..051e500d --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPointCollector.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btPointCollector.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btPointCollector.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btPointCollector.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp new file mode 100644 index 00000000..9d183603 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp @@ -0,0 +1,548 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///This file was written by Erwin Coumans +///Separating axis rest based on work from Pierre Terdiman, see +///And contact clipping based on work from Simon Hobbs + +#include "btPolyhedralContactClipping.h" +#include "BulletCollision/CollisionShapes/btConvexPolyhedron.h" + +#include //for FLT_MAX + +int gExpectedNbTests = 0; +int gActualNbTests = 0; +bool gUseInternalObject = true; + +// Clips a face to the back of a plane +void btPolyhedralContactClipping::clipFace(const btVertexArray& pVtxIn, btVertexArray& ppVtxOut, const btVector3& planeNormalWS, btScalar planeEqWS) +{ + int ve; + btScalar ds, de; + int numVerts = pVtxIn.size(); + if (numVerts < 2) + return; + + btVector3 firstVertex = pVtxIn[pVtxIn.size() - 1]; + btVector3 endVertex = pVtxIn[0]; + + ds = planeNormalWS.dot(firstVertex) + planeEqWS; + + for (ve = 0; ve < numVerts; ve++) + { + endVertex = pVtxIn[ve]; + + de = planeNormalWS.dot(endVertex) + planeEqWS; + + if (ds < 0) + { + if (de < 0) + { + // Start < 0, end < 0, so output endVertex + ppVtxOut.push_back(endVertex); + } + else + { + // Start < 0, end >= 0, so output intersection + ppVtxOut.push_back(firstVertex.lerp(endVertex, btScalar(ds * 1.f / (ds - de)))); + } + } + else + { + if (de < 0) + { + // Start >= 0, end < 0 so output intersection and end + ppVtxOut.push_back(firstVertex.lerp(endVertex, btScalar(ds * 1.f / (ds - de)))); + ppVtxOut.push_back(endVertex); + } + } + firstVertex = endVertex; + ds = de; + } +} + +static bool TestSepAxis(const btConvexPolyhedron& hullA, const btConvexPolyhedron& hullB, const btTransform& transA, const btTransform& transB, const btVector3& sep_axis, btScalar& depth, btVector3& witnessPointA, btVector3& witnessPointB) +{ + btScalar Min0, Max0; + btScalar Min1, Max1; + btVector3 witnesPtMinA, witnesPtMaxA; + btVector3 witnesPtMinB, witnesPtMaxB; + + hullA.project(transA, sep_axis, Min0, Max0, witnesPtMinA, witnesPtMaxA); + hullB.project(transB, sep_axis, Min1, Max1, witnesPtMinB, witnesPtMaxB); + + if (Max0 < Min1 || Max1 < Min0) + return false; + + btScalar d0 = Max0 - Min1; + btAssert(d0 >= 0.0f); + btScalar d1 = Max1 - Min0; + btAssert(d1 >= 0.0f); + if (d0 < d1) + { + depth = d0; + witnessPointA = witnesPtMaxA; + witnessPointB = witnesPtMinB; + } + else + { + depth = d1; + witnessPointA = witnesPtMinA; + witnessPointB = witnesPtMaxB; + } + + return true; +} + +static int gActualSATPairTests = 0; + +inline bool IsAlmostZero(const btVector3& v) +{ + if (btFabs(v.x()) > 1e-6 || btFabs(v.y()) > 1e-6 || btFabs(v.z()) > 1e-6) return false; + return true; +} + +#ifdef TEST_INTERNAL_OBJECTS + +inline void BoxSupport(const btScalar extents[3], const btScalar sv[3], btScalar p[3]) +{ + // This version is ~11.000 cycles (4%) faster overall in one of the tests. + // IR(p[0]) = IR(extents[0])|(IR(sv[0])&SIGN_BITMASK); + // IR(p[1]) = IR(extents[1])|(IR(sv[1])&SIGN_BITMASK); + // IR(p[2]) = IR(extents[2])|(IR(sv[2])&SIGN_BITMASK); + p[0] = sv[0] < 0.0f ? -extents[0] : extents[0]; + p[1] = sv[1] < 0.0f ? -extents[1] : extents[1]; + p[2] = sv[2] < 0.0f ? -extents[2] : extents[2]; +} + +void InverseTransformPoint3x3(btVector3& out, const btVector3& in, const btTransform& tr) +{ + const btMatrix3x3& rot = tr.getBasis(); + const btVector3& r0 = rot[0]; + const btVector3& r1 = rot[1]; + const btVector3& r2 = rot[2]; + + const btScalar x = r0.x() * in.x() + r1.x() * in.y() + r2.x() * in.z(); + const btScalar y = r0.y() * in.x() + r1.y() * in.y() + r2.y() * in.z(); + const btScalar z = r0.z() * in.x() + r1.z() * in.y() + r2.z() * in.z(); + + out.setValue(x, y, z); +} + +bool TestInternalObjects(const btTransform& trans0, const btTransform& trans1, const btVector3& delta_c, const btVector3& axis, const btConvexPolyhedron& convex0, const btConvexPolyhedron& convex1, btScalar dmin) +{ + const btScalar dp = delta_c.dot(axis); + + btVector3 localAxis0; + InverseTransformPoint3x3(localAxis0, axis, trans0); + btVector3 localAxis1; + InverseTransformPoint3x3(localAxis1, axis, trans1); + + btScalar p0[3]; + BoxSupport(convex0.m_extents, localAxis0, p0); + btScalar p1[3]; + BoxSupport(convex1.m_extents, localAxis1, p1); + + const btScalar Radius0 = p0[0] * localAxis0.x() + p0[1] * localAxis0.y() + p0[2] * localAxis0.z(); + const btScalar Radius1 = p1[0] * localAxis1.x() + p1[1] * localAxis1.y() + p1[2] * localAxis1.z(); + + const btScalar MinRadius = Radius0 > convex0.m_radius ? Radius0 : convex0.m_radius; + const btScalar MaxRadius = Radius1 > convex1.m_radius ? Radius1 : convex1.m_radius; + + const btScalar MinMaxRadius = MaxRadius + MinRadius; + const btScalar d0 = MinMaxRadius + dp; + const btScalar d1 = MinMaxRadius - dp; + + const btScalar depth = d0 < d1 ? d0 : d1; + if (depth > dmin) + return false; + return true; +} +#endif //TEST_INTERNAL_OBJECTS + +SIMD_FORCE_INLINE void btSegmentsClosestPoints( + btVector3& ptsVector, + btVector3& offsetA, + btVector3& offsetB, + btScalar& tA, btScalar& tB, + const btVector3& translation, + const btVector3& dirA, btScalar hlenA, + const btVector3& dirB, btScalar hlenB) +{ + // compute the parameters of the closest points on each line segment + + btScalar dirA_dot_dirB = btDot(dirA, dirB); + btScalar dirA_dot_trans = btDot(dirA, translation); + btScalar dirB_dot_trans = btDot(dirB, translation); + + btScalar denom = 1.0f - dirA_dot_dirB * dirA_dot_dirB; + + if (denom == 0.0f) + { + tA = 0.0f; + } + else + { + tA = (dirA_dot_trans - dirB_dot_trans * dirA_dot_dirB) / denom; + if (tA < -hlenA) + tA = -hlenA; + else if (tA > hlenA) + tA = hlenA; + } + + tB = tA * dirA_dot_dirB - dirB_dot_trans; + + if (tB < -hlenB) + { + tB = -hlenB; + tA = tB * dirA_dot_dirB + dirA_dot_trans; + + if (tA < -hlenA) + tA = -hlenA; + else if (tA > hlenA) + tA = hlenA; + } + else if (tB > hlenB) + { + tB = hlenB; + tA = tB * dirA_dot_dirB + dirA_dot_trans; + + if (tA < -hlenA) + tA = -hlenA; + else if (tA > hlenA) + tA = hlenA; + } + + // compute the closest points relative to segment centers. + + offsetA = dirA * tA; + offsetB = dirB * tB; + + ptsVector = translation - offsetA + offsetB; +} + +bool btPolyhedralContactClipping::findSeparatingAxis(const btConvexPolyhedron& hullA, const btConvexPolyhedron& hullB, const btTransform& transA, const btTransform& transB, btVector3& sep, btDiscreteCollisionDetectorInterface::Result& resultOut) +{ + gActualSATPairTests++; + + //#ifdef TEST_INTERNAL_OBJECTS + const btVector3 c0 = transA * hullA.m_localCenter; + const btVector3 c1 = transB * hullB.m_localCenter; + const btVector3 DeltaC2 = c0 - c1; + //#endif + + btScalar dmin = FLT_MAX; + int curPlaneTests = 0; + + int numFacesA = hullA.m_faces.size(); + // Test normals from hullA + for (int i = 0; i < numFacesA; i++) + { + const btVector3 Normal(hullA.m_faces[i].m_plane[0], hullA.m_faces[i].m_plane[1], hullA.m_faces[i].m_plane[2]); + btVector3 faceANormalWS = transA.getBasis() * Normal; + if (DeltaC2.dot(faceANormalWS) < 0) + faceANormalWS *= -1.f; + + curPlaneTests++; +#ifdef TEST_INTERNAL_OBJECTS + gExpectedNbTests++; + if (gUseInternalObject && !TestInternalObjects(transA, transB, DeltaC2, faceANormalWS, hullA, hullB, dmin)) + continue; + gActualNbTests++; +#endif + + btScalar d; + btVector3 wA, wB; + if (!TestSepAxis(hullA, hullB, transA, transB, faceANormalWS, d, wA, wB)) + return false; + + if (d < dmin) + { + dmin = d; + sep = faceANormalWS; + } + } + + int numFacesB = hullB.m_faces.size(); + // Test normals from hullB + for (int i = 0; i < numFacesB; i++) + { + const btVector3 Normal(hullB.m_faces[i].m_plane[0], hullB.m_faces[i].m_plane[1], hullB.m_faces[i].m_plane[2]); + btVector3 WorldNormal = transB.getBasis() * Normal; + if (DeltaC2.dot(WorldNormal) < 0) + WorldNormal *= -1.f; + + curPlaneTests++; +#ifdef TEST_INTERNAL_OBJECTS + gExpectedNbTests++; + if (gUseInternalObject && !TestInternalObjects(transA, transB, DeltaC2, WorldNormal, hullA, hullB, dmin)) + continue; + gActualNbTests++; +#endif + + btScalar d; + btVector3 wA, wB; + if (!TestSepAxis(hullA, hullB, transA, transB, WorldNormal, d, wA, wB)) + return false; + + if (d < dmin) + { + dmin = d; + sep = WorldNormal; + } + } + + btVector3 edgeAstart, edgeAend, edgeBstart, edgeBend; + int edgeA = -1; + int edgeB = -1; + btVector3 worldEdgeA; + btVector3 worldEdgeB; + btVector3 witnessPointA(0, 0, 0), witnessPointB(0, 0, 0); + + int curEdgeEdge = 0; + // Test edges + for (int e0 = 0; e0 < hullA.m_uniqueEdges.size(); e0++) + { + const btVector3 edge0 = hullA.m_uniqueEdges[e0]; + const btVector3 WorldEdge0 = transA.getBasis() * edge0; + for (int e1 = 0; e1 < hullB.m_uniqueEdges.size(); e1++) + { + const btVector3 edge1 = hullB.m_uniqueEdges[e1]; + const btVector3 WorldEdge1 = transB.getBasis() * edge1; + + btVector3 Cross = WorldEdge0.cross(WorldEdge1); + curEdgeEdge++; + if (!IsAlmostZero(Cross)) + { + Cross = Cross.normalize(); + if (DeltaC2.dot(Cross) < 0) + Cross *= -1.f; + +#ifdef TEST_INTERNAL_OBJECTS + gExpectedNbTests++; + if (gUseInternalObject && !TestInternalObjects(transA, transB, DeltaC2, Cross, hullA, hullB, dmin)) + continue; + gActualNbTests++; +#endif + + btScalar dist; + btVector3 wA, wB; + if (!TestSepAxis(hullA, hullB, transA, transB, Cross, dist, wA, wB)) + return false; + + if (dist < dmin) + { + dmin = dist; + sep = Cross; + edgeA = e0; + edgeB = e1; + worldEdgeA = WorldEdge0; + worldEdgeB = WorldEdge1; + witnessPointA = wA; + witnessPointB = wB; + } + } + } + } + + if (edgeA >= 0 && edgeB >= 0) + { + // printf("edge-edge\n"); + //add an edge-edge contact + + btVector3 ptsVector; + btVector3 offsetA; + btVector3 offsetB; + btScalar tA; + btScalar tB; + + btVector3 translation = witnessPointB - witnessPointA; + + btVector3 dirA = worldEdgeA; + btVector3 dirB = worldEdgeB; + + btScalar hlenB = 1e30f; + btScalar hlenA = 1e30f; + + btSegmentsClosestPoints(ptsVector, offsetA, offsetB, tA, tB, + translation, + dirA, hlenA, + dirB, hlenB); + + btScalar nlSqrt = ptsVector.length2(); + if (nlSqrt > SIMD_EPSILON) + { + btScalar nl = btSqrt(nlSqrt); + ptsVector *= 1.f / nl; + if (ptsVector.dot(DeltaC2) < 0.f) + { + ptsVector *= -1.f; + } + btVector3 ptOnB = witnessPointB + offsetB; + btScalar distance = nl; + resultOut.addContactPoint(ptsVector, ptOnB, -distance); + } + } + + if ((DeltaC2.dot(sep)) < 0.0f) + sep = -sep; + + return true; +} + +void btPolyhedralContactClipping::clipFaceAgainstHull(const btVector3& separatingNormal, const btConvexPolyhedron& hullA, const btTransform& transA, btVertexArray& worldVertsB1, btVertexArray& worldVertsB2, const btScalar minDist, btScalar maxDist, btDiscreteCollisionDetectorInterface::Result& resultOut) +{ + worldVertsB2.resize(0); + btVertexArray* pVtxIn = &worldVertsB1; + btVertexArray* pVtxOut = &worldVertsB2; + pVtxOut->reserve(pVtxIn->size()); + + int closestFaceA = -1; + { + btScalar dmin = FLT_MAX; + for (int face = 0; face < hullA.m_faces.size(); face++) + { + const btVector3 Normal(hullA.m_faces[face].m_plane[0], hullA.m_faces[face].m_plane[1], hullA.m_faces[face].m_plane[2]); + const btVector3 faceANormalWS = transA.getBasis() * Normal; + + btScalar d = faceANormalWS.dot(separatingNormal); + if (d < dmin) + { + dmin = d; + closestFaceA = face; + } + } + } + if (closestFaceA < 0) + return; + + const btFace& polyA = hullA.m_faces[closestFaceA]; + + // clip polygon to back of planes of all faces of hull A that are adjacent to witness face + int numVerticesA = polyA.m_indices.size(); + for (int e0 = 0; e0 < numVerticesA; e0++) + { + const btVector3& a = hullA.m_vertices[polyA.m_indices[e0]]; + const btVector3& b = hullA.m_vertices[polyA.m_indices[(e0 + 1) % numVerticesA]]; + const btVector3 edge0 = a - b; + const btVector3 WorldEdge0 = transA.getBasis() * edge0; + btVector3 worldPlaneAnormal1 = transA.getBasis() * btVector3(polyA.m_plane[0], polyA.m_plane[1], polyA.m_plane[2]); + + btVector3 planeNormalWS1 = -WorldEdge0.cross(worldPlaneAnormal1); //.cross(WorldEdge0); + btVector3 worldA1 = transA * a; + btScalar planeEqWS1 = -worldA1.dot(planeNormalWS1); + +//int otherFace=0; +#ifdef BLA1 + int otherFace = polyA.m_connectedFaces[e0]; + btVector3 localPlaneNormal(hullA.m_faces[otherFace].m_plane[0], hullA.m_faces[otherFace].m_plane[1], hullA.m_faces[otherFace].m_plane[2]); + btScalar localPlaneEq = hullA.m_faces[otherFace].m_plane[3]; + + btVector3 planeNormalWS = transA.getBasis() * localPlaneNormal; + btScalar planeEqWS = localPlaneEq - planeNormalWS.dot(transA.getOrigin()); +#else + btVector3 planeNormalWS = planeNormalWS1; + btScalar planeEqWS = planeEqWS1; + +#endif + //clip face + + clipFace(*pVtxIn, *pVtxOut, planeNormalWS, planeEqWS); + btSwap(pVtxIn, pVtxOut); + pVtxOut->resize(0); + } + + //#define ONLY_REPORT_DEEPEST_POINT + + btVector3 point; + + // only keep points that are behind the witness face + { + btVector3 localPlaneNormal(polyA.m_plane[0], polyA.m_plane[1], polyA.m_plane[2]); + btScalar localPlaneEq = polyA.m_plane[3]; + btVector3 planeNormalWS = transA.getBasis() * localPlaneNormal; + btScalar planeEqWS = localPlaneEq - planeNormalWS.dot(transA.getOrigin()); + for (int i = 0; i < pVtxIn->size(); i++) + { + btVector3 vtx = pVtxIn->at(i); + btScalar depth = planeNormalWS.dot(vtx) + planeEqWS; + if (depth <= minDist) + { + // printf("clamped: depth=%f to minDist=%f\n",depth,minDist); + depth = minDist; + } + + if (depth <= maxDist) + { + btVector3 point = pVtxIn->at(i); +#ifdef ONLY_REPORT_DEEPEST_POINT + curMaxDist = depth; +#else +#if 0 + if (depth<-3) + { + printf("error in btPolyhedralContactClipping depth = %f\n", depth); + printf("likely wrong separatingNormal passed in\n"); + } +#endif + resultOut.addContactPoint(separatingNormal, point, depth); +#endif + } + } + } +#ifdef ONLY_REPORT_DEEPEST_POINT + if (curMaxDist < maxDist) + { + resultOut.addContactPoint(separatingNormal, point, curMaxDist); + } +#endif //ONLY_REPORT_DEEPEST_POINT +} + +void btPolyhedralContactClipping::clipHullAgainstHull(const btVector3& separatingNormal1, const btConvexPolyhedron& hullA, const btConvexPolyhedron& hullB, const btTransform& transA, const btTransform& transB, const btScalar minDist, btScalar maxDist, btVertexArray& worldVertsB1, btVertexArray& worldVertsB2, btDiscreteCollisionDetectorInterface::Result& resultOut) +{ + btVector3 separatingNormal = separatingNormal1.normalized(); + // const btVector3 c0 = transA * hullA.m_localCenter; + // const btVector3 c1 = transB * hullB.m_localCenter; + //const btVector3 DeltaC2 = c0 - c1; + + int closestFaceB = -1; + btScalar dmax = -FLT_MAX; + { + for (int face = 0; face < hullB.m_faces.size(); face++) + { + const btVector3 Normal(hullB.m_faces[face].m_plane[0], hullB.m_faces[face].m_plane[1], hullB.m_faces[face].m_plane[2]); + const btVector3 WorldNormal = transB.getBasis() * Normal; + btScalar d = WorldNormal.dot(separatingNormal); + if (d > dmax) + { + dmax = d; + closestFaceB = face; + } + } + } + worldVertsB1.resize(0); + { + const btFace& polyB = hullB.m_faces[closestFaceB]; + const int numVertices = polyB.m_indices.size(); + for (int e0 = 0; e0 < numVertices; e0++) + { + const btVector3& b = hullB.m_vertices[polyB.m_indices[e0]]; + worldVertsB1.push_back(transB * b); + } + } + + if (closestFaceB >= 0) + clipFaceAgainstHull(separatingNormal, hullA, transA, worldVertsB1, worldVertsB2, minDist, maxDist, resultOut); +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp.i new file mode 100644 index 00000000..149fb6af --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp ---------------- + +// %include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h new file mode 100644 index 00000000..328f6424 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h @@ -0,0 +1,42 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///This file was written by Erwin Coumans + +#ifndef BT_POLYHEDRAL_CONTACT_CLIPPING_H +#define BT_POLYHEDRAL_CONTACT_CLIPPING_H + +#include "LinearMath/btAlignedObjectArray.h" +#include "LinearMath/btTransform.h" +#include "btDiscreteCollisionDetectorInterface.h" + +class btConvexPolyhedron; + +typedef btAlignedObjectArray btVertexArray; + +// Clips a face to the back of a plane +struct btPolyhedralContactClipping +{ + static void clipHullAgainstHull(const btVector3& separatingNormal1, const btConvexPolyhedron& hullA, const btConvexPolyhedron& hullB, const btTransform& transA, const btTransform& transB, const btScalar minDist, btScalar maxDist, btVertexArray& worldVertsB1, btVertexArray& worldVertsB2, btDiscreteCollisionDetectorInterface::Result& resultOut); + + static void clipFaceAgainstHull(const btVector3& separatingNormal, const btConvexPolyhedron& hullA, const btTransform& transA, btVertexArray& worldVertsB1, btVertexArray& worldVertsB2, const btScalar minDist, btScalar maxDist, btDiscreteCollisionDetectorInterface::Result& resultOut); + + static bool findSeparatingAxis(const btConvexPolyhedron& hullA, const btConvexPolyhedron& hullB, const btTransform& transA, const btTransform& transB, btVector3& sep, btDiscreteCollisionDetectorInterface::Result& resultOut); + + ///the clipFace method is used internally + static void clipFace(const btVertexArray& pVtxIn, btVertexArray& ppVtxOut, const btVector3& planeNormalWS, btScalar planeEqWS); +}; + +#endif // BT_POLYHEDRAL_CONTACT_CLIPPING_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h.i new file mode 100644 index 00000000..eb8da526 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp new file mode 100644 index 00000000..f2de4e90 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp @@ -0,0 +1,175 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +//#include + +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "BulletCollision/CollisionShapes/btTriangleShape.h" +#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h" +#include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h" +#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h" +#include "btRaycastCallback.h" + +btTriangleRaycastCallback::btTriangleRaycastCallback(const btVector3& from, const btVector3& to, unsigned int flags) + : m_from(from), + m_to(to), + //@BP Mod + m_flags(flags), + m_hitFraction(btScalar(1.)) +{ +} + +void btTriangleRaycastCallback::processTriangle(btVector3* triangle, int partId, int triangleIndex) +{ + const btVector3& vert0 = triangle[0]; + const btVector3& vert1 = triangle[1]; + const btVector3& vert2 = triangle[2]; + + btVector3 v10; + v10 = vert1 - vert0; + btVector3 v20; + v20 = vert2 - vert0; + + btVector3 triangleNormal; + triangleNormal = v10.cross(v20); + + const btScalar dist = vert0.dot(triangleNormal); + btScalar dist_a = triangleNormal.dot(m_from); + dist_a -= dist; + btScalar dist_b = triangleNormal.dot(m_to); + dist_b -= dist; + + if (dist_a * dist_b >= btScalar(0.0)) + { + return; // same sign + } + + if (((m_flags & kF_FilterBackfaces) != 0) && (dist_a <= btScalar(0.0))) + { + // Backface, skip check + return; + } + + const btScalar proj_length = dist_a - dist_b; + const btScalar distance = (dist_a) / (proj_length); + // Now we have the intersection point on the plane, we'll see if it's inside the triangle + // Add an epsilon as a tolerance for the raycast, + // in case the ray hits exacly on the edge of the triangle. + // It must be scaled for the triangle size. + + if (distance < m_hitFraction) + { + btScalar edge_tolerance = triangleNormal.length2(); + edge_tolerance *= btScalar(-0.0001); + btVector3 point; + point.setInterpolate3(m_from, m_to, distance); + { + btVector3 v0p; + v0p = vert0 - point; + btVector3 v1p; + v1p = vert1 - point; + btVector3 cp0; + cp0 = v0p.cross(v1p); + + if ((btScalar)(cp0.dot(triangleNormal)) >= edge_tolerance) + { + btVector3 v2p; + v2p = vert2 - point; + btVector3 cp1; + cp1 = v1p.cross(v2p); + if ((btScalar)(cp1.dot(triangleNormal)) >= edge_tolerance) + { + btVector3 cp2; + cp2 = v2p.cross(v0p); + + if ((btScalar)(cp2.dot(triangleNormal)) >= edge_tolerance) + { + //@BP Mod + // Triangle normal isn't normalized + triangleNormal.normalize(); + + //@BP Mod - Allow for unflipped normal when raycasting against backfaces + if (((m_flags & kF_KeepUnflippedNormal) == 0) && (dist_a <= btScalar(0.0))) + { + m_hitFraction = reportHit(-triangleNormal, distance, partId, triangleIndex); + } + else + { + m_hitFraction = reportHit(triangleNormal, distance, partId, triangleIndex); + } + } + } + } + } + } +} + +btTriangleConvexcastCallback::btTriangleConvexcastCallback(const btConvexShape* convexShape, const btTransform& convexShapeFrom, const btTransform& convexShapeTo, const btTransform& triangleToWorld, const btScalar triangleCollisionMargin) +{ + m_convexShape = convexShape; + m_convexShapeFrom = convexShapeFrom; + m_convexShapeTo = convexShapeTo; + m_triangleToWorld = triangleToWorld; + m_hitFraction = 1.0f; + m_triangleCollisionMargin = triangleCollisionMargin; + m_allowedPenetration = 0.f; +} + +void btTriangleConvexcastCallback::processTriangle(btVector3* triangle, int partId, int triangleIndex) +{ + btTriangleShape triangleShape(triangle[0], triangle[1], triangle[2]); + triangleShape.setMargin(m_triangleCollisionMargin); + + btVoronoiSimplexSolver simplexSolver; + btGjkEpaPenetrationDepthSolver gjkEpaPenetrationSolver; + +//#define USE_SUBSIMPLEX_CONVEX_CAST 1 +//if you reenable USE_SUBSIMPLEX_CONVEX_CAST see commented out code below +#ifdef USE_SUBSIMPLEX_CONVEX_CAST + btSubsimplexConvexCast convexCaster(m_convexShape, &triangleShape, &simplexSolver); +#else + //btGjkConvexCast convexCaster(m_convexShape,&triangleShape,&simplexSolver); + btContinuousConvexCollision convexCaster(m_convexShape, &triangleShape, &simplexSolver, &gjkEpaPenetrationSolver); +#endif //#USE_SUBSIMPLEX_CONVEX_CAST + + btConvexCast::CastResult castResult; + castResult.m_fraction = btScalar(1.); + castResult.m_allowedPenetration = m_allowedPenetration; + if (convexCaster.calcTimeOfImpact(m_convexShapeFrom, m_convexShapeTo, m_triangleToWorld, m_triangleToWorld, castResult)) + { + //add hit + if (castResult.m_normal.length2() > btScalar(0.0001)) + { + if (castResult.m_fraction < m_hitFraction) + { + /* btContinuousConvexCast's normal is already in world space */ + /* +#ifdef USE_SUBSIMPLEX_CONVEX_CAST + //rotate normal into worldspace + castResult.m_normal = m_convexShapeFrom.getBasis() * castResult.m_normal; +#endif //USE_SUBSIMPLEX_CONVEX_CAST +*/ + castResult.m_normal.normalize(); + + reportHit(castResult.m_normal, + castResult.m_hitPoint, + castResult.m_fraction, + partId, + triangleIndex); + } + } + } +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp.i new file mode 100644 index 00000000..7ff26af5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h new file mode 100644 index 00000000..58a48c7a --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h @@ -0,0 +1,72 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_RAYCAST_TRI_CALLBACK_H +#define BT_RAYCAST_TRI_CALLBACK_H + +#include "BulletCollision/CollisionShapes/btTriangleCallback.h" +#include "LinearMath/btTransform.h" +struct btBroadphaseProxy; +class btConvexShape; + +class btTriangleRaycastCallback : public btTriangleCallback +{ +public: + //input + btVector3 m_from; + btVector3 m_to; + + //@BP Mod - allow backface filtering and unflipped normals + enum EFlags + { + kF_None = 0, + kF_FilterBackfaces = 1 << 0, + kF_KeepUnflippedNormal = 1 << 1, // Prevents returned face normal getting flipped when a ray hits a back-facing triangle + ///SubSimplexConvexCastRaytest is the default, even if kF_None is set. + kF_UseSubSimplexConvexCastRaytest = 1 << 2, // Uses an approximate but faster ray versus convex intersection algorithm + kF_UseGjkConvexCastRaytest = 1 << 3, + kF_DisableHeightfieldAccelerator = 1 << 4, //don't use the heightfield raycast accelerator. See https://github.com/bulletphysics/bullet3/pull/2062 + kF_Terminator = 0xFFFFFFFF + }; + unsigned int m_flags; + + btScalar m_hitFraction; + + btTriangleRaycastCallback(const btVector3& from, const btVector3& to, unsigned int flags = 0); + + virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex); + + virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex) = 0; +}; + +class btTriangleConvexcastCallback : public btTriangleCallback +{ +public: + const btConvexShape* m_convexShape; + btTransform m_convexShapeFrom; + btTransform m_convexShapeTo; + btTransform m_triangleToWorld; + btScalar m_hitFraction; + btScalar m_triangleCollisionMargin; + btScalar m_allowedPenetration; + + btTriangleConvexcastCallback(const btConvexShape* convexShape, const btTransform& convexShapeFrom, const btTransform& convexShapeTo, const btTransform& triangleToWorld, const btScalar triangleCollisionMargin); + + virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex); + + virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex) = 0; +}; + +#endif //BT_RAYCAST_TRI_CALLBACK_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h.i new file mode 100644 index 00000000..f7852a51 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btRaycastCallback.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h new file mode 100644 index 00000000..b994aca9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h @@ -0,0 +1,58 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SIMPLEX_SOLVER_INTERFACE_H +#define BT_SIMPLEX_SOLVER_INTERFACE_H + +#include "LinearMath/btVector3.h" + +#define NO_VIRTUAL_INTERFACE 1 +#ifdef NO_VIRTUAL_INTERFACE +#include "btVoronoiSimplexSolver.h" +#define btSimplexSolverInterface btVoronoiSimplexSolver +#else + +/// btSimplexSolverInterface can incrementally calculate distance between origin and up to 4 vertices +/// Used by GJK or Linear Casting. Can be implemented by the Johnson-algorithm or alternative approaches based on +/// voronoi regions or barycentric coordinates +class btSimplexSolverInterface +{ +public: + virtual ~btSimplexSolverInterface(){}; + + virtual void reset() = 0; + + virtual void addVertex(const btVector3& w, const btVector3& p, const btVector3& q) = 0; + + virtual bool closest(btVector3& v) = 0; + + virtual btScalar maxVertex() = 0; + + virtual bool fullSimplex() const = 0; + + virtual int getSimplex(btVector3* pBuf, btVector3* qBuf, btVector3* yBuf) const = 0; + + virtual bool inSimplex(const btVector3& w) = 0; + + virtual void backup_closest(btVector3& v) = 0; + + virtual bool emptySimplex() const = 0; + + virtual void compute_points(btVector3& p1, btVector3& p2) = 0; + + virtual int numVertices() const = 0; +}; +#endif +#endif //BT_SIMPLEX_SOLVER_INTERFACE_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h.i new file mode 100644 index 00000000..3c0bccdb --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp new file mode 100644 index 00000000..8b011a82 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp @@ -0,0 +1,143 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btSubSimplexConvexCast.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" + +#include "BulletCollision/CollisionShapes/btMinkowskiSumShape.h" +#include "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h" +#include "btPointCollector.h" +#include "LinearMath/btTransformUtil.h" + +btSubsimplexConvexCast::btSubsimplexConvexCast(const btConvexShape* convexA, const btConvexShape* convexB, btSimplexSolverInterface* simplexSolver) + : m_simplexSolver(simplexSolver), + m_convexA(convexA), + m_convexB(convexB) +{ +} + + +bool btSubsimplexConvexCast::calcTimeOfImpact( + const btTransform& fromA, + const btTransform& toA, + const btTransform& fromB, + const btTransform& toB, + CastResult& result) +{ + m_simplexSolver->reset(); + + btVector3 linVelA, linVelB; + linVelA = toA.getOrigin() - fromA.getOrigin(); + linVelB = toB.getOrigin() - fromB.getOrigin(); + + btScalar lambda = btScalar(0.); + + btTransform interpolatedTransA = fromA; + btTransform interpolatedTransB = fromB; + + ///take relative motion + btVector3 r = (linVelA - linVelB); + btVector3 v; + + btVector3 supVertexA = fromA(m_convexA->localGetSupportingVertex(-r * fromA.getBasis())); + btVector3 supVertexB = fromB(m_convexB->localGetSupportingVertex(r * fromB.getBasis())); + v = supVertexA - supVertexB; + int maxIter = result.m_subSimplexCastMaxIterations; + + btVector3 n; + n.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); + + btVector3 c; + + btScalar dist2 = v.length2(); + + + + btVector3 w, p; + btScalar VdotR; + + while ((dist2 > result.m_subSimplexCastEpsilon) && maxIter--) + { + supVertexA = interpolatedTransA(m_convexA->localGetSupportingVertex(-v * interpolatedTransA.getBasis())); + supVertexB = interpolatedTransB(m_convexB->localGetSupportingVertex(v * interpolatedTransB.getBasis())); + w = supVertexA - supVertexB; + + btScalar VdotW = v.dot(w); + + if (lambda > btScalar(1.0)) + { + return false; + } + + if (VdotW > btScalar(0.)) + { + VdotR = v.dot(r); + + if (VdotR >= -(SIMD_EPSILON * SIMD_EPSILON)) + return false; + else + { + lambda = lambda - VdotW / VdotR; + //interpolate to next lambda + // x = s + lambda * r; + interpolatedTransA.getOrigin().setInterpolate3(fromA.getOrigin(), toA.getOrigin(), lambda); + interpolatedTransB.getOrigin().setInterpolate3(fromB.getOrigin(), toB.getOrigin(), lambda); + //m_simplexSolver->reset(); + //check next line + w = supVertexA - supVertexB; + + n = v; + } + } + ///Just like regular GJK only add the vertex if it isn't already (close) to current vertex, it would lead to divisions by zero and NaN etc. + if (!m_simplexSolver->inSimplex(w)) + m_simplexSolver->addVertex(w, supVertexA, supVertexB); + + if (m_simplexSolver->closest(v)) + { + dist2 = v.length2(); + + //todo: check this normal for validity + //n=v; + //printf("V=%f , %f, %f\n",v[0],v[1],v[2]); + //printf("DIST2=%f\n",dist2); + //printf("numverts = %i\n",m_simplexSolver->numVertices()); + } + else + { + dist2 = btScalar(0.); + } + } + + //int numiter = MAX_ITERATIONS - maxIter; + // printf("number of iterations: %d", numiter); + + //don't report a time of impact when moving 'away' from the hitnormal + + result.m_fraction = lambda; + if (n.length2() >= (SIMD_EPSILON * SIMD_EPSILON)) + result.m_normal = n.normalized(); + else + result.m_normal = btVector3(btScalar(0.0), btScalar(0.0), btScalar(0.0)); + + //don't report time of impact for motion away from the contact normal (or causes minor penetration) + if (result.m_normal.dot(r) >= -result.m_allowedPenetration) + return false; + + btVector3 hitA, hitB; + m_simplexSolver->compute_points(hitA, hitB); + result.m_hitPoint = hitB; + return true; +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp.i new file mode 100644 index 00000000..34071ee0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp ---------------- + +// %include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h new file mode 100644 index 00000000..e2b6bbcf --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h @@ -0,0 +1,47 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SUBSIMPLEX_CONVEX_CAST_H +#define BT_SUBSIMPLEX_CONVEX_CAST_H + +#include "btConvexCast.h" +#include "btSimplexSolverInterface.h" +class btConvexShape; + +/// btSubsimplexConvexCast implements Gino van den Bergens' paper +///"Ray Casting against bteral Convex Objects with Application to Continuous Collision Detection" +/// GJK based Ray Cast, optimized version +/// Objects should not start in overlap, otherwise results are not defined. +class btSubsimplexConvexCast : public btConvexCast +{ + btSimplexSolverInterface* m_simplexSolver; + const btConvexShape* m_convexA; + const btConvexShape* m_convexB; + +public: + btSubsimplexConvexCast(const btConvexShape* shapeA, const btConvexShape* shapeB, btSimplexSolverInterface* simplexSolver); + + //virtual ~btSubsimplexConvexCast(); + ///SimsimplexConvexCast calculateTimeOfImpact calculates the time of impact+normal for the linear cast (sweep) between two moving objects. + ///Precondition is that objects should not penetration/overlap at the start from the interval. Overlap can be tested using btGjkPairDetector. + virtual bool calcTimeOfImpact( + const btTransform& fromA, + const btTransform& toA, + const btTransform& fromB, + const btTransform& toB, + CastResult& result); +}; + +#endif //BT_SUBSIMPLEX_CONVEX_CAST_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h.i new file mode 100644 index 00000000..e1075c08 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp new file mode 100644 index 00000000..6b65a254 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp @@ -0,0 +1,577 @@ + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. + + Elsevier CDROM license agreements grants nonexclusive license to use the software + for any purpose, commercial or non-commercial as long as the following credit is included + identifying the original source of the software: + + Parts of the source are "from the book Real-Time Collision Detection by + Christer Ericson, published by Morgan Kaufmann Publishers, + (c) 2005 Elsevier Inc." + +*/ + +#include "btVoronoiSimplexSolver.h" + +#define VERTA 0 +#define VERTB 1 +#define VERTC 2 +#define VERTD 3 + +#define CATCH_DEGENERATE_TETRAHEDRON 1 +void btVoronoiSimplexSolver::removeVertex(int index) +{ + btAssert(m_numVertices > 0); + m_numVertices--; + m_simplexVectorW[index] = m_simplexVectorW[m_numVertices]; + m_simplexPointsP[index] = m_simplexPointsP[m_numVertices]; + m_simplexPointsQ[index] = m_simplexPointsQ[m_numVertices]; +} + +void btVoronoiSimplexSolver::reduceVertices(const btUsageBitfield& usedVerts) +{ + if ((numVertices() >= 4) && (!usedVerts.usedVertexD)) + removeVertex(3); + + if ((numVertices() >= 3) && (!usedVerts.usedVertexC)) + removeVertex(2); + + if ((numVertices() >= 2) && (!usedVerts.usedVertexB)) + removeVertex(1); + + if ((numVertices() >= 1) && (!usedVerts.usedVertexA)) + removeVertex(0); +} + +//clear the simplex, remove all the vertices +void btVoronoiSimplexSolver::reset() +{ + m_cachedValidClosest = false; + m_numVertices = 0; + m_needsUpdate = true; + m_lastW = btVector3(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + m_cachedBC.reset(); +} + +//add a vertex +void btVoronoiSimplexSolver::addVertex(const btVector3& w, const btVector3& p, const btVector3& q) +{ + m_lastW = w; + m_needsUpdate = true; + + m_simplexVectorW[m_numVertices] = w; + m_simplexPointsP[m_numVertices] = p; + m_simplexPointsQ[m_numVertices] = q; + + m_numVertices++; +} + +bool btVoronoiSimplexSolver::updateClosestVectorAndPoints() +{ + if (m_needsUpdate) + { + m_cachedBC.reset(); + + m_needsUpdate = false; + + switch (numVertices()) + { + case 0: + m_cachedValidClosest = false; + break; + case 1: + { + m_cachedP1 = m_simplexPointsP[0]; + m_cachedP2 = m_simplexPointsQ[0]; + m_cachedV = m_cachedP1 - m_cachedP2; //== m_simplexVectorW[0] + m_cachedBC.reset(); + m_cachedBC.setBarycentricCoordinates(btScalar(1.), btScalar(0.), btScalar(0.), btScalar(0.)); + m_cachedValidClosest = m_cachedBC.isValid(); + break; + }; + case 2: + { + //closest point origin from line segment + const btVector3& from = m_simplexVectorW[0]; + const btVector3& to = m_simplexVectorW[1]; + btVector3 nearest; + + btVector3 p(btScalar(0.), btScalar(0.), btScalar(0.)); + btVector3 diff = p - from; + btVector3 v = to - from; + btScalar t = v.dot(diff); + + if (t > 0) + { + btScalar dotVV = v.dot(v); + if (t < dotVV) + { + t /= dotVV; + diff -= t * v; + m_cachedBC.m_usedVertices.usedVertexA = true; + m_cachedBC.m_usedVertices.usedVertexB = true; + } + else + { + t = 1; + diff -= v; + //reduce to 1 point + m_cachedBC.m_usedVertices.usedVertexB = true; + } + } + else + { + t = 0; + //reduce to 1 point + m_cachedBC.m_usedVertices.usedVertexA = true; + } + m_cachedBC.setBarycentricCoordinates(1 - t, t); + nearest = from + t * v; + + m_cachedP1 = m_simplexPointsP[0] + t * (m_simplexPointsP[1] - m_simplexPointsP[0]); + m_cachedP2 = m_simplexPointsQ[0] + t * (m_simplexPointsQ[1] - m_simplexPointsQ[0]); + m_cachedV = m_cachedP1 - m_cachedP2; + + reduceVertices(m_cachedBC.m_usedVertices); + + m_cachedValidClosest = m_cachedBC.isValid(); + break; + } + case 3: + { + //closest point origin from triangle + btVector3 p(btScalar(0.), btScalar(0.), btScalar(0.)); + + const btVector3& a = m_simplexVectorW[0]; + const btVector3& b = m_simplexVectorW[1]; + const btVector3& c = m_simplexVectorW[2]; + + closestPtPointTriangle(p, a, b, c, m_cachedBC); + m_cachedP1 = m_simplexPointsP[0] * m_cachedBC.m_barycentricCoords[0] + + m_simplexPointsP[1] * m_cachedBC.m_barycentricCoords[1] + + m_simplexPointsP[2] * m_cachedBC.m_barycentricCoords[2]; + + m_cachedP2 = m_simplexPointsQ[0] * m_cachedBC.m_barycentricCoords[0] + + m_simplexPointsQ[1] * m_cachedBC.m_barycentricCoords[1] + + m_simplexPointsQ[2] * m_cachedBC.m_barycentricCoords[2]; + + m_cachedV = m_cachedP1 - m_cachedP2; + + reduceVertices(m_cachedBC.m_usedVertices); + m_cachedValidClosest = m_cachedBC.isValid(); + + break; + } + case 4: + { + btVector3 p(btScalar(0.), btScalar(0.), btScalar(0.)); + + const btVector3& a = m_simplexVectorW[0]; + const btVector3& b = m_simplexVectorW[1]; + const btVector3& c = m_simplexVectorW[2]; + const btVector3& d = m_simplexVectorW[3]; + + bool hasSeparation = closestPtPointTetrahedron(p, a, b, c, d, m_cachedBC); + + if (hasSeparation) + { + m_cachedP1 = m_simplexPointsP[0] * m_cachedBC.m_barycentricCoords[0] + + m_simplexPointsP[1] * m_cachedBC.m_barycentricCoords[1] + + m_simplexPointsP[2] * m_cachedBC.m_barycentricCoords[2] + + m_simplexPointsP[3] * m_cachedBC.m_barycentricCoords[3]; + + m_cachedP2 = m_simplexPointsQ[0] * m_cachedBC.m_barycentricCoords[0] + + m_simplexPointsQ[1] * m_cachedBC.m_barycentricCoords[1] + + m_simplexPointsQ[2] * m_cachedBC.m_barycentricCoords[2] + + m_simplexPointsQ[3] * m_cachedBC.m_barycentricCoords[3]; + + m_cachedV = m_cachedP1 - m_cachedP2; + reduceVertices(m_cachedBC.m_usedVertices); + } + else + { + // printf("sub distance got penetration\n"); + + if (m_cachedBC.m_degenerate) + { + m_cachedValidClosest = false; + } + else + { + m_cachedValidClosest = true; + //degenerate case == false, penetration = true + zero + m_cachedV.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); + } + break; + } + + m_cachedValidClosest = m_cachedBC.isValid(); + + //closest point origin from tetrahedron + break; + } + default: + { + m_cachedValidClosest = false; + } + }; + } + + return m_cachedValidClosest; +} + +//return/calculate the closest vertex +bool btVoronoiSimplexSolver::closest(btVector3& v) +{ + bool succes = updateClosestVectorAndPoints(); + v = m_cachedV; + return succes; +} + +btScalar btVoronoiSimplexSolver::maxVertex() +{ + int i, numverts = numVertices(); + btScalar maxV = btScalar(0.); + for (i = 0; i < numverts; i++) + { + btScalar curLen2 = m_simplexVectorW[i].length2(); + if (maxV < curLen2) + maxV = curLen2; + } + return maxV; +} + +//return the current simplex +int btVoronoiSimplexSolver::getSimplex(btVector3* pBuf, btVector3* qBuf, btVector3* yBuf) const +{ + int i; + for (i = 0; i < numVertices(); i++) + { + yBuf[i] = m_simplexVectorW[i]; + pBuf[i] = m_simplexPointsP[i]; + qBuf[i] = m_simplexPointsQ[i]; + } + return numVertices(); +} + +bool btVoronoiSimplexSolver::inSimplex(const btVector3& w) +{ + bool found = false; + int i, numverts = numVertices(); + //btScalar maxV = btScalar(0.); + + //w is in the current (reduced) simplex + for (i = 0; i < numverts; i++) + { +#ifdef BT_USE_EQUAL_VERTEX_THRESHOLD + if (m_simplexVectorW[i].distance2(w) <= m_equalVertexThreshold) +#else + if (m_simplexVectorW[i] == w) +#endif + { + found = true; + break; + } + } + + //check in case lastW is already removed + if (w == m_lastW) + return true; + + return found; +} + +void btVoronoiSimplexSolver::backup_closest(btVector3& v) +{ + v = m_cachedV; +} + +bool btVoronoiSimplexSolver::emptySimplex() const +{ + return (numVertices() == 0); +} + +void btVoronoiSimplexSolver::compute_points(btVector3& p1, btVector3& p2) +{ + updateClosestVectorAndPoints(); + p1 = m_cachedP1; + p2 = m_cachedP2; +} + +bool btVoronoiSimplexSolver::closestPtPointTriangle(const btVector3& p, const btVector3& a, const btVector3& b, const btVector3& c, btSubSimplexClosestResult& result) +{ + result.m_usedVertices.reset(); + + // Check if P in vertex region outside A + btVector3 ab = b - a; + btVector3 ac = c - a; + btVector3 ap = p - a; + btScalar d1 = ab.dot(ap); + btScalar d2 = ac.dot(ap); + if (d1 <= btScalar(0.0) && d2 <= btScalar(0.0)) + { + result.m_closestPointOnSimplex = a; + result.m_usedVertices.usedVertexA = true; + result.setBarycentricCoordinates(1, 0, 0); + return true; // a; // barycentric coordinates (1,0,0) + } + + // Check if P in vertex region outside B + btVector3 bp = p - b; + btScalar d3 = ab.dot(bp); + btScalar d4 = ac.dot(bp); + if (d3 >= btScalar(0.0) && d4 <= d3) + { + result.m_closestPointOnSimplex = b; + result.m_usedVertices.usedVertexB = true; + result.setBarycentricCoordinates(0, 1, 0); + + return true; // b; // barycentric coordinates (0,1,0) + } + // Check if P in edge region of AB, if so return projection of P onto AB + btScalar vc = d1 * d4 - d3 * d2; + if (vc <= btScalar(0.0) && d1 >= btScalar(0.0) && d3 <= btScalar(0.0)) + { + btScalar v = d1 / (d1 - d3); + result.m_closestPointOnSimplex = a + v * ab; + result.m_usedVertices.usedVertexA = true; + result.m_usedVertices.usedVertexB = true; + result.setBarycentricCoordinates(1 - v, v, 0); + return true; + //return a + v * ab; // barycentric coordinates (1-v,v,0) + } + + // Check if P in vertex region outside C + btVector3 cp = p - c; + btScalar d5 = ab.dot(cp); + btScalar d6 = ac.dot(cp); + if (d6 >= btScalar(0.0) && d5 <= d6) + { + result.m_closestPointOnSimplex = c; + result.m_usedVertices.usedVertexC = true; + result.setBarycentricCoordinates(0, 0, 1); + return true; //c; // barycentric coordinates (0,0,1) + } + + // Check if P in edge region of AC, if so return projection of P onto AC + btScalar vb = d5 * d2 - d1 * d6; + if (vb <= btScalar(0.0) && d2 >= btScalar(0.0) && d6 <= btScalar(0.0)) + { + btScalar w = d2 / (d2 - d6); + result.m_closestPointOnSimplex = a + w * ac; + result.m_usedVertices.usedVertexA = true; + result.m_usedVertices.usedVertexC = true; + result.setBarycentricCoordinates(1 - w, 0, w); + return true; + //return a + w * ac; // barycentric coordinates (1-w,0,w) + } + + // Check if P in edge region of BC, if so return projection of P onto BC + btScalar va = d3 * d6 - d5 * d4; + if (va <= btScalar(0.0) && (d4 - d3) >= btScalar(0.0) && (d5 - d6) >= btScalar(0.0)) + { + btScalar w = (d4 - d3) / ((d4 - d3) + (d5 - d6)); + + result.m_closestPointOnSimplex = b + w * (c - b); + result.m_usedVertices.usedVertexB = true; + result.m_usedVertices.usedVertexC = true; + result.setBarycentricCoordinates(0, 1 - w, w); + return true; + // return b + w * (c - b); // barycentric coordinates (0,1-w,w) + } + + // P inside face region. Compute Q through its barycentric coordinates (u,v,w) + btScalar denom = btScalar(1.0) / (va + vb + vc); + btScalar v = vb * denom; + btScalar w = vc * denom; + + result.m_closestPointOnSimplex = a + ab * v + ac * w; + result.m_usedVertices.usedVertexA = true; + result.m_usedVertices.usedVertexB = true; + result.m_usedVertices.usedVertexC = true; + result.setBarycentricCoordinates(1 - v - w, v, w); + + return true; + // return a + ab * v + ac * w; // = u*a + v*b + w*c, u = va * denom = btScalar(1.0) - v - w +} + +/// Test if point p and d lie on opposite sides of plane through abc +int btVoronoiSimplexSolver::pointOutsideOfPlane(const btVector3& p, const btVector3& a, const btVector3& b, const btVector3& c, const btVector3& d) +{ + btVector3 normal = (b - a).cross(c - a); + + btScalar signp = (p - a).dot(normal); // [AP AB AC] + btScalar signd = (d - a).dot(normal); // [AD AB AC] + +#ifdef CATCH_DEGENERATE_TETRAHEDRON +#ifdef BT_USE_DOUBLE_PRECISION + if (signd * signd < (btScalar(1e-8) * btScalar(1e-8))) + { + return -1; + } +#else + if (signd * signd < (btScalar(1e-4) * btScalar(1e-4))) + { + // printf("affine dependent/degenerate\n");// + return -1; + } +#endif + +#endif + // Points on opposite sides if expression signs are opposite + return signp * signd < btScalar(0.); +} + +bool btVoronoiSimplexSolver::closestPtPointTetrahedron(const btVector3& p, const btVector3& a, const btVector3& b, const btVector3& c, const btVector3& d, btSubSimplexClosestResult& finalResult) +{ + btSubSimplexClosestResult tempResult; + + // Start out assuming point inside all halfspaces, so closest to itself + finalResult.m_closestPointOnSimplex = p; + finalResult.m_usedVertices.reset(); + finalResult.m_usedVertices.usedVertexA = true; + finalResult.m_usedVertices.usedVertexB = true; + finalResult.m_usedVertices.usedVertexC = true; + finalResult.m_usedVertices.usedVertexD = true; + + int pointOutsideABC = pointOutsideOfPlane(p, a, b, c, d); + int pointOutsideACD = pointOutsideOfPlane(p, a, c, d, b); + int pointOutsideADB = pointOutsideOfPlane(p, a, d, b, c); + int pointOutsideBDC = pointOutsideOfPlane(p, b, d, c, a); + + if (pointOutsideABC < 0 || pointOutsideACD < 0 || pointOutsideADB < 0 || pointOutsideBDC < 0) + { + finalResult.m_degenerate = true; + return false; + } + + if (!pointOutsideABC && !pointOutsideACD && !pointOutsideADB && !pointOutsideBDC) + { + return false; + } + + btScalar bestSqDist = FLT_MAX; + // If point outside face abc then compute closest point on abc + if (pointOutsideABC) + { + closestPtPointTriangle(p, a, b, c, tempResult); + btVector3 q = tempResult.m_closestPointOnSimplex; + + btScalar sqDist = (q - p).dot(q - p); + // Update best closest point if (squared) distance is less than current best + if (sqDist < bestSqDist) + { + bestSqDist = sqDist; + finalResult.m_closestPointOnSimplex = q; + //convert result bitmask! + finalResult.m_usedVertices.reset(); + finalResult.m_usedVertices.usedVertexA = tempResult.m_usedVertices.usedVertexA; + finalResult.m_usedVertices.usedVertexB = tempResult.m_usedVertices.usedVertexB; + finalResult.m_usedVertices.usedVertexC = tempResult.m_usedVertices.usedVertexC; + finalResult.setBarycentricCoordinates( + tempResult.m_barycentricCoords[VERTA], + tempResult.m_barycentricCoords[VERTB], + tempResult.m_barycentricCoords[VERTC], + 0); + } + } + + // Repeat test for face acd + if (pointOutsideACD) + { + closestPtPointTriangle(p, a, c, d, tempResult); + btVector3 q = tempResult.m_closestPointOnSimplex; + //convert result bitmask! + + btScalar sqDist = (q - p).dot(q - p); + if (sqDist < bestSqDist) + { + bestSqDist = sqDist; + finalResult.m_closestPointOnSimplex = q; + finalResult.m_usedVertices.reset(); + finalResult.m_usedVertices.usedVertexA = tempResult.m_usedVertices.usedVertexA; + + finalResult.m_usedVertices.usedVertexC = tempResult.m_usedVertices.usedVertexB; + finalResult.m_usedVertices.usedVertexD = tempResult.m_usedVertices.usedVertexC; + finalResult.setBarycentricCoordinates( + tempResult.m_barycentricCoords[VERTA], + 0, + tempResult.m_barycentricCoords[VERTB], + tempResult.m_barycentricCoords[VERTC]); + } + } + // Repeat test for face adb + + if (pointOutsideADB) + { + closestPtPointTriangle(p, a, d, b, tempResult); + btVector3 q = tempResult.m_closestPointOnSimplex; + //convert result bitmask! + + btScalar sqDist = (q - p).dot(q - p); + if (sqDist < bestSqDist) + { + bestSqDist = sqDist; + finalResult.m_closestPointOnSimplex = q; + finalResult.m_usedVertices.reset(); + finalResult.m_usedVertices.usedVertexA = tempResult.m_usedVertices.usedVertexA; + finalResult.m_usedVertices.usedVertexB = tempResult.m_usedVertices.usedVertexC; + + finalResult.m_usedVertices.usedVertexD = tempResult.m_usedVertices.usedVertexB; + finalResult.setBarycentricCoordinates( + tempResult.m_barycentricCoords[VERTA], + tempResult.m_barycentricCoords[VERTC], + 0, + tempResult.m_barycentricCoords[VERTB]); + } + } + // Repeat test for face bdc + + if (pointOutsideBDC) + { + closestPtPointTriangle(p, b, d, c, tempResult); + btVector3 q = tempResult.m_closestPointOnSimplex; + //convert result bitmask! + btScalar sqDist = (q - p).dot(q - p); + if (sqDist < bestSqDist) + { + bestSqDist = sqDist; + finalResult.m_closestPointOnSimplex = q; + finalResult.m_usedVertices.reset(); + // + finalResult.m_usedVertices.usedVertexB = tempResult.m_usedVertices.usedVertexA; + finalResult.m_usedVertices.usedVertexC = tempResult.m_usedVertices.usedVertexC; + finalResult.m_usedVertices.usedVertexD = tempResult.m_usedVertices.usedVertexB; + + finalResult.setBarycentricCoordinates( + 0, + tempResult.m_barycentricCoords[VERTA], + tempResult.m_barycentricCoords[VERTC], + tempResult.m_barycentricCoords[VERTB]); + } + } + + //help! we ended up full ! + + if (finalResult.m_usedVertices.usedVertexA && + finalResult.m_usedVertices.usedVertexB && + finalResult.m_usedVertices.usedVertexC && + finalResult.m_usedVertices.usedVertexD) + { + return true; + } + + return true; +} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp.i new file mode 100644 index 00000000..1d140c3c --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp ---------------- + +// %include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h new file mode 100644 index 00000000..5ed896f2 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h @@ -0,0 +1,173 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_VORONOI_SIMPLEX_SOLVER_H +#define BT_VORONOI_SIMPLEX_SOLVER_H + +#include "btSimplexSolverInterface.h" + +#define VORONOI_SIMPLEX_MAX_VERTS 5 + +///disable next define, or use defaultCollisionConfiguration->getSimplexSolver()->setEqualVertexThreshold(0.f) to disable/configure +#define BT_USE_EQUAL_VERTEX_THRESHOLD + +#ifdef BT_USE_DOUBLE_PRECISION +#define VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD 1e-12f +#else +#define VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD 0.0001f +#endif //BT_USE_DOUBLE_PRECISION + +struct btUsageBitfield +{ + btUsageBitfield() + { + reset(); + } + + void reset() + { + usedVertexA = false; + usedVertexB = false; + usedVertexC = false; + usedVertexD = false; + } + unsigned short usedVertexA : 1; + unsigned short usedVertexB : 1; + unsigned short usedVertexC : 1; + unsigned short usedVertexD : 1; + unsigned short unused1 : 1; + unsigned short unused2 : 1; + unsigned short unused3 : 1; + unsigned short unused4 : 1; +}; + +struct btSubSimplexClosestResult +{ + btVector3 m_closestPointOnSimplex; + //MASK for m_usedVertices + //stores the simplex vertex-usage, using the MASK, + // if m_usedVertices & MASK then the related vertex is used + btUsageBitfield m_usedVertices; + btScalar m_barycentricCoords[4]; + bool m_degenerate; + + void reset() + { + m_degenerate = false; + setBarycentricCoordinates(); + m_usedVertices.reset(); + } + bool isValid() + { + bool valid = (m_barycentricCoords[0] >= btScalar(0.)) && + (m_barycentricCoords[1] >= btScalar(0.)) && + (m_barycentricCoords[2] >= btScalar(0.)) && + (m_barycentricCoords[3] >= btScalar(0.)); + + return valid; + } + void setBarycentricCoordinates(btScalar a = btScalar(0.), btScalar b = btScalar(0.), btScalar c = btScalar(0.), btScalar d = btScalar(0.)) + { + m_barycentricCoords[0] = a; + m_barycentricCoords[1] = b; + m_barycentricCoords[2] = c; + m_barycentricCoords[3] = d; + } +}; + +/// btVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points simplex to the origin. +/// Can be used with GJK, as an alternative to Johnson distance algorithm. +#ifdef NO_VIRTUAL_INTERFACE +ATTRIBUTE_ALIGNED16(class) +btVoronoiSimplexSolver +#else +ATTRIBUTE_ALIGNED16(class) +btVoronoiSimplexSolver : public btSimplexSolverInterface +#endif +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + int m_numVertices; + + btVector3 m_simplexVectorW[VORONOI_SIMPLEX_MAX_VERTS]; + btVector3 m_simplexPointsP[VORONOI_SIMPLEX_MAX_VERTS]; + btVector3 m_simplexPointsQ[VORONOI_SIMPLEX_MAX_VERTS]; + + btVector3 m_cachedP1; + btVector3 m_cachedP2; + btVector3 m_cachedV; + btVector3 m_lastW; + + btScalar m_equalVertexThreshold; + bool m_cachedValidClosest; + + btSubSimplexClosestResult m_cachedBC; + + bool m_needsUpdate; + + void removeVertex(int index); + void reduceVertices(const btUsageBitfield& usedVerts); + bool updateClosestVectorAndPoints(); + + bool closestPtPointTetrahedron(const btVector3& p, const btVector3& a, const btVector3& b, const btVector3& c, const btVector3& d, btSubSimplexClosestResult& finalResult); + int pointOutsideOfPlane(const btVector3& p, const btVector3& a, const btVector3& b, const btVector3& c, const btVector3& d); + bool closestPtPointTriangle(const btVector3& p, const btVector3& a, const btVector3& b, const btVector3& c, btSubSimplexClosestResult& result); + +public: + btVoronoiSimplexSolver() + : m_equalVertexThreshold(VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD) + { + } + void reset(); + + void addVertex(const btVector3& w, const btVector3& p, const btVector3& q); + + void setEqualVertexThreshold(btScalar threshold) + { + m_equalVertexThreshold = threshold; + } + + btScalar getEqualVertexThreshold() const + { + return m_equalVertexThreshold; + } + + bool closest(btVector3 & v); + + btScalar maxVertex(); + + bool fullSimplex() const + { + return (m_numVertices == 4); + } + + int getSimplex(btVector3 * pBuf, btVector3 * qBuf, btVector3 * yBuf) const; + + bool inSimplex(const btVector3& w); + + void backup_closest(btVector3 & v); + + bool emptySimplex() const; + + void compute_points(btVector3 & p1, btVector3 & p2); + + int numVertices() const + { + return m_numVertices; + } +}; + +#endif //BT_VORONOI_SIMPLEX_SOLVER_H diff --git a/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h.i b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h.i new file mode 100644 index 00000000..68b1e973 --- /dev/null +++ b/pkg/mphysics/mbt/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h.i @@ -0,0 +1,7 @@ +////// BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h ---------------- + +%include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" + +%{ +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp new file mode 100644 index 00000000..8e7467f4 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp @@ -0,0 +1,1084 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btBatchedConstraints.h" + +#include "LinearMath/btIDebugDraw.h" +#include "LinearMath/btMinMax.h" +#include "LinearMath/btStackAlloc.h" +#include "LinearMath/btQuickprof.h" + +#include //for memset + +#include + +const int kNoMerge = -1; + +bool btBatchedConstraints::s_debugDrawBatches = false; + +struct btBatchedConstraintInfo +{ + int constraintIndex; + int numConstraintRows; + int bodyIds[2]; +}; + +struct btBatchInfo +{ + int numConstraints; + int mergeIndex; + + btBatchInfo() : numConstraints(0), mergeIndex(kNoMerge) {} +}; + +bool btBatchedConstraints::validate(btConstraintArray* constraints, const btAlignedObjectArray& bodies) const +{ + // + // validate: for debugging only. Verify coloring of bodies, that no body is touched by more than one batch in any given phase + // + int errors = 0; + const int kUnassignedBatch = -1; + + btAlignedObjectArray bodyBatchId; + for (int iPhase = 0; iPhase < m_phases.size(); ++iPhase) + { + bodyBatchId.resizeNoInitialize(0); + bodyBatchId.resize(bodies.size(), kUnassignedBatch); + const Range& phase = m_phases[iPhase]; + for (int iBatch = phase.begin; iBatch < phase.end; ++iBatch) + { + const Range& batch = m_batches[iBatch]; + for (int iiCons = batch.begin; iiCons < batch.end; ++iiCons) + { + int iCons = m_constraintIndices[iiCons]; + const btSolverConstraint& cons = constraints->at(iCons); + const btSolverBody& bodyA = bodies[cons.m_solverBodyIdA]; + const btSolverBody& bodyB = bodies[cons.m_solverBodyIdB]; + if (!bodyA.internalGetInvMass().isZero()) + { + int thisBodyBatchId = bodyBatchId[cons.m_solverBodyIdA]; + if (thisBodyBatchId == kUnassignedBatch) + { + bodyBatchId[cons.m_solverBodyIdA] = iBatch; + } + else if (thisBodyBatchId != iBatch) + { + btAssert(!"dynamic body is used in 2 different batches in the same phase"); + errors++; + } + } + if (!bodyB.internalGetInvMass().isZero()) + { + int thisBodyBatchId = bodyBatchId[cons.m_solverBodyIdB]; + if (thisBodyBatchId == kUnassignedBatch) + { + bodyBatchId[cons.m_solverBodyIdB] = iBatch; + } + else if (thisBodyBatchId != iBatch) + { + btAssert(!"dynamic body is used in 2 different batches in the same phase"); + errors++; + } + } + } + } + } + return errors == 0; +} + +static void debugDrawSingleBatch(const btBatchedConstraints* bc, + btConstraintArray* constraints, + const btAlignedObjectArray& bodies, + int iBatch, + const btVector3& color, + const btVector3& offset) +{ + if (bc && bc->m_debugDrawer && iBatch < bc->m_batches.size()) + { + const btBatchedConstraints::Range& b = bc->m_batches[iBatch]; + for (int iiCon = b.begin; iiCon < b.end; ++iiCon) + { + int iCon = bc->m_constraintIndices[iiCon]; + const btSolverConstraint& con = constraints->at(iCon); + int iBody0 = con.m_solverBodyIdA; + int iBody1 = con.m_solverBodyIdB; + btVector3 pos0 = bodies[iBody0].getWorldTransform().getOrigin() + offset; + btVector3 pos1 = bodies[iBody1].getWorldTransform().getOrigin() + offset; + bc->m_debugDrawer->drawLine(pos0, pos1, color); + } + } +} + +static void debugDrawPhase(const btBatchedConstraints* bc, + btConstraintArray* constraints, + const btAlignedObjectArray& bodies, + int iPhase, + const btVector3& color0, + const btVector3& color1, + const btVector3& offset) +{ +//\1("debugDrawPhase"); + if (bc && bc->m_debugDrawer && iPhase < bc->m_phases.size()) + { + const btBatchedConstraints::Range& phase = bc->m_phases[iPhase]; + for (int iBatch = phase.begin; iBatch < phase.end; ++iBatch) + { + float tt = float(iBatch - phase.begin) / float(btMax(1, phase.end - phase.begin - 1)); + btVector3 col = lerp(color0, color1, tt); + debugDrawSingleBatch(bc, constraints, bodies, iBatch, col, offset); + } + } +} + +static void debugDrawAllBatches(const btBatchedConstraints* bc, + btConstraintArray* constraints, + const btAlignedObjectArray& bodies) +{ +//\1("debugDrawAllBatches"); + if (bc && bc->m_debugDrawer && bc->m_phases.size() > 0) + { + btVector3 bboxMin(BT_LARGE_FLOAT, BT_LARGE_FLOAT, BT_LARGE_FLOAT); + btVector3 bboxMax = -bboxMin; + for (int iBody = 0; iBody < bodies.size(); ++iBody) + { + const btVector3& pos = bodies[iBody].getWorldTransform().getOrigin(); + bboxMin.setMin(pos); + bboxMax.setMax(pos); + } + btVector3 bboxExtent = bboxMax - bboxMin; + btVector3 offsetBase = btVector3(0, bboxExtent.y() * 1.1f, 0); + btVector3 offsetStep = btVector3(0, 0, bboxExtent.z() * 1.1f); + int numPhases = bc->m_phases.size(); + for (int iPhase = 0; iPhase < numPhases; ++iPhase) + { + float b = float(iPhase) / float(numPhases - 1); + btVector3 color0 = btVector3(1, 0, b); + btVector3 color1 = btVector3(0, 1, b); + btVector3 offset = offsetBase + offsetStep * (float(iPhase) - float(numPhases - 1) * 0.5); + debugDrawPhase(bc, constraints, bodies, iPhase, color0, color1, offset); + } + } +} + +static void initBatchedBodyDynamicFlags(btAlignedObjectArray* outBodyDynamicFlags, const btAlignedObjectArray& bodies) +{ +//\1("initBatchedBodyDynamicFlags"); + btAlignedObjectArray& bodyDynamicFlags = *outBodyDynamicFlags; + bodyDynamicFlags.resizeNoInitialize(bodies.size()); + for (int i = 0; i < bodies.size(); ++i) + { + const btSolverBody& body = bodies[i]; + bodyDynamicFlags[i] = (body.internalGetInvMass().x() > btScalar(0)); + } +} + +static int runLengthEncodeConstraintInfo(btBatchedConstraintInfo* outConInfos, int numConstraints) +{ +//\1("runLengthEncodeConstraintInfo"); + // detect and run-length encode constraint rows that repeat the same bodies + int iDest = 0; + int iSrc = 0; + while (iSrc < numConstraints) + { + const btBatchedConstraintInfo& srcConInfo = outConInfos[iSrc]; + btBatchedConstraintInfo& conInfo = outConInfos[iDest]; + conInfo.constraintIndex = iSrc; + conInfo.bodyIds[0] = srcConInfo.bodyIds[0]; + conInfo.bodyIds[1] = srcConInfo.bodyIds[1]; + while (iSrc < numConstraints && outConInfos[iSrc].bodyIds[0] == srcConInfo.bodyIds[0] && outConInfos[iSrc].bodyIds[1] == srcConInfo.bodyIds[1]) + { + ++iSrc; + } + conInfo.numConstraintRows = iSrc - conInfo.constraintIndex; + ++iDest; + } + return iDest; +} + +struct ReadSolverConstraintsLoop : public btIParallelForBody +{ + btBatchedConstraintInfo* m_outConInfos; + btConstraintArray* m_constraints; + + ReadSolverConstraintsLoop(btBatchedConstraintInfo* outConInfos, btConstraintArray* constraints) + { + m_outConInfos = outConInfos; + m_constraints = constraints; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + for (int i = iBegin; i < iEnd; ++i) + { + btBatchedConstraintInfo& conInfo = m_outConInfos[i]; + const btSolverConstraint& con = m_constraints->at(i); + conInfo.bodyIds[0] = con.m_solverBodyIdA; + conInfo.bodyIds[1] = con.m_solverBodyIdB; + conInfo.constraintIndex = i; + conInfo.numConstraintRows = 1; + } + } +}; + +static int initBatchedConstraintInfo(btBatchedConstraintInfo* outConInfos, btConstraintArray* constraints) +{ +//\1("initBatchedConstraintInfo"); + int numConstraints = constraints->size(); + bool inParallel = true; + if (inParallel) + { + ReadSolverConstraintsLoop loop(outConInfos, constraints); + int grainSize = 1200; + btParallelFor(0, numConstraints, grainSize, loop); + } + else + { + for (int i = 0; i < numConstraints; ++i) + { + btBatchedConstraintInfo& conInfo = outConInfos[i]; + const btSolverConstraint& con = constraints->at(i); + conInfo.bodyIds[0] = con.m_solverBodyIdA; + conInfo.bodyIds[1] = con.m_solverBodyIdB; + conInfo.constraintIndex = i; + conInfo.numConstraintRows = 1; + } + } + bool useRunLengthEncoding = true; + if (useRunLengthEncoding) + { + numConstraints = runLengthEncodeConstraintInfo(outConInfos, numConstraints); + } + return numConstraints; +} + +static void expandConstraintRowsInPlace(int* constraintBatchIds, const btBatchedConstraintInfo* conInfos, int numConstraints, int numConstraintRows) +{ +//\1("expandConstraintRowsInPlace"); + if (numConstraintRows > numConstraints) + { + // we walk the array in reverse to avoid overwriteing + for (int iCon = numConstraints - 1; iCon >= 0; --iCon) + { + const btBatchedConstraintInfo& conInfo = conInfos[iCon]; + int iBatch = constraintBatchIds[iCon]; + for (int i = conInfo.numConstraintRows - 1; i >= 0; --i) + { + int iDest = conInfo.constraintIndex + i; + btAssert(iDest >= iCon); + btAssert(iDest >= 0 && iDest < numConstraintRows); + constraintBatchIds[iDest] = iBatch; + } + } + } +} + +static void expandConstraintRows(int* destConstraintBatchIds, const int* srcConstraintBatchIds, const btBatchedConstraintInfo* conInfos, int numConstraints, int numConstraintRows) +{ +//\1("expandConstraintRows"); + for (int iCon = 0; iCon < numConstraints; ++iCon) + { + const btBatchedConstraintInfo& conInfo = conInfos[iCon]; + int iBatch = srcConstraintBatchIds[iCon]; + for (int i = 0; i < conInfo.numConstraintRows; ++i) + { + int iDest = conInfo.constraintIndex + i; + btAssert(iDest >= iCon); + btAssert(iDest >= 0 && iDest < numConstraintRows); + destConstraintBatchIds[iDest] = iBatch; + } + } +} + +struct ExpandConstraintRowsLoop : public btIParallelForBody +{ + int* m_destConstraintBatchIds; + const int* m_srcConstraintBatchIds; + const btBatchedConstraintInfo* m_conInfos; + int m_numConstraintRows; + + ExpandConstraintRowsLoop(int* destConstraintBatchIds, const int* srcConstraintBatchIds, const btBatchedConstraintInfo* conInfos, int numConstraintRows) + { + m_destConstraintBatchIds = destConstraintBatchIds; + m_srcConstraintBatchIds = srcConstraintBatchIds; + m_conInfos = conInfos; + m_numConstraintRows = numConstraintRows; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + expandConstraintRows(m_destConstraintBatchIds, m_srcConstraintBatchIds + iBegin, m_conInfos + iBegin, iEnd - iBegin, m_numConstraintRows); + } +}; + +static void expandConstraintRowsMt(int* destConstraintBatchIds, const int* srcConstraintBatchIds, const btBatchedConstraintInfo* conInfos, int numConstraints, int numConstraintRows) +{ +//\1("expandConstraintRowsMt"); + ExpandConstraintRowsLoop loop(destConstraintBatchIds, srcConstraintBatchIds, conInfos, numConstraintRows); + int grainSize = 600; + btParallelFor(0, numConstraints, grainSize, loop); +} + +static void initBatchedConstraintInfoArray(btAlignedObjectArray* outConInfos, btConstraintArray* constraints) +{ +//\1("initBatchedConstraintInfoArray"); + btAlignedObjectArray& conInfos = *outConInfos; + int numConstraints = constraints->size(); + conInfos.resizeNoInitialize(numConstraints); + + int newSize = initBatchedConstraintInfo(&outConInfos->at(0), constraints); + conInfos.resizeNoInitialize(newSize); +} + +static void mergeSmallBatches(btBatchInfo* batches, int iBeginBatch, int iEndBatch, int minBatchSize, int maxBatchSize) +{ +//\1("mergeSmallBatches"); + for (int iBatch = iEndBatch - 1; iBatch >= iBeginBatch; --iBatch) + { + btBatchInfo& batch = batches[iBatch]; + if (batch.mergeIndex == kNoMerge && batch.numConstraints > 0 && batch.numConstraints < minBatchSize) + { + for (int iDestBatch = iBatch - 1; iDestBatch >= iBeginBatch; --iDestBatch) + { + btBatchInfo& destBatch = batches[iDestBatch]; + if (destBatch.mergeIndex == kNoMerge && (destBatch.numConstraints + batch.numConstraints) < maxBatchSize) + { + destBatch.numConstraints += batch.numConstraints; + batch.numConstraints = 0; + batch.mergeIndex = iDestBatch; + break; + } + } + } + } + // flatten mergeIndexes + // e.g. in case where A was merged into B and then B was merged into C, we need A to point to C instead of B + // Note: loop goes forward through batches because batches always merge from higher indexes to lower, + // so by going from low to high it reduces the amount of trail-following + for (int iBatch = iBeginBatch; iBatch < iEndBatch; ++iBatch) + { + btBatchInfo& batch = batches[iBatch]; + if (batch.mergeIndex != kNoMerge) + { + int iMergeDest = batches[batch.mergeIndex].mergeIndex; + // follow trail of merges to the end + while (iMergeDest != kNoMerge) + { + int iNext = batches[iMergeDest].mergeIndex; + if (iNext == kNoMerge) + { + batch.mergeIndex = iMergeDest; + break; + } + iMergeDest = iNext; + } + } + } +} + +static void updateConstraintBatchIdsForMerges(int* constraintBatchIds, int numConstraints, const btBatchInfo* batches, int numBatches) +{ +//\1("updateConstraintBatchIdsForMerges"); + // update batchIds to account for merges + for (int i = 0; i < numConstraints; ++i) + { + int iBatch = constraintBatchIds[i]; + btAssert(iBatch < numBatches); + // if this constraint references a batch that was merged into another batch + if (batches[iBatch].mergeIndex != kNoMerge) + { + // update batchId + constraintBatchIds[i] = batches[iBatch].mergeIndex; + } + } +} + +struct UpdateConstraintBatchIdsForMergesLoop : public btIParallelForBody +{ + int* m_constraintBatchIds; + const btBatchInfo* m_batches; + int m_numBatches; + + UpdateConstraintBatchIdsForMergesLoop(int* constraintBatchIds, const btBatchInfo* batches, int numBatches) + { + m_constraintBatchIds = constraintBatchIds; + m_batches = batches; + m_numBatches = numBatches; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { +//\1("UpdateConstraintBatchIdsForMergesLoop"); + updateConstraintBatchIdsForMerges(m_constraintBatchIds + iBegin, iEnd - iBegin, m_batches, m_numBatches); + } +}; + +static void updateConstraintBatchIdsForMergesMt(int* constraintBatchIds, int numConstraints, const btBatchInfo* batches, int numBatches) +{ +//\1("updateConstraintBatchIdsForMergesMt"); + UpdateConstraintBatchIdsForMergesLoop loop(constraintBatchIds, batches, numBatches); + int grainSize = 800; + btParallelFor(0, numConstraints, grainSize, loop); +} + +inline bool BatchCompare(const btBatchedConstraints::Range& a, const btBatchedConstraints::Range& b) +{ + int lenA = a.end - a.begin; + int lenB = b.end - b.begin; + return lenA > lenB; +} + +static void writeOutConstraintIndicesForRangeOfBatches(btBatchedConstraints* bc, + const int* constraintBatchIds, + int numConstraints, + int* constraintIdPerBatch, + int batchBegin, + int batchEnd) +{ +//\1("writeOutConstraintIndicesForRangeOfBatches"); + for (int iCon = 0; iCon < numConstraints; ++iCon) + { + int iBatch = constraintBatchIds[iCon]; + if (iBatch >= batchBegin && iBatch < batchEnd) + { + int iDestCon = constraintIdPerBatch[iBatch]; + constraintIdPerBatch[iBatch] = iDestCon + 1; + bc->m_constraintIndices[iDestCon] = iCon; + } + } +} + +struct WriteOutConstraintIndicesLoop : public btIParallelForBody +{ + btBatchedConstraints* m_batchedConstraints; + const int* m_constraintBatchIds; + int m_numConstraints; + int* m_constraintIdPerBatch; + int m_maxNumBatchesPerPhase; + + WriteOutConstraintIndicesLoop(btBatchedConstraints* bc, const int* constraintBatchIds, int numConstraints, int* constraintIdPerBatch, int maxNumBatchesPerPhase) + { + m_batchedConstraints = bc; + m_constraintBatchIds = constraintBatchIds; + m_numConstraints = numConstraints; + m_constraintIdPerBatch = constraintIdPerBatch; + m_maxNumBatchesPerPhase = maxNumBatchesPerPhase; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { +//\1("WriteOutConstraintIndicesLoop"); + int batchBegin = iBegin * m_maxNumBatchesPerPhase; + int batchEnd = iEnd * m_maxNumBatchesPerPhase; + writeOutConstraintIndicesForRangeOfBatches(m_batchedConstraints, + m_constraintBatchIds, + m_numConstraints, + m_constraintIdPerBatch, + batchBegin, + batchEnd); + } +}; + +static void writeOutConstraintIndicesMt(btBatchedConstraints* bc, + const int* constraintBatchIds, + int numConstraints, + int* constraintIdPerBatch, + int maxNumBatchesPerPhase, + int numPhases) +{ +//\1("writeOutConstraintIndicesMt"); + bool inParallel = true; + if (inParallel) + { + WriteOutConstraintIndicesLoop loop(bc, constraintBatchIds, numConstraints, constraintIdPerBatch, maxNumBatchesPerPhase); + btParallelFor(0, numPhases, 1, loop); + } + else + { + for (int iCon = 0; iCon < numConstraints; ++iCon) + { + int iBatch = constraintBatchIds[iCon]; + int iDestCon = constraintIdPerBatch[iBatch]; + constraintIdPerBatch[iBatch] = iDestCon + 1; + bc->m_constraintIndices[iDestCon] = iCon; + } + } +} + +static void writeGrainSizes(btBatchedConstraints* bc) +{ + typedef btBatchedConstraints::Range Range; + int numPhases = bc->m_phases.size(); + bc->m_phaseGrainSize.resizeNoInitialize(numPhases); + int numThreads = btGetTaskScheduler()->getNumThreads(); + for (int iPhase = 0; iPhase < numPhases; ++iPhase) + { + const Range& phase = bc->m_phases[iPhase]; + int numBatches = phase.end - phase.begin; + float grainSize = std::floor((0.25f * numBatches / float(numThreads)) + 0.0f); + bc->m_phaseGrainSize[iPhase] = btMax(1, int(grainSize)); + } +} + +static void writeOutBatches(btBatchedConstraints* bc, + const int* constraintBatchIds, + int numConstraints, + const btBatchInfo* batches, + int* batchWork, + int maxNumBatchesPerPhase, + int numPhases) +{ +//\1("writeOutBatches"); + typedef btBatchedConstraints::Range Range; + bc->m_constraintIndices.reserve(numConstraints); + bc->m_batches.resizeNoInitialize(0); + bc->m_phases.resizeNoInitialize(0); + + //int maxNumBatches = numPhases * maxNumBatchesPerPhase; + { + int* constraintIdPerBatch = batchWork; // for each batch, keep an index into the next available slot in the m_constraintIndices array + int iConstraint = 0; + for (int iPhase = 0; iPhase < numPhases; ++iPhase) + { + int curPhaseBegin = bc->m_batches.size(); + int iBegin = iPhase * maxNumBatchesPerPhase; + int iEnd = iBegin + maxNumBatchesPerPhase; + for (int i = iBegin; i < iEnd; ++i) + { + const btBatchInfo& batch = batches[i]; + int curBatchBegin = iConstraint; + constraintIdPerBatch[i] = curBatchBegin; // record the start of each batch in m_constraintIndices array + int numConstraints = batch.numConstraints; + iConstraint += numConstraints; + if (numConstraints > 0) + { + bc->m_batches.push_back(Range(curBatchBegin, iConstraint)); + } + } + // if any batches were emitted this phase, + if (bc->m_batches.size() > curPhaseBegin) + { + // output phase + bc->m_phases.push_back(Range(curPhaseBegin, bc->m_batches.size())); + } + } + + btAssert(iConstraint == numConstraints); + bc->m_constraintIndices.resizeNoInitialize(numConstraints); + writeOutConstraintIndicesMt(bc, constraintBatchIds, numConstraints, constraintIdPerBatch, maxNumBatchesPerPhase, numPhases); + } + // for each phase + for (int iPhase = 0; iPhase < bc->m_phases.size(); ++iPhase) + { + // sort the batches from largest to smallest (can be helpful to some task schedulers) + const Range& curBatches = bc->m_phases[iPhase]; + bc->m_batches.quickSortInternal(BatchCompare, curBatches.begin, curBatches.end - 1); + } + bc->m_phaseOrder.resize(bc->m_phases.size()); + for (int i = 0; i < bc->m_phases.size(); ++i) + { + bc->m_phaseOrder[i] = i; + } + writeGrainSizes(bc); +} + +// +// PreallocatedMemoryHelper -- helper object for allocating a number of chunks of memory in a single contiguous block. +// It is generally more efficient to do a single larger allocation than many smaller allocations. +// +// Example Usage: +// +// btVector3* bodyPositions = NULL; +// btBatchedConstraintInfo* conInfos = NULL; +// { +// PreallocatedMemoryHelper<8> memHelper; +// memHelper.addChunk( (void**) &bodyPositions, sizeof( btVector3 ) * bodies.size() ); +// memHelper.addChunk( (void**) &conInfos, sizeof( btBatchedConstraintInfo ) * numConstraints ); +// void* memPtr = malloc( memHelper.getSizeToAllocate() ); // allocate the memory +// memHelper.setChunkPointers( memPtr ); // update pointers to chunks +// } +template +class PreallocatedMemoryHelper +{ + struct Chunk + { + void** ptr; + size_t size; + }; + Chunk m_chunks[N]; + int m_numChunks; + +public: + PreallocatedMemoryHelper() { m_numChunks = 0; } + void addChunk(void** ptr, size_t sz) + { + btAssert(m_numChunks < N); + if (m_numChunks < N) + { + Chunk& chunk = m_chunks[m_numChunks]; + chunk.ptr = ptr; + chunk.size = sz; + m_numChunks++; + } + } + size_t getSizeToAllocate() const + { + size_t totalSize = 0; + for (int i = 0; i < m_numChunks; ++i) + { + totalSize += m_chunks[i].size; + } + return totalSize; + } + void setChunkPointers(void* mem) const + { + size_t totalSize = 0; + for (int i = 0; i < m_numChunks; ++i) + { + const Chunk& chunk = m_chunks[i]; + char* chunkPtr = static_cast(mem) + totalSize; + *chunk.ptr = chunkPtr; + totalSize += chunk.size; + } + } +}; + +static btVector3 findMaxDynamicConstraintExtent( + btVector3* bodyPositions, + bool* bodyDynamicFlags, + btBatchedConstraintInfo* conInfos, + int numConstraints, + int numBodies) +{ +//\1("findMaxDynamicConstraintExtent"); + btVector3 consExtent = btVector3(1, 1, 1) * 0.001; + for (int iCon = 0; iCon < numConstraints; ++iCon) + { + const btBatchedConstraintInfo& con = conInfos[iCon]; + int iBody0 = con.bodyIds[0]; + int iBody1 = con.bodyIds[1]; + btAssert(iBody0 >= 0 && iBody0 < numBodies); + btAssert(iBody1 >= 0 && iBody1 < numBodies); + // is it a dynamic constraint? + if (bodyDynamicFlags[iBody0] && bodyDynamicFlags[iBody1]) + { + btVector3 delta = bodyPositions[iBody1] - bodyPositions[iBody0]; + consExtent.setMax(delta.absolute()); + } + } + return consExtent; +} + +struct btIntVec3 +{ + int m_ints[3]; + + SIMD_FORCE_INLINE const int& operator[](int i) const { return m_ints[i]; } + SIMD_FORCE_INLINE int& operator[](int i) { return m_ints[i]; } +}; + +struct AssignConstraintsToGridBatchesParams +{ + bool* bodyDynamicFlags; + btIntVec3* bodyGridCoords; + int numBodies; + btBatchedConstraintInfo* conInfos; + int* constraintBatchIds; + btIntVec3 gridChunkDim; + int maxNumBatchesPerPhase; + int numPhases; + int phaseMask; + + AssignConstraintsToGridBatchesParams() + { + memset(this, 0, sizeof(*this)); + } +}; + +static void assignConstraintsToGridBatches(const AssignConstraintsToGridBatchesParams& params, int iConBegin, int iConEnd) +{ +//\1("assignConstraintsToGridBatches"); + // (can be done in parallel) + for (int iCon = iConBegin; iCon < iConEnd; ++iCon) + { + const btBatchedConstraintInfo& con = params.conInfos[iCon]; + int iBody0 = con.bodyIds[0]; + int iBody1 = con.bodyIds[1]; + int iPhase = iCon; //iBody0; // pseudorandom choice to distribute evenly amongst phases + iPhase &= params.phaseMask; + int gridCoord[3]; + // is it a dynamic constraint? + if (params.bodyDynamicFlags[iBody0] && params.bodyDynamicFlags[iBody1]) + { + const btIntVec3& body0Coords = params.bodyGridCoords[iBody0]; + const btIntVec3& body1Coords = params.bodyGridCoords[iBody1]; + // for each dimension x,y,z, + for (int i = 0; i < 3; ++i) + { + int coordMin = btMin(body0Coords.m_ints[i], body1Coords.m_ints[i]); + int coordMax = btMax(body0Coords.m_ints[i], body1Coords.m_ints[i]); + if (coordMin != coordMax) + { + btAssert(coordMax == coordMin + 1); + if ((coordMin & 1) == 0) + { + iPhase &= ~(1 << i); // force bit off + } + else + { + iPhase |= (1 << i); // force bit on + iPhase &= params.phaseMask; + } + } + gridCoord[i] = coordMin; + } + } + else + { + if (!params.bodyDynamicFlags[iBody0]) + { + iBody0 = con.bodyIds[1]; + } + btAssert(params.bodyDynamicFlags[iBody0]); + const btIntVec3& body0Coords = params.bodyGridCoords[iBody0]; + // for each dimension x,y,z, + for (int i = 0; i < 3; ++i) + { + gridCoord[i] = body0Coords.m_ints[i]; + } + } + // calculate chunk coordinates + int chunkCoord[3]; + btIntVec3 gridChunkDim = params.gridChunkDim; + // for each dimension x,y,z, + for (int i = 0; i < 3; ++i) + { + int coordOffset = (iPhase >> i) & 1; + chunkCoord[i] = (gridCoord[i] - coordOffset) / 2; + btClamp(chunkCoord[i], 0, gridChunkDim[i] - 1); + btAssert(chunkCoord[i] < gridChunkDim[i]); + } + int iBatch = iPhase * params.maxNumBatchesPerPhase + chunkCoord[0] + chunkCoord[1] * gridChunkDim[0] + chunkCoord[2] * gridChunkDim[0] * gridChunkDim[1]; + btAssert(iBatch >= 0 && iBatch < params.maxNumBatchesPerPhase * params.numPhases); + params.constraintBatchIds[iCon] = iBatch; + } +} + +struct AssignConstraintsToGridBatchesLoop : public btIParallelForBody +{ + const AssignConstraintsToGridBatchesParams* m_params; + + AssignConstraintsToGridBatchesLoop(const AssignConstraintsToGridBatchesParams& params) + { + m_params = ¶ms; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + assignConstraintsToGridBatches(*m_params, iBegin, iEnd); + } +}; + +// +// setupSpatialGridBatchesMt -- generate batches using a uniform 3D grid +// +/* + +Bodies are treated as 3D points at their center of mass. We only consider dynamic bodies at this stage, +because only dynamic bodies are mutated when a constraint is solved, thus subject to race conditions. + +1. Compute a bounding box around all dynamic bodies +2. Compute the maximum extent of all dynamic constraints. Each dynamic constraint is treated as a line segment, and we need the size of + box that will fully enclose any single dynamic constraint + +3. Establish the cell size of our grid, the cell size in each dimension must be at least as large as the dynamic constraints max-extent, + so that no dynamic constraint can span more than 2 cells of our grid on any axis of the grid. The cell size should be adjusted + larger in order to keep the total number of cells from being excessively high + +Key idea: Given that each constraint spans 1 or 2 grid cells in each dimension, we can handle all constraints by processing + in chunks of 2x2x2 cells with 8 different 1-cell offsets ((0,0,0),(0,0,1),(0,1,0),(0,1,1),(1,0,0)...). + For each of the 8 offsets, we create a phase, and for each 2x2x2 chunk with dynamic constraints becomes a batch in that phase. + +4. Once the grid is established, we can calculate for each constraint which phase and batch it belongs in. + +5. Do a merge small batches on the batches of each phase separately, to try to even out the sizes of batches + +Optionally, we can "collapse" one dimension of our 3D grid to turn it into a 2D grid, which reduces the number of phases +to 4. With fewer phases, there are more constraints per phase and this makes it easier to create batches of a useful size. +*/ +// +static void setupSpatialGridBatchesMt( + btBatchedConstraints* batchedConstraints, + btAlignedObjectArray* scratchMemory, + btConstraintArray* constraints, + const btAlignedObjectArray& bodies, + int minBatchSize, + int maxBatchSize, + bool use2DGrid) +{ +//\1("setupSpatialGridBatchesMt"); + const int numPhases = 8; + int numConstraints = constraints->size(); + int numConstraintRows = constraints->size(); + + const int maxGridChunkCount = 128; + int allocNumBatchesPerPhase = maxGridChunkCount; + int minNumBatchesPerPhase = 16; + int allocNumBatches = allocNumBatchesPerPhase * numPhases; + + btVector3* bodyPositions = NULL; + bool* bodyDynamicFlags = NULL; + btIntVec3* bodyGridCoords = NULL; + btBatchInfo* batches = NULL; + int* batchWork = NULL; + btBatchedConstraintInfo* conInfos = NULL; + int* constraintBatchIds = NULL; + int* constraintRowBatchIds = NULL; + { + PreallocatedMemoryHelper<10> memHelper; + memHelper.addChunk((void**)&bodyPositions, sizeof(btVector3) * bodies.size()); + memHelper.addChunk((void**)&bodyDynamicFlags, sizeof(bool) * bodies.size()); + memHelper.addChunk((void**)&bodyGridCoords, sizeof(btIntVec3) * bodies.size()); + memHelper.addChunk((void**)&batches, sizeof(btBatchInfo) * allocNumBatches); + memHelper.addChunk((void**)&batchWork, sizeof(int) * allocNumBatches); + memHelper.addChunk((void**)&conInfos, sizeof(btBatchedConstraintInfo) * numConstraints); + memHelper.addChunk((void**)&constraintBatchIds, sizeof(int) * numConstraints); + memHelper.addChunk((void**)&constraintRowBatchIds, sizeof(int) * numConstraintRows); + size_t scratchSize = memHelper.getSizeToAllocate(); + // if we need to reallocate + if (static_cast(scratchMemory->capacity()) < scratchSize) + { + // allocate 6.25% extra to avoid repeated reallocs + scratchMemory->reserve(scratchSize + scratchSize / 16); + } + scratchMemory->resizeNoInitialize(scratchSize); + char* memPtr = &scratchMemory->at(0); + memHelper.setChunkPointers(memPtr); + } + + numConstraints = initBatchedConstraintInfo(conInfos, constraints); + + // compute bounding box around all dynamic bodies + // (could be done in parallel) + btVector3 bboxMin(BT_LARGE_FLOAT, BT_LARGE_FLOAT, BT_LARGE_FLOAT); + btVector3 bboxMax = -bboxMin; + //int dynamicBodyCount = 0; + for (int i = 0; i < bodies.size(); ++i) + { + const btSolverBody& body = bodies[i]; + btVector3 bodyPos = body.getWorldTransform().getOrigin(); + bool isDynamic = (body.internalGetInvMass().x() > btScalar(0)); + bodyPositions[i] = bodyPos; + bodyDynamicFlags[i] = isDynamic; + if (isDynamic) + { + //dynamicBodyCount++; + bboxMin.setMin(bodyPos); + bboxMax.setMax(bodyPos); + } + } + + // find max extent of all dynamic constraints + // (could be done in parallel) + btVector3 consExtent = findMaxDynamicConstraintExtent(bodyPositions, bodyDynamicFlags, conInfos, numConstraints, bodies.size()); + + btVector3 gridExtent = bboxMax - bboxMin; + + gridExtent.setMax(btVector3(btScalar(1), btScalar(1), btScalar(1))); + + btVector3 gridCellSize = consExtent; + int gridDim[3]; + gridDim[0] = int(1.0 + gridExtent.x() / gridCellSize.x()); + gridDim[1] = int(1.0 + gridExtent.y() / gridCellSize.y()); + gridDim[2] = int(1.0 + gridExtent.z() / gridCellSize.z()); + + // if we can collapse an axis, it will cut our number of phases in half which could be more efficient + int phaseMask = 7; + bool collapseAxis = use2DGrid; + if (collapseAxis) + { + // pick the smallest axis to collapse, leaving us with the greatest number of cells in our grid + int iAxisToCollapse = 0; + int axisDim = gridDim[iAxisToCollapse]; + //for each dimension + for (int i = 0; i < 3; ++i) + { + if (gridDim[i] < axisDim) + { + iAxisToCollapse = i; + axisDim = gridDim[i]; + } + } + // collapse it + gridCellSize[iAxisToCollapse] = gridExtent[iAxisToCollapse] * 2.0f; + phaseMask &= ~(1 << iAxisToCollapse); + } + + int numGridChunks = 0; + btIntVec3 gridChunkDim; // each chunk is 2x2x2 group of cells + while (true) + { + gridDim[0] = int(1.0 + gridExtent.x() / gridCellSize.x()); + gridDim[1] = int(1.0 + gridExtent.y() / gridCellSize.y()); + gridDim[2] = int(1.0 + gridExtent.z() / gridCellSize.z()); + gridChunkDim[0] = btMax(1, (gridDim[0] + 0) / 2); + gridChunkDim[1] = btMax(1, (gridDim[1] + 0) / 2); + gridChunkDim[2] = btMax(1, (gridDim[2] + 0) / 2); + numGridChunks = gridChunkDim[0] * gridChunkDim[1] * gridChunkDim[2]; + float nChunks = float(gridChunkDim[0]) * float(gridChunkDim[1]) * float(gridChunkDim[2]); // suceptible to integer overflow + if (numGridChunks <= maxGridChunkCount && nChunks <= maxGridChunkCount) + { + break; + } + gridCellSize *= 1.25; // should roughly cut numCells in half + } + btAssert(numGridChunks <= maxGridChunkCount); + int maxNumBatchesPerPhase = numGridChunks; + + // for each dynamic body, compute grid coords + btVector3 invGridCellSize = btVector3(1, 1, 1) / gridCellSize; + // (can be done in parallel) + for (int iBody = 0; iBody < bodies.size(); ++iBody) + { + btIntVec3& coords = bodyGridCoords[iBody]; + if (bodyDynamicFlags[iBody]) + { + btVector3 v = (bodyPositions[iBody] - bboxMin) * invGridCellSize; + coords.m_ints[0] = int(v.x()); + coords.m_ints[1] = int(v.y()); + coords.m_ints[2] = int(v.z()); + btAssert(coords.m_ints[0] >= 0 && coords.m_ints[0] < gridDim[0]); + btAssert(coords.m_ints[1] >= 0 && coords.m_ints[1] < gridDim[1]); + btAssert(coords.m_ints[2] >= 0 && coords.m_ints[2] < gridDim[2]); + } + else + { + coords.m_ints[0] = -1; + coords.m_ints[1] = -1; + coords.m_ints[2] = -1; + } + } + + for (int iPhase = 0; iPhase < numPhases; ++iPhase) + { + int batchBegin = iPhase * maxNumBatchesPerPhase; + int batchEnd = batchBegin + maxNumBatchesPerPhase; + for (int iBatch = batchBegin; iBatch < batchEnd; ++iBatch) + { + btBatchInfo& batch = batches[iBatch]; + batch = btBatchInfo(); + } + } + + { + AssignConstraintsToGridBatchesParams params; + params.bodyDynamicFlags = bodyDynamicFlags; + params.bodyGridCoords = bodyGridCoords; + params.numBodies = bodies.size(); + params.conInfos = conInfos; + params.constraintBatchIds = constraintBatchIds; + params.gridChunkDim = gridChunkDim; + params.maxNumBatchesPerPhase = maxNumBatchesPerPhase; + params.numPhases = numPhases; + params.phaseMask = phaseMask; + bool inParallel = true; + if (inParallel) + { + AssignConstraintsToGridBatchesLoop loop(params); + int grainSize = 250; + btParallelFor(0, numConstraints, grainSize, loop); + } + else + { + assignConstraintsToGridBatches(params, 0, numConstraints); + } + } + for (int iCon = 0; iCon < numConstraints; ++iCon) + { + const btBatchedConstraintInfo& con = conInfos[iCon]; + int iBatch = constraintBatchIds[iCon]; + btBatchInfo& batch = batches[iBatch]; + batch.numConstraints += con.numConstraintRows; + } + + for (int iPhase = 0; iPhase < numPhases; ++iPhase) + { + // if phase is legit, + if (iPhase == (iPhase & phaseMask)) + { + int iBeginBatch = iPhase * maxNumBatchesPerPhase; + int iEndBatch = iBeginBatch + maxNumBatchesPerPhase; + mergeSmallBatches(batches, iBeginBatch, iEndBatch, minBatchSize, maxBatchSize); + } + } + // all constraints have been assigned a batchId + updateConstraintBatchIdsForMergesMt(constraintBatchIds, numConstraints, batches, maxNumBatchesPerPhase * numPhases); + + if (numConstraintRows > numConstraints) + { + expandConstraintRowsMt(&constraintRowBatchIds[0], &constraintBatchIds[0], &conInfos[0], numConstraints, numConstraintRows); + } + else + { + constraintRowBatchIds = constraintBatchIds; + } + + writeOutBatches(batchedConstraints, constraintRowBatchIds, numConstraintRows, batches, batchWork, maxNumBatchesPerPhase, numPhases); + btAssert(batchedConstraints->validate(constraints, bodies)); +} + +static void setupSingleBatch( + btBatchedConstraints* bc, + int numConstraints) +{ +//\1("setupSingleBatch"); + typedef btBatchedConstraints::Range Range; + + bc->m_constraintIndices.resize(numConstraints); + for (int i = 0; i < numConstraints; ++i) + { + bc->m_constraintIndices[i] = i; + } + + bc->m_batches.resizeNoInitialize(0); + bc->m_phases.resizeNoInitialize(0); + bc->m_phaseOrder.resizeNoInitialize(0); + bc->m_phaseGrainSize.resizeNoInitialize(0); + + if (numConstraints > 0) + { + bc->m_batches.push_back(Range(0, numConstraints)); + bc->m_phases.push_back(Range(0, 1)); + bc->m_phaseOrder.push_back(0); + bc->m_phaseGrainSize.push_back(1); + } +} + +void btBatchedConstraints::setup( + btConstraintArray* constraints, + const btAlignedObjectArray& bodies, + BatchingMethod batchingMethod, + int minBatchSize, + int maxBatchSize, + btAlignedObjectArray* scratchMemory) +{ + if (constraints->size() >= minBatchSize * 4) + { + bool use2DGrid = batchingMethod == BATCHING_METHOD_SPATIAL_GRID_2D; + setupSpatialGridBatchesMt(this, scratchMemory, constraints, bodies, minBatchSize, maxBatchSize, use2DGrid); + if (s_debugDrawBatches) + { + debugDrawAllBatches(this, constraints, bodies); + } + } + else + { + setupSingleBatch(this, constraints->size()); + } +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp.i new file mode 100644 index 00000000..898eb002 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.h new file mode 100644 index 00000000..651df7a9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.h @@ -0,0 +1,62 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_BATCHED_CONSTRAINTS_H +#define BT_BATCHED_CONSTRAINTS_H + +#include "LinearMath/btThreads.h" +#include "LinearMath/btAlignedObjectArray.h" +#include "BulletDynamics/ConstraintSolver/btSolverBody.h" +#include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" + +class btIDebugDraw; + +struct btBatchedConstraints +{ + enum BatchingMethod + { + BATCHING_METHOD_SPATIAL_GRID_2D, + BATCHING_METHOD_SPATIAL_GRID_3D, + BATCHING_METHOD_COUNT + }; + struct Range + { + int begin; + int end; + + Range() : begin(0), end(0) {} + Range(int _beg, int _end) : begin(_beg), end(_end) {} + }; + + btAlignedObjectArray m_constraintIndices; + btAlignedObjectArray m_batches; // each batch is a range of indices in the m_constraintIndices array + btAlignedObjectArray m_phases; // each phase is range of indices in the m_batches array + btAlignedObjectArray m_phaseGrainSize; // max grain size for each phase + btAlignedObjectArray m_phaseOrder; // phases can be done in any order, so we can randomize the order here + btIDebugDraw* m_debugDrawer; + + static bool s_debugDrawBatches; + + btBatchedConstraints() { m_debugDrawer = NULL; } + void setup(btConstraintArray* constraints, + const btAlignedObjectArray& bodies, + BatchingMethod batchingMethod, + int minBatchSize, + int maxBatchSize, + btAlignedObjectArray* scratchMemory); + bool validate(btConstraintArray* constraints, const btAlignedObjectArray& bodies) const; +}; + +#endif // BT_BATCHED_CONSTRAINTS_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.h.i new file mode 100644 index 00000000..bcab5c5d --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btBatchedConstraints.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btBatchedConstraints.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btBatchedConstraints.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btBatchedConstraints.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp new file mode 100644 index 00000000..ac046aa6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp @@ -0,0 +1,1116 @@ +/* +Bullet Continuous Collision Detection and Physics Library +btConeTwistConstraint is Copyright (c) 2007 Starbreeze Studios + +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. + +Written by: Marcus Hennix +*/ + +#include "btConeTwistConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btTransformUtil.h" +#include "LinearMath/btMinMax.h" +#include +#include + +//#define CONETWIST_USE_OBSOLETE_SOLVER true +#define CONETWIST_USE_OBSOLETE_SOLVER false +#define CONETWIST_DEF_FIX_THRESH btScalar(.05f) + +SIMD_FORCE_INLINE btScalar computeAngularImpulseDenominator(const btVector3& axis, const btMatrix3x3& invInertiaWorld) +{ + btVector3 vec = axis * invInertiaWorld; + return axis.dot(vec); +} + +btConeTwistConstraint::btConeTwistConstraint(btRigidBody& rbA, btRigidBody& rbB, + const btTransform& rbAFrame, const btTransform& rbBFrame) + : btTypedConstraint(CONETWIST_CONSTRAINT_TYPE, rbA, rbB), m_rbAFrame(rbAFrame), m_rbBFrame(rbBFrame), m_angularOnly(false), m_useSolveConstraintObsolete(CONETWIST_USE_OBSOLETE_SOLVER) +{ + init(); +} + +btConeTwistConstraint::btConeTwistConstraint(btRigidBody& rbA, const btTransform& rbAFrame) + : btTypedConstraint(CONETWIST_CONSTRAINT_TYPE, rbA), m_rbAFrame(rbAFrame), m_angularOnly(false), m_useSolveConstraintObsolete(CONETWIST_USE_OBSOLETE_SOLVER) +{ + m_rbBFrame = m_rbAFrame; + m_rbBFrame.setOrigin(btVector3(0., 0., 0.)); + init(); +} + +void btConeTwistConstraint::init() +{ + m_angularOnly = false; + m_solveTwistLimit = false; + m_solveSwingLimit = false; + m_bMotorEnabled = false; + m_maxMotorImpulse = btScalar(-1); + + setLimit(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT)); + m_damping = btScalar(0.01); + m_fixThresh = CONETWIST_DEF_FIX_THRESH; + m_flags = 0; + m_linCFM = btScalar(0.f); + m_linERP = btScalar(0.7f); + m_angCFM = btScalar(0.f); +} + +void btConeTwistConstraint::getInfo1(btConstraintInfo1* info) +{ + if (m_useSolveConstraintObsolete) + { + info->m_numConstraintRows = 0; + info->nub = 0; + } + else + { + info->m_numConstraintRows = 3; + info->nub = 3; + calcAngleInfo2(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getInvInertiaTensorWorld(), m_rbB.getInvInertiaTensorWorld()); + if (m_solveSwingLimit) + { + info->m_numConstraintRows++; + info->nub--; + if ((m_swingSpan1 < m_fixThresh) && (m_swingSpan2 < m_fixThresh)) + { + info->m_numConstraintRows++; + info->nub--; + } + } + if (m_solveTwistLimit) + { + info->m_numConstraintRows++; + info->nub--; + } + } +} + +void btConeTwistConstraint::getInfo1NonVirtual(btConstraintInfo1* info) +{ + //always reserve 6 rows: object transform is not available on SPU + info->m_numConstraintRows = 6; + info->nub = 0; +} + +void btConeTwistConstraint::getInfo2(btConstraintInfo2* info) +{ + getInfo2NonVirtual(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getInvInertiaTensorWorld(), m_rbB.getInvInertiaTensorWorld()); +} + +void btConeTwistConstraint::getInfo2NonVirtual(btConstraintInfo2* info, const btTransform& transA, const btTransform& transB, const btMatrix3x3& invInertiaWorldA, const btMatrix3x3& invInertiaWorldB) +{ + calcAngleInfo2(transA, transB, invInertiaWorldA, invInertiaWorldB); + + btAssert(!m_useSolveConstraintObsolete); + // set jacobian + info->m_J1linearAxis[0] = 1; + info->m_J1linearAxis[info->rowskip + 1] = 1; + info->m_J1linearAxis[2 * info->rowskip + 2] = 1; + btVector3 a1 = transA.getBasis() * m_rbAFrame.getOrigin(); + { + btVector3* angular0 = (btVector3*)(info->m_J1angularAxis); + btVector3* angular1 = (btVector3*)(info->m_J1angularAxis + info->rowskip); + btVector3* angular2 = (btVector3*)(info->m_J1angularAxis + 2 * info->rowskip); + btVector3 a1neg = -a1; + a1neg.getSkewSymmetricMatrix(angular0, angular1, angular2); + } + info->m_J2linearAxis[0] = -1; + info->m_J2linearAxis[info->rowskip + 1] = -1; + info->m_J2linearAxis[2 * info->rowskip + 2] = -1; + btVector3 a2 = transB.getBasis() * m_rbBFrame.getOrigin(); + { + btVector3* angular0 = (btVector3*)(info->m_J2angularAxis); + btVector3* angular1 = (btVector3*)(info->m_J2angularAxis + info->rowskip); + btVector3* angular2 = (btVector3*)(info->m_J2angularAxis + 2 * info->rowskip); + a2.getSkewSymmetricMatrix(angular0, angular1, angular2); + } + // set right hand side + btScalar linERP = (m_flags & BT_CONETWIST_FLAGS_LIN_ERP) ? m_linERP : info->erp; + btScalar k = info->fps * linERP; + int j; + for (j = 0; j < 3; j++) + { + info->m_constraintError[j * info->rowskip] = k * (a2[j] + transB.getOrigin()[j] - a1[j] - transA.getOrigin()[j]); + info->m_lowerLimit[j * info->rowskip] = -SIMD_INFINITY; + info->m_upperLimit[j * info->rowskip] = SIMD_INFINITY; + if (m_flags & BT_CONETWIST_FLAGS_LIN_CFM) + { + info->cfm[j * info->rowskip] = m_linCFM; + } + } + int row = 3; + int srow = row * info->rowskip; + btVector3 ax1; + // angular limits + if (m_solveSwingLimit) + { + btScalar* J1 = info->m_J1angularAxis; + btScalar* J2 = info->m_J2angularAxis; + if ((m_swingSpan1 < m_fixThresh) && (m_swingSpan2 < m_fixThresh)) + { + btTransform trA = transA * m_rbAFrame; + btVector3 p = trA.getBasis().getColumn(1); + btVector3 q = trA.getBasis().getColumn(2); + int srow1 = srow + info->rowskip; + J1[srow + 0] = p[0]; + J1[srow + 1] = p[1]; + J1[srow + 2] = p[2]; + J1[srow1 + 0] = q[0]; + J1[srow1 + 1] = q[1]; + J1[srow1 + 2] = q[2]; + J2[srow + 0] = -p[0]; + J2[srow + 1] = -p[1]; + J2[srow + 2] = -p[2]; + J2[srow1 + 0] = -q[0]; + J2[srow1 + 1] = -q[1]; + J2[srow1 + 2] = -q[2]; + btScalar fact = info->fps * m_relaxationFactor; + info->m_constraintError[srow] = fact * m_swingAxis.dot(p); + info->m_constraintError[srow1] = fact * m_swingAxis.dot(q); + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = SIMD_INFINITY; + info->m_lowerLimit[srow1] = -SIMD_INFINITY; + info->m_upperLimit[srow1] = SIMD_INFINITY; + srow = srow1 + info->rowskip; + } + else + { + ax1 = m_swingAxis * m_relaxationFactor * m_relaxationFactor; + J1[srow + 0] = ax1[0]; + J1[srow + 1] = ax1[1]; + J1[srow + 2] = ax1[2]; + J2[srow + 0] = -ax1[0]; + J2[srow + 1] = -ax1[1]; + J2[srow + 2] = -ax1[2]; + btScalar k = info->fps * m_biasFactor; + + info->m_constraintError[srow] = k * m_swingCorrection; + if (m_flags & BT_CONETWIST_FLAGS_ANG_CFM) + { + info->cfm[srow] = m_angCFM; + } + // m_swingCorrection is always positive or 0 + info->m_lowerLimit[srow] = 0; + info->m_upperLimit[srow] = (m_bMotorEnabled && m_maxMotorImpulse >= 0.0f) ? m_maxMotorImpulse : SIMD_INFINITY; + srow += info->rowskip; + } + } + if (m_solveTwistLimit) + { + ax1 = m_twistAxis * m_relaxationFactor * m_relaxationFactor; + btScalar* J1 = info->m_J1angularAxis; + btScalar* J2 = info->m_J2angularAxis; + J1[srow + 0] = ax1[0]; + J1[srow + 1] = ax1[1]; + J1[srow + 2] = ax1[2]; + J2[srow + 0] = -ax1[0]; + J2[srow + 1] = -ax1[1]; + J2[srow + 2] = -ax1[2]; + btScalar k = info->fps * m_biasFactor; + info->m_constraintError[srow] = k * m_twistCorrection; + if (m_flags & BT_CONETWIST_FLAGS_ANG_CFM) + { + info->cfm[srow] = m_angCFM; + } + if (m_twistSpan > 0.0f) + { + if (m_twistCorrection > 0.0f) + { + info->m_lowerLimit[srow] = 0; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + else + { + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = 0; + } + } + else + { + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + srow += info->rowskip; + } +} + +void btConeTwistConstraint::buildJacobian() +{ + if (m_useSolveConstraintObsolete) + { + m_appliedImpulse = btScalar(0.); + m_accTwistLimitImpulse = btScalar(0.); + m_accSwingLimitImpulse = btScalar(0.); + m_accMotorImpulse = btVector3(0., 0., 0.); + + if (!m_angularOnly) + { + btVector3 pivotAInW = m_rbA.getCenterOfMassTransform() * m_rbAFrame.getOrigin(); + btVector3 pivotBInW = m_rbB.getCenterOfMassTransform() * m_rbBFrame.getOrigin(); + btVector3 relPos = pivotBInW - pivotAInW; + + btVector3 normal[3]; + if (relPos.length2() > SIMD_EPSILON) + { + normal[0] = relPos.normalized(); + } + else + { + normal[0].setValue(btScalar(1.0), 0, 0); + } + + btPlaneSpace1(normal[0], normal[1], normal[2]); + + for (int i = 0; i < 3; i++) + { + new (&m_jac[i]) btJacobianEntry( + m_rbA.getCenterOfMassTransform().getBasis().transpose(), + m_rbB.getCenterOfMassTransform().getBasis().transpose(), + pivotAInW - m_rbA.getCenterOfMassPosition(), + pivotBInW - m_rbB.getCenterOfMassPosition(), + normal[i], + m_rbA.getInvInertiaDiagLocal(), + m_rbA.getInvMass(), + m_rbB.getInvInertiaDiagLocal(), + m_rbB.getInvMass()); + } + } + + calcAngleInfo2(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getInvInertiaTensorWorld(), m_rbB.getInvInertiaTensorWorld()); + } +} + +void btConeTwistConstraint::solveConstraintObsolete(btSolverBody& bodyA, btSolverBody& bodyB, btScalar timeStep) +{ +#ifndef __SPU__ + if (m_useSolveConstraintObsolete) + { + btVector3 pivotAInW = m_rbA.getCenterOfMassTransform() * m_rbAFrame.getOrigin(); + btVector3 pivotBInW = m_rbB.getCenterOfMassTransform() * m_rbBFrame.getOrigin(); + + btScalar tau = btScalar(0.3); + + //linear part + if (!m_angularOnly) + { + btVector3 rel_pos1 = pivotAInW - m_rbA.getCenterOfMassPosition(); + btVector3 rel_pos2 = pivotBInW - m_rbB.getCenterOfMassPosition(); + + btVector3 vel1; + bodyA.internalGetVelocityInLocalPointObsolete(rel_pos1, vel1); + btVector3 vel2; + bodyB.internalGetVelocityInLocalPointObsolete(rel_pos2, vel2); + btVector3 vel = vel1 - vel2; + + for (int i = 0; i < 3; i++) + { + const btVector3& normal = m_jac[i].m_linearJointAxis; + btScalar jacDiagABInv = btScalar(1.) / m_jac[i].getDiagonal(); + + btScalar rel_vel; + rel_vel = normal.dot(vel); + //positional error (zeroth order error) + btScalar depth = -(pivotAInW - pivotBInW).dot(normal); //this is the error projected on the normal + btScalar impulse = depth * tau / timeStep * jacDiagABInv - rel_vel * jacDiagABInv; + m_appliedImpulse += impulse; + + btVector3 ftorqueAxis1 = rel_pos1.cross(normal); + btVector3 ftorqueAxis2 = rel_pos2.cross(normal); + bodyA.internalApplyImpulse(normal * m_rbA.getInvMass(), m_rbA.getInvInertiaTensorWorld() * ftorqueAxis1, impulse); + bodyB.internalApplyImpulse(normal * m_rbB.getInvMass(), m_rbB.getInvInertiaTensorWorld() * ftorqueAxis2, -impulse); + } + } + + // apply motor + if (m_bMotorEnabled) + { + // compute current and predicted transforms + btTransform trACur = m_rbA.getCenterOfMassTransform(); + btTransform trBCur = m_rbB.getCenterOfMassTransform(); + btVector3 omegaA; + bodyA.internalGetAngularVelocity(omegaA); + btVector3 omegaB; + bodyB.internalGetAngularVelocity(omegaB); + btTransform trAPred; + trAPred.setIdentity(); + btVector3 zerovec(0, 0, 0); + btTransformUtil::integrateTransform( + trACur, zerovec, omegaA, timeStep, trAPred); + btTransform trBPred; + trBPred.setIdentity(); + btTransformUtil::integrateTransform( + trBCur, zerovec, omegaB, timeStep, trBPred); + + // compute desired transforms in world + btTransform trPose(m_qTarget); + btTransform trABDes = m_rbBFrame * trPose * m_rbAFrame.inverse(); + btTransform trADes = trBPred * trABDes; + btTransform trBDes = trAPred * trABDes.inverse(); + + // compute desired omegas in world + btVector3 omegaADes, omegaBDes; + + btTransformUtil::calculateVelocity(trACur, trADes, timeStep, zerovec, omegaADes); + btTransformUtil::calculateVelocity(trBCur, trBDes, timeStep, zerovec, omegaBDes); + + // compute delta omegas + btVector3 dOmegaA = omegaADes - omegaA; + btVector3 dOmegaB = omegaBDes - omegaB; + + // compute weighted avg axis of dOmega (weighting based on inertias) + btVector3 axisA, axisB; + btScalar kAxisAInv = 0, kAxisBInv = 0; + + if (dOmegaA.length2() > SIMD_EPSILON) + { + axisA = dOmegaA.normalized(); + kAxisAInv = getRigidBodyA().computeAngularImpulseDenominator(axisA); + } + + if (dOmegaB.length2() > SIMD_EPSILON) + { + axisB = dOmegaB.normalized(); + kAxisBInv = getRigidBodyB().computeAngularImpulseDenominator(axisB); + } + + btVector3 avgAxis = kAxisAInv * axisA + kAxisBInv * axisB; + + static bool bDoTorque = true; + if (bDoTorque && avgAxis.length2() > SIMD_EPSILON) + { + avgAxis.normalize(); + kAxisAInv = getRigidBodyA().computeAngularImpulseDenominator(avgAxis); + kAxisBInv = getRigidBodyB().computeAngularImpulseDenominator(avgAxis); + btScalar kInvCombined = kAxisAInv + kAxisBInv; + + btVector3 impulse = (kAxisAInv * dOmegaA - kAxisBInv * dOmegaB) / + (kInvCombined * kInvCombined); + + if (m_maxMotorImpulse >= 0) + { + btScalar fMaxImpulse = m_maxMotorImpulse; + if (m_bNormalizedMotorStrength) + fMaxImpulse = fMaxImpulse / kAxisAInv; + + btVector3 newUnclampedAccImpulse = m_accMotorImpulse + impulse; + btScalar newUnclampedMag = newUnclampedAccImpulse.length(); + if (newUnclampedMag > fMaxImpulse) + { + newUnclampedAccImpulse.normalize(); + newUnclampedAccImpulse *= fMaxImpulse; + impulse = newUnclampedAccImpulse - m_accMotorImpulse; + } + m_accMotorImpulse += impulse; + } + + btScalar impulseMag = impulse.length(); + btVector3 impulseAxis = impulse / impulseMag; + + bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.getInvInertiaTensorWorld() * impulseAxis, impulseMag); + bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.getInvInertiaTensorWorld() * impulseAxis, -impulseMag); + } + } + else if (m_damping > SIMD_EPSILON) // no motor: do a little damping + { + btVector3 angVelA; + bodyA.internalGetAngularVelocity(angVelA); + btVector3 angVelB; + bodyB.internalGetAngularVelocity(angVelB); + btVector3 relVel = angVelB - angVelA; + if (relVel.length2() > SIMD_EPSILON) + { + btVector3 relVelAxis = relVel.normalized(); + btScalar m_kDamping = btScalar(1.) / + (getRigidBodyA().computeAngularImpulseDenominator(relVelAxis) + + getRigidBodyB().computeAngularImpulseDenominator(relVelAxis)); + btVector3 impulse = m_damping * m_kDamping * relVel; + + btScalar impulseMag = impulse.length(); + btVector3 impulseAxis = impulse / impulseMag; + bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.getInvInertiaTensorWorld() * impulseAxis, impulseMag); + bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.getInvInertiaTensorWorld() * impulseAxis, -impulseMag); + } + } + + // joint limits + { + ///solve angular part + btVector3 angVelA; + bodyA.internalGetAngularVelocity(angVelA); + btVector3 angVelB; + bodyB.internalGetAngularVelocity(angVelB); + + // solve swing limit + if (m_solveSwingLimit) + { + btScalar amplitude = m_swingLimitRatio * m_swingCorrection * m_biasFactor / timeStep; + btScalar relSwingVel = (angVelB - angVelA).dot(m_swingAxis); + if (relSwingVel > 0) + amplitude += m_swingLimitRatio * relSwingVel * m_relaxationFactor; + btScalar impulseMag = amplitude * m_kSwing; + + // Clamp the accumulated impulse + btScalar temp = m_accSwingLimitImpulse; + m_accSwingLimitImpulse = btMax(m_accSwingLimitImpulse + impulseMag, btScalar(0.0)); + impulseMag = m_accSwingLimitImpulse - temp; + + btVector3 impulse = m_swingAxis * impulseMag; + + // don't let cone response affect twist + // (this can happen since body A's twist doesn't match body B's AND we use an elliptical cone limit) + { + btVector3 impulseTwistCouple = impulse.dot(m_twistAxisA) * m_twistAxisA; + btVector3 impulseNoTwistCouple = impulse - impulseTwistCouple; + impulse = impulseNoTwistCouple; + } + + impulseMag = impulse.length(); + btVector3 noTwistSwingAxis = impulse / impulseMag; + + bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.getInvInertiaTensorWorld() * noTwistSwingAxis, impulseMag); + bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.getInvInertiaTensorWorld() * noTwistSwingAxis, -impulseMag); + } + + // solve twist limit + if (m_solveTwistLimit) + { + btScalar amplitude = m_twistLimitRatio * m_twistCorrection * m_biasFactor / timeStep; + btScalar relTwistVel = (angVelB - angVelA).dot(m_twistAxis); + if (relTwistVel > 0) // only damp when moving towards limit (m_twistAxis flipping is important) + amplitude += m_twistLimitRatio * relTwistVel * m_relaxationFactor; + btScalar impulseMag = amplitude * m_kTwist; + + // Clamp the accumulated impulse + btScalar temp = m_accTwistLimitImpulse; + m_accTwistLimitImpulse = btMax(m_accTwistLimitImpulse + impulseMag, btScalar(0.0)); + impulseMag = m_accTwistLimitImpulse - temp; + + // btVector3 impulse = m_twistAxis * impulseMag; + + bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.getInvInertiaTensorWorld() * m_twistAxis, impulseMag); + bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.getInvInertiaTensorWorld() * m_twistAxis, -impulseMag); + } + } + } +#else + btAssert(0); +#endif //__SPU__ +} + +void btConeTwistConstraint::updateRHS(btScalar timeStep) +{ + (void)timeStep; +} + +#ifndef __SPU__ +void btConeTwistConstraint::calcAngleInfo() +{ + m_swingCorrection = btScalar(0.); + m_twistLimitSign = btScalar(0.); + m_solveTwistLimit = false; + m_solveSwingLimit = false; + + btVector3 b1Axis1(0, 0, 0), b1Axis2(0, 0, 0), b1Axis3(0, 0, 0); + btVector3 b2Axis1(0, 0, 0), b2Axis2(0, 0, 0); + + b1Axis1 = getRigidBodyA().getCenterOfMassTransform().getBasis() * this->m_rbAFrame.getBasis().getColumn(0); + b2Axis1 = getRigidBodyB().getCenterOfMassTransform().getBasis() * this->m_rbBFrame.getBasis().getColumn(0); + + btScalar swing1 = btScalar(0.), swing2 = btScalar(0.); + + btScalar swx = btScalar(0.), swy = btScalar(0.); + btScalar thresh = btScalar(10.); + btScalar fact; + + // Get Frame into world space + if (m_swingSpan1 >= btScalar(0.05f)) + { + b1Axis2 = getRigidBodyA().getCenterOfMassTransform().getBasis() * this->m_rbAFrame.getBasis().getColumn(1); + swx = b2Axis1.dot(b1Axis1); + swy = b2Axis1.dot(b1Axis2); + swing1 = btAtan2Fast(swy, swx); + fact = (swy * swy + swx * swx) * thresh * thresh; + fact = fact / (fact + btScalar(1.0)); + swing1 *= fact; + } + + if (m_swingSpan2 >= btScalar(0.05f)) + { + b1Axis3 = getRigidBodyA().getCenterOfMassTransform().getBasis() * this->m_rbAFrame.getBasis().getColumn(2); + swx = b2Axis1.dot(b1Axis1); + swy = b2Axis1.dot(b1Axis3); + swing2 = btAtan2Fast(swy, swx); + fact = (swy * swy + swx * swx) * thresh * thresh; + fact = fact / (fact + btScalar(1.0)); + swing2 *= fact; + } + + btScalar RMaxAngle1Sq = 1.0f / (m_swingSpan1 * m_swingSpan1); + btScalar RMaxAngle2Sq = 1.0f / (m_swingSpan2 * m_swingSpan2); + btScalar EllipseAngle = btFabs(swing1 * swing1) * RMaxAngle1Sq + btFabs(swing2 * swing2) * RMaxAngle2Sq; + + if (EllipseAngle > 1.0f) + { + m_swingCorrection = EllipseAngle - 1.0f; + m_solveSwingLimit = true; + // Calculate necessary axis & factors + m_swingAxis = b2Axis1.cross(b1Axis2 * b2Axis1.dot(b1Axis2) + b1Axis3 * b2Axis1.dot(b1Axis3)); + m_swingAxis.normalize(); + btScalar swingAxisSign = (b2Axis1.dot(b1Axis1) >= 0.0f) ? 1.0f : -1.0f; + m_swingAxis *= swingAxisSign; + } + + // Twist limits + if (m_twistSpan >= btScalar(0.)) + { + btVector3 b2Axis2 = getRigidBodyB().getCenterOfMassTransform().getBasis() * this->m_rbBFrame.getBasis().getColumn(1); + btQuaternion rotationArc = shortestArcQuat(b2Axis1, b1Axis1); + btVector3 TwistRef = quatRotate(rotationArc, b2Axis2); + btScalar twist = btAtan2Fast(TwistRef.dot(b1Axis3), TwistRef.dot(b1Axis2)); + m_twistAngle = twist; + + // btScalar lockedFreeFactor = (m_twistSpan > btScalar(0.05f)) ? m_limitSoftness : btScalar(0.); + btScalar lockedFreeFactor = (m_twistSpan > btScalar(0.05f)) ? btScalar(1.0f) : btScalar(0.); + if (twist <= -m_twistSpan * lockedFreeFactor) + { + m_twistCorrection = -(twist + m_twistSpan); + m_solveTwistLimit = true; + m_twistAxis = (b2Axis1 + b1Axis1) * 0.5f; + m_twistAxis.normalize(); + m_twistAxis *= -1.0f; + } + else if (twist > m_twistSpan * lockedFreeFactor) + { + m_twistCorrection = (twist - m_twistSpan); + m_solveTwistLimit = true; + m_twistAxis = (b2Axis1 + b1Axis1) * 0.5f; + m_twistAxis.normalize(); + } + } +} +#endif //__SPU__ + +static btVector3 vTwist(1, 0, 0); // twist axis in constraint's space + +void btConeTwistConstraint::calcAngleInfo2(const btTransform& transA, const btTransform& transB, const btMatrix3x3& invInertiaWorldA, const btMatrix3x3& invInertiaWorldB) +{ + m_swingCorrection = btScalar(0.); + m_twistLimitSign = btScalar(0.); + m_solveTwistLimit = false; + m_solveSwingLimit = false; + // compute rotation of A wrt B (in constraint space) + if (m_bMotorEnabled && (!m_useSolveConstraintObsolete)) + { // it is assumed that setMotorTarget() was alredy called + // and motor target m_qTarget is within constraint limits + // TODO : split rotation to pure swing and pure twist + // compute desired transforms in world + btTransform trPose(m_qTarget); + btTransform trA = transA * m_rbAFrame; + btTransform trB = transB * m_rbBFrame; + btTransform trDeltaAB = trB * trPose * trA.inverse(); + btQuaternion qDeltaAB = trDeltaAB.getRotation(); + btVector3 swingAxis = btVector3(qDeltaAB.x(), qDeltaAB.y(), qDeltaAB.z()); + btScalar swingAxisLen2 = swingAxis.length2(); + if (btFuzzyZero(swingAxisLen2)) + { + return; + } + m_swingAxis = swingAxis; + m_swingAxis.normalize(); + m_swingCorrection = qDeltaAB.getAngle(); + if (!btFuzzyZero(m_swingCorrection)) + { + m_solveSwingLimit = true; + } + return; + } + + { + // compute rotation of A wrt B (in constraint space) + btQuaternion qA = transA.getRotation() * m_rbAFrame.getRotation(); + btQuaternion qB = transB.getRotation() * m_rbBFrame.getRotation(); + btQuaternion qAB = qB.inverse() * qA; + // split rotation into cone and twist + // (all this is done from B's perspective. Maybe I should be averaging axes...) + btVector3 vConeNoTwist = quatRotate(qAB, vTwist); + vConeNoTwist.normalize(); + btQuaternion qABCone = shortestArcQuat(vTwist, vConeNoTwist); + qABCone.normalize(); + btQuaternion qABTwist = qABCone.inverse() * qAB; + qABTwist.normalize(); + + if (m_swingSpan1 >= m_fixThresh && m_swingSpan2 >= m_fixThresh) + { + btScalar swingAngle, swingLimit = 0; + btVector3 swingAxis; + computeConeLimitInfo(qABCone, swingAngle, swingAxis, swingLimit); + + if (swingAngle > swingLimit * m_limitSoftness) + { + m_solveSwingLimit = true; + + // compute limit ratio: 0->1, where + // 0 == beginning of soft limit + // 1 == hard/real limit + m_swingLimitRatio = 1.f; + if (swingAngle < swingLimit && m_limitSoftness < 1.f - SIMD_EPSILON) + { + m_swingLimitRatio = (swingAngle - swingLimit * m_limitSoftness) / + (swingLimit - swingLimit * m_limitSoftness); + } + + // swing correction tries to get back to soft limit + m_swingCorrection = swingAngle - (swingLimit * m_limitSoftness); + + // adjustment of swing axis (based on ellipse normal) + adjustSwingAxisToUseEllipseNormal(swingAxis); + + // Calculate necessary axis & factors + m_swingAxis = quatRotate(qB, -swingAxis); + + m_twistAxisA.setValue(0, 0, 0); + + m_kSwing = btScalar(1.) / + (computeAngularImpulseDenominator(m_swingAxis, invInertiaWorldA) + + computeAngularImpulseDenominator(m_swingAxis, invInertiaWorldB)); + } + } + else + { + // you haven't set any limits; + // or you're trying to set at least one of the swing limits too small. (if so, do you really want a conetwist constraint?) + // anyway, we have either hinge or fixed joint + btVector3 ivA = transA.getBasis() * m_rbAFrame.getBasis().getColumn(0); + btVector3 jvA = transA.getBasis() * m_rbAFrame.getBasis().getColumn(1); + btVector3 kvA = transA.getBasis() * m_rbAFrame.getBasis().getColumn(2); + btVector3 ivB = transB.getBasis() * m_rbBFrame.getBasis().getColumn(0); + btVector3 target; + btScalar x = ivB.dot(ivA); + btScalar y = ivB.dot(jvA); + btScalar z = ivB.dot(kvA); + if ((m_swingSpan1 < m_fixThresh) && (m_swingSpan2 < m_fixThresh)) + { // fixed. We'll need to add one more row to constraint + if ((!btFuzzyZero(y)) || (!(btFuzzyZero(z)))) + { + m_solveSwingLimit = true; + m_swingAxis = -ivB.cross(ivA); + } + } + else + { + if (m_swingSpan1 < m_fixThresh) + { // hinge around Y axis + // if(!(btFuzzyZero(y))) + if ((!(btFuzzyZero(x))) || (!(btFuzzyZero(z)))) + { + m_solveSwingLimit = true; + if (m_swingSpan2 >= m_fixThresh) + { + y = btScalar(0.f); + btScalar span2 = btAtan2(z, x); + if (span2 > m_swingSpan2) + { + x = btCos(m_swingSpan2); + z = btSin(m_swingSpan2); + } + else if (span2 < -m_swingSpan2) + { + x = btCos(m_swingSpan2); + z = -btSin(m_swingSpan2); + } + } + } + } + else + { // hinge around Z axis + // if(!btFuzzyZero(z)) + if ((!(btFuzzyZero(x))) || (!(btFuzzyZero(y)))) + { + m_solveSwingLimit = true; + if (m_swingSpan1 >= m_fixThresh) + { + z = btScalar(0.f); + btScalar span1 = btAtan2(y, x); + if (span1 > m_swingSpan1) + { + x = btCos(m_swingSpan1); + y = btSin(m_swingSpan1); + } + else if (span1 < -m_swingSpan1) + { + x = btCos(m_swingSpan1); + y = -btSin(m_swingSpan1); + } + } + } + } + target[0] = x * ivA[0] + y * jvA[0] + z * kvA[0]; + target[1] = x * ivA[1] + y * jvA[1] + z * kvA[1]; + target[2] = x * ivA[2] + y * jvA[2] + z * kvA[2]; + target.normalize(); + m_swingAxis = -ivB.cross(target); + m_swingCorrection = m_swingAxis.length(); + + if (!btFuzzyZero(m_swingCorrection)) + m_swingAxis.normalize(); + } + } + + if (m_twistSpan >= btScalar(0.f)) + { + btVector3 twistAxis; + computeTwistLimitInfo(qABTwist, m_twistAngle, twistAxis); + + if (m_twistAngle > m_twistSpan * m_limitSoftness) + { + m_solveTwistLimit = true; + + m_twistLimitRatio = 1.f; + if (m_twistAngle < m_twistSpan && m_limitSoftness < 1.f - SIMD_EPSILON) + { + m_twistLimitRatio = (m_twistAngle - m_twistSpan * m_limitSoftness) / + (m_twistSpan - m_twistSpan * m_limitSoftness); + } + + // twist correction tries to get back to soft limit + m_twistCorrection = m_twistAngle - (m_twistSpan * m_limitSoftness); + + m_twistAxis = quatRotate(qB, -twistAxis); + + m_kTwist = btScalar(1.) / + (computeAngularImpulseDenominator(m_twistAxis, invInertiaWorldA) + + computeAngularImpulseDenominator(m_twistAxis, invInertiaWorldB)); + } + + if (m_solveSwingLimit) + m_twistAxisA = quatRotate(qA, -twistAxis); + } + else + { + m_twistAngle = btScalar(0.f); + } + } +} + +// given a cone rotation in constraint space, (pre: twist must already be removed) +// this method computes its corresponding swing angle and axis. +// more interestingly, it computes the cone/swing limit (angle) for this cone "pose". +void btConeTwistConstraint::computeConeLimitInfo(const btQuaternion& qCone, + btScalar& swingAngle, // out + btVector3& vSwingAxis, // out + btScalar& swingLimit) // out +{ + swingAngle = qCone.getAngle(); + if (swingAngle > SIMD_EPSILON) + { + vSwingAxis = btVector3(qCone.x(), qCone.y(), qCone.z()); + vSwingAxis.normalize(); +#if 0 + // non-zero twist?! this should never happen. + btAssert(fabs(vSwingAxis.x()) <= SIMD_EPSILON)); +#endif + + // Compute limit for given swing. tricky: + // Given a swing axis, we're looking for the intersection with the bounding cone ellipse. + // (Since we're dealing with angles, this ellipse is embedded on the surface of a sphere.) + + // For starters, compute the direction from center to surface of ellipse. + // This is just the perpendicular (ie. rotate 2D vector by PI/2) of the swing axis. + // (vSwingAxis is the cone rotation (in z,y); change vars and rotate to (x,y) coords.) + btScalar xEllipse = vSwingAxis.y(); + btScalar yEllipse = -vSwingAxis.z(); + + // Now, we use the slope of the vector (using x/yEllipse) and find the length + // of the line that intersects the ellipse: + // x^2 y^2 + // --- + --- = 1, where a and b are semi-major axes 2 and 1 respectively (ie. the limits) + // a^2 b^2 + // Do the math and it should be clear. + + swingLimit = m_swingSpan1; // if xEllipse == 0, we have a pure vSwingAxis.z rotation: just use swingspan1 + if (fabs(xEllipse) > SIMD_EPSILON) + { + btScalar surfaceSlope2 = (yEllipse * yEllipse) / (xEllipse * xEllipse); + btScalar norm = 1 / (m_swingSpan2 * m_swingSpan2); + norm += surfaceSlope2 / (m_swingSpan1 * m_swingSpan1); + btScalar swingLimit2 = (1 + surfaceSlope2) / norm; + swingLimit = std::sqrt(swingLimit2); + } + + // test! + /*swingLimit = m_swingSpan2; + if (fabs(vSwingAxis.z()) > SIMD_EPSILON) + { + btScalar mag_2 = m_swingSpan1*m_swingSpan1 + m_swingSpan2*m_swingSpan2; + btScalar sinphi = m_swingSpan2 / sqrt(mag_2); + btScalar phi = asin(sinphi); + btScalar theta = atan2(fabs(vSwingAxis.y()),fabs(vSwingAxis.z())); + btScalar alpha = 3.14159f - theta - phi; + btScalar sinalpha = sin(alpha); + swingLimit = m_swingSpan1 * sinphi/sinalpha; + }*/ + } + else if (swingAngle < 0) + { + // this should never happen! +#if 0 + btAssert(0); +#endif + } +} + +btVector3 btConeTwistConstraint::GetPointForAngle(btScalar fAngleInRadians, btScalar fLength) const +{ + // compute x/y in ellipse using cone angle (0 -> 2*PI along surface of cone) + btScalar xEllipse = btCos(fAngleInRadians); + btScalar yEllipse = btSin(fAngleInRadians); + + // Use the slope of the vector (using x/yEllipse) and find the length + // of the line that intersects the ellipse: + // x^2 y^2 + // --- + --- = 1, where a and b are semi-major axes 2 and 1 respectively (ie. the limits) + // a^2 b^2 + // Do the math and it should be clear. + + btScalar swingLimit = m_swingSpan1; // if xEllipse == 0, just use axis b (1) + if (fabs(xEllipse) > SIMD_EPSILON) + { + btScalar surfaceSlope2 = (yEllipse * yEllipse) / (xEllipse * xEllipse); + btScalar norm = 1 / (m_swingSpan2 * m_swingSpan2); + norm += surfaceSlope2 / (m_swingSpan1 * m_swingSpan1); + btScalar swingLimit2 = (1 + surfaceSlope2) / norm; + swingLimit = std::sqrt(swingLimit2); + } + + // convert into point in constraint space: + // note: twist is x-axis, swing 1 and 2 are along the z and y axes respectively + btVector3 vSwingAxis(0, xEllipse, -yEllipse); + btQuaternion qSwing(vSwingAxis, swingLimit); + btVector3 vPointInConstraintSpace(fLength, 0, 0); + return quatRotate(qSwing, vPointInConstraintSpace); +} + +// given a twist rotation in constraint space, (pre: cone must already be removed) +// this method computes its corresponding angle and axis. +void btConeTwistConstraint::computeTwistLimitInfo(const btQuaternion& qTwist, + btScalar& twistAngle, // out + btVector3& vTwistAxis) // out +{ + btQuaternion qMinTwist = qTwist; + twistAngle = qTwist.getAngle(); + + if (twistAngle > SIMD_PI) // long way around. flip quat and recalculate. + { + qMinTwist = -(qTwist); + twistAngle = qMinTwist.getAngle(); + } + if (twistAngle < 0) + { + // this should never happen +#if 0 + btAssert(0); +#endif + } + + vTwistAxis = btVector3(qMinTwist.x(), qMinTwist.y(), qMinTwist.z()); + if (twistAngle > SIMD_EPSILON) + vTwistAxis.normalize(); +} + +void btConeTwistConstraint::adjustSwingAxisToUseEllipseNormal(btVector3& vSwingAxis) const +{ + // the swing axis is computed as the "twist-free" cone rotation, + // but the cone limit is not circular, but elliptical (if swingspan1 != swingspan2). + // so, if we're outside the limits, the closest way back inside the cone isn't + // along the vector back to the center. better (and more stable) to use the ellipse normal. + + // convert swing axis to direction from center to surface of ellipse + // (ie. rotate 2D vector by PI/2) + btScalar y = -vSwingAxis.z(); + btScalar z = vSwingAxis.y(); + + // do the math... + if (fabs(z) > SIMD_EPSILON) // avoid division by 0. and we don't need an update if z == 0. + { + // compute gradient/normal of ellipse surface at current "point" + btScalar grad = y / z; + grad *= m_swingSpan2 / m_swingSpan1; + + // adjust y/z to represent normal at point (instead of vector to point) + if (y > 0) + y = fabs(grad * z); + else + y = -fabs(grad * z); + + // convert ellipse direction back to swing axis + vSwingAxis.setZ(-y); + vSwingAxis.setY(z); + vSwingAxis.normalize(); + } +} + +void btConeTwistConstraint::setMotorTarget(const btQuaternion& q) +{ + //btTransform trACur = m_rbA.getCenterOfMassTransform(); + //btTransform trBCur = m_rbB.getCenterOfMassTransform(); + // btTransform trABCur = trBCur.inverse() * trACur; + // btQuaternion qABCur = trABCur.getRotation(); + // btTransform trConstraintCur = (trBCur * m_rbBFrame).inverse() * (trACur * m_rbAFrame); + //btQuaternion qConstraintCur = trConstraintCur.getRotation(); + + btQuaternion qConstraint = m_rbBFrame.getRotation().inverse() * q * m_rbAFrame.getRotation(); + setMotorTargetInConstraintSpace(qConstraint); +} + +void btConeTwistConstraint::setMotorTargetInConstraintSpace(const btQuaternion& q) +{ + m_qTarget = q; + + // clamp motor target to within limits + { + btScalar softness = 1.f; //m_limitSoftness; + + // split into twist and cone + btVector3 vTwisted = quatRotate(m_qTarget, vTwist); + btQuaternion qTargetCone = shortestArcQuat(vTwist, vTwisted); + qTargetCone.normalize(); + btQuaternion qTargetTwist = qTargetCone.inverse() * m_qTarget; + qTargetTwist.normalize(); + + // clamp cone + if (m_swingSpan1 >= btScalar(0.05f) && m_swingSpan2 >= btScalar(0.05f)) + { + btScalar swingAngle, swingLimit; + btVector3 swingAxis; + computeConeLimitInfo(qTargetCone, swingAngle, swingAxis, swingLimit); + + if (fabs(swingAngle) > SIMD_EPSILON) + { + if (swingAngle > swingLimit * softness) + swingAngle = swingLimit * softness; + else if (swingAngle < -swingLimit * softness) + swingAngle = -swingLimit * softness; + qTargetCone = btQuaternion(swingAxis, swingAngle); + } + } + + // clamp twist + if (m_twistSpan >= btScalar(0.05f)) + { + btScalar twistAngle; + btVector3 twistAxis; + computeTwistLimitInfo(qTargetTwist, twistAngle, twistAxis); + + if (fabs(twistAngle) > SIMD_EPSILON) + { + // eddy todo: limitSoftness used here??? + if (twistAngle > m_twistSpan * softness) + twistAngle = m_twistSpan * softness; + else if (twistAngle < -m_twistSpan * softness) + twistAngle = -m_twistSpan * softness; + qTargetTwist = btQuaternion(twistAxis, twistAngle); + } + } + + m_qTarget = qTargetCone * qTargetTwist; + } +} + +///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). +///If no axis is provided, it uses the default axis for this constraint. +void btConeTwistConstraint::setParam(int num, btScalar value, int axis) +{ + switch (num) + { + case BT_CONSTRAINT_ERP: + case BT_CONSTRAINT_STOP_ERP: + if ((axis >= 0) && (axis < 3)) + { + m_linERP = value; + m_flags |= BT_CONETWIST_FLAGS_LIN_ERP; + } + else + { + m_biasFactor = value; + } + break; + case BT_CONSTRAINT_CFM: + case BT_CONSTRAINT_STOP_CFM: + if ((axis >= 0) && (axis < 3)) + { + m_linCFM = value; + m_flags |= BT_CONETWIST_FLAGS_LIN_CFM; + } + else + { + m_angCFM = value; + m_flags |= BT_CONETWIST_FLAGS_ANG_CFM; + } + break; + default: + btAssertConstrParams(0); + break; + } +} + +///return the local value of parameter +btScalar btConeTwistConstraint::getParam(int num, int axis) const +{ + btScalar retVal = 0; + switch (num) + { + case BT_CONSTRAINT_ERP: + case BT_CONSTRAINT_STOP_ERP: + if ((axis >= 0) && (axis < 3)) + { + btAssertConstrParams(m_flags & BT_CONETWIST_FLAGS_LIN_ERP); + retVal = m_linERP; + } + else if ((axis >= 3) && (axis < 6)) + { + retVal = m_biasFactor; + } + else + { + btAssertConstrParams(0); + } + break; + case BT_CONSTRAINT_CFM: + case BT_CONSTRAINT_STOP_CFM: + if ((axis >= 0) && (axis < 3)) + { + btAssertConstrParams(m_flags & BT_CONETWIST_FLAGS_LIN_CFM); + retVal = m_linCFM; + } + else if ((axis >= 3) && (axis < 6)) + { + btAssertConstrParams(m_flags & BT_CONETWIST_FLAGS_ANG_CFM); + retVal = m_angCFM; + } + else + { + btAssertConstrParams(0); + } + break; + default: + btAssertConstrParams(0); + } + return retVal; +} + +void btConeTwistConstraint::setFrames(const btTransform& frameA, const btTransform& frameB) +{ + m_rbAFrame = frameA; + m_rbBFrame = frameB; + buildJacobian(); + //calculateTransforms(); +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp.i new file mode 100644 index 00000000..dc2b7d43 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp ---------------- + +// %include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h new file mode 100644 index 00000000..64f44df1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h @@ -0,0 +1,423 @@ +/* +Bullet Continuous Collision Detection and Physics Library +btConeTwistConstraint is Copyright (c) 2007 Starbreeze Studios + +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. + +Written by: Marcus Hennix +*/ + +/* +Overview: + +btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc). +It is a fixed translation, 3 degree-of-freedom (DOF) rotational "joint". +It divides the 3 rotational DOFs into swing (movement within a cone) and twist. +Swing is divided into swing1 and swing2 which can have different limits, giving an elliptical shape. +(Note: the cone's base isn't flat, so this ellipse is "embedded" on the surface of a sphere.) + +In the contraint's frame of reference: +twist is along the x-axis, +and swing 1 and 2 are along the z and y axes respectively. +*/ + +#ifndef BT_CONETWISTCONSTRAINT_H +#define BT_CONETWISTCONSTRAINT_H + +#include "LinearMath/btVector3.h" +#include "btJacobianEntry.h" +#include "btTypedConstraint.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define btConeTwistConstraintData2 btConeTwistConstraintDoubleData +#define btConeTwistConstraintDataName "btConeTwistConstraintDoubleData" +#else +#define btConeTwistConstraintData2 btConeTwistConstraintData +#define btConeTwistConstraintDataName "btConeTwistConstraintData" +#endif //BT_USE_DOUBLE_PRECISION + +class btRigidBody; + +enum btConeTwistFlags +{ + BT_CONETWIST_FLAGS_LIN_CFM = 1, + BT_CONETWIST_FLAGS_LIN_ERP = 2, + BT_CONETWIST_FLAGS_ANG_CFM = 4 +}; + +///btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc) +ATTRIBUTE_ALIGNED16(class) +btConeTwistConstraint : public btTypedConstraint +{ +#ifdef IN_PARALLELL_SOLVER +public: +#endif + btJacobianEntry m_jac[3]; //3 orthogonal linear constraints + + btTransform m_rbAFrame; + btTransform m_rbBFrame; + + btScalar m_limitSoftness; + btScalar m_biasFactor; + btScalar m_relaxationFactor; + + btScalar m_damping; + + btScalar m_swingSpan1; + btScalar m_swingSpan2; + btScalar m_twistSpan; + + btScalar m_fixThresh; + + btVector3 m_swingAxis; + btVector3 m_twistAxis; + + btScalar m_kSwing; + btScalar m_kTwist; + + btScalar m_twistLimitSign; + btScalar m_swingCorrection; + btScalar m_twistCorrection; + + btScalar m_twistAngle; + + btScalar m_accSwingLimitImpulse; + btScalar m_accTwistLimitImpulse; + + bool m_angularOnly; + bool m_solveTwistLimit; + bool m_solveSwingLimit; + + bool m_useSolveConstraintObsolete; + + // not yet used... + btScalar m_swingLimitRatio; + btScalar m_twistLimitRatio; + btVector3 m_twistAxisA; + + // motor + bool m_bMotorEnabled; + bool m_bNormalizedMotorStrength; + btQuaternion m_qTarget; + btScalar m_maxMotorImpulse; + btVector3 m_accMotorImpulse; + + // parameters + int m_flags; + btScalar m_linCFM; + btScalar m_linERP; + btScalar m_angCFM; + +protected: + void init(); + + void computeConeLimitInfo(const btQuaternion& qCone, // in + btScalar& swingAngle, btVector3& vSwingAxis, btScalar& swingLimit); // all outs + + void computeTwistLimitInfo(const btQuaternion& qTwist, // in + btScalar& twistAngle, btVector3& vTwistAxis); // all outs + + void adjustSwingAxisToUseEllipseNormal(btVector3 & vSwingAxis) const; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btConeTwistConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& rbAFrame, const btTransform& rbBFrame); + + btConeTwistConstraint(btRigidBody & rbA, const btTransform& rbAFrame); + + virtual void buildJacobian(); + + virtual void getInfo1(btConstraintInfo1 * info); + + void getInfo1NonVirtual(btConstraintInfo1 * info); + + virtual void getInfo2(btConstraintInfo2 * info); + + void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btMatrix3x3& invInertiaWorldA, const btMatrix3x3& invInertiaWorldB); + + virtual void solveConstraintObsolete(btSolverBody & bodyA, btSolverBody & bodyB, btScalar timeStep); + + void updateRHS(btScalar timeStep); + + const btRigidBody& getRigidBodyA() const + { + return m_rbA; + } + const btRigidBody& getRigidBodyB() const + { + return m_rbB; + } + + void setAngularOnly(bool angularOnly) + { + m_angularOnly = angularOnly; + } + + bool getAngularOnly() const + { + return m_angularOnly; + } + + void setLimit(int limitIndex, btScalar limitValue) + { + switch (limitIndex) + { + case 3: + { + m_twistSpan = limitValue; + break; + } + case 4: + { + m_swingSpan2 = limitValue; + break; + } + case 5: + { + m_swingSpan1 = limitValue; + break; + } + default: + { + } + }; + } + + btScalar getLimit(int limitIndex) const + { + switch (limitIndex) + { + case 3: + { + return m_twistSpan; + break; + } + case 4: + { + return m_swingSpan2; + break; + } + case 5: + { + return m_swingSpan1; + break; + } + default: + { + btAssert(0 && "Invalid limitIndex specified for btConeTwistConstraint"); + return 0.0; + } + }; + } + + // setLimit(), a few notes: + // _softness: + // 0->1, recommend ~0.8->1. + // describes % of limits where movement is free. + // beyond this softness %, the limit is gradually enforced until the "hard" (1.0) limit is reached. + // _biasFactor: + // 0->1?, recommend 0.3 +/-0.3 or so. + // strength with which constraint resists zeroth order (angular, not angular velocity) limit violation. + // __relaxationFactor: + // 0->1, recommend to stay near 1. + // the lower the value, the less the constraint will fight velocities which violate the angular limits. + void setLimit(btScalar _swingSpan1, btScalar _swingSpan2, btScalar _twistSpan, btScalar _softness = 1.f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f) + { + m_swingSpan1 = _swingSpan1; + m_swingSpan2 = _swingSpan2; + m_twistSpan = _twistSpan; + + m_limitSoftness = _softness; + m_biasFactor = _biasFactor; + m_relaxationFactor = _relaxationFactor; + } + + const btTransform& getAFrame() const { return m_rbAFrame; }; + const btTransform& getBFrame() const { return m_rbBFrame; }; + + inline int getSolveTwistLimit() + { + return m_solveTwistLimit; + } + + inline int getSolveSwingLimit() + { + return m_solveSwingLimit; + } + + inline btScalar getTwistLimitSign() + { + return m_twistLimitSign; + } + + void calcAngleInfo(); + void calcAngleInfo2(const btTransform& transA, const btTransform& transB, const btMatrix3x3& invInertiaWorldA, const btMatrix3x3& invInertiaWorldB); + + inline btScalar getSwingSpan1() const + { + return m_swingSpan1; + } + inline btScalar getSwingSpan2() const + { + return m_swingSpan2; + } + inline btScalar getTwistSpan() const + { + return m_twistSpan; + } + inline btScalar getLimitSoftness() const + { + return m_limitSoftness; + } + inline btScalar getBiasFactor() const + { + return m_biasFactor; + } + inline btScalar getRelaxationFactor() const + { + return m_relaxationFactor; + } + inline btScalar getTwistAngle() const + { + return m_twistAngle; + } + bool isPastSwingLimit() { return m_solveSwingLimit; } + + btScalar getDamping() const { return m_damping; } + void setDamping(btScalar damping) { m_damping = damping; } + + void enableMotor(bool b) { m_bMotorEnabled = b; } + bool isMotorEnabled() const { return m_bMotorEnabled; } + btScalar getMaxMotorImpulse() const { return m_maxMotorImpulse; } + bool isMaxMotorImpulseNormalized() const { return m_bNormalizedMotorStrength; } + void setMaxMotorImpulse(btScalar maxMotorImpulse) + { + m_maxMotorImpulse = maxMotorImpulse; + m_bNormalizedMotorStrength = false; + } + void setMaxMotorImpulseNormalized(btScalar maxMotorImpulse) + { + m_maxMotorImpulse = maxMotorImpulse; + m_bNormalizedMotorStrength = true; + } + + btScalar getFixThresh() { return m_fixThresh; } + void setFixThresh(btScalar fixThresh) { m_fixThresh = fixThresh; } + + // setMotorTarget: + // q: the desired rotation of bodyA wrt bodyB. + // note: if q violates the joint limits, the internal target is clamped to avoid conflicting impulses (very bad for stability) + // note: don't forget to enableMotor() + void setMotorTarget(const btQuaternion& q); + const btQuaternion& getMotorTarget() const { return m_qTarget; } + + // same as above, but q is the desired rotation of frameA wrt frameB in constraint space + void setMotorTargetInConstraintSpace(const btQuaternion& q); + + btVector3 GetPointForAngle(btScalar fAngleInRadians, btScalar fLength) const; + + ///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + ///If no axis is provided, it uses the default axis for this constraint. + virtual void setParam(int num, btScalar value, int axis = -1); + + virtual void setFrames(const btTransform& frameA, const btTransform& frameB); + + const btTransform& getFrameOffsetA() const + { + return m_rbAFrame; + } + + const btTransform& getFrameOffsetB() const + { + return m_rbBFrame; + } + + ///return the local value of parameter + virtual btScalar getParam(int num, int axis = -1) const; + + int getFlags() const + { + return m_flags; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +struct btConeTwistConstraintDoubleData +{ + btTypedConstraintDoubleData m_typeConstraintData; + btTransformDoubleData m_rbAFrame; + btTransformDoubleData m_rbBFrame; + + //limits + double m_swingSpan1; + double m_swingSpan2; + double m_twistSpan; + double m_limitSoftness; + double m_biasFactor; + double m_relaxationFactor; + + double m_damping; +}; + +#ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +///this structure is not used, except for loading pre-2.82 .bullet files +struct btConeTwistConstraintData +{ + btTypedConstraintData m_typeConstraintData; + btTransformFloatData m_rbAFrame; + btTransformFloatData m_rbBFrame; + + //limits + float m_swingSpan1; + float m_swingSpan2; + float m_twistSpan; + float m_limitSoftness; + float m_biasFactor; + float m_relaxationFactor; + + float m_damping; + + char m_pad[4]; +}; +#endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION +// + +SIMD_FORCE_INLINE int btConeTwistConstraint::calculateSerializeBufferSize() const +{ + return sizeof(btConeTwistConstraintData2); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btConeTwistConstraint::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btConeTwistConstraintData2* cone = (btConeTwistConstraintData2*)dataBuffer; + btTypedConstraint::serialize(&cone->m_typeConstraintData, serializer); + + m_rbAFrame.serialize(cone->m_rbAFrame); + m_rbBFrame.serialize(cone->m_rbBFrame); + + cone->m_swingSpan1 = m_swingSpan1; + cone->m_swingSpan2 = m_swingSpan2; + cone->m_twistSpan = m_twistSpan; + cone->m_limitSoftness = m_limitSoftness; + cone->m_biasFactor = m_biasFactor; + cone->m_relaxationFactor = m_relaxationFactor; + cone->m_damping = m_damping; + + return btConeTwistConstraintDataName; +} + +#endif //BT_CONETWISTCONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h.i new file mode 100644 index 00000000..25316c96 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btConeTwistConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConstraintSolver.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConstraintSolver.h new file mode 100644 index 00000000..777eccf9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConstraintSolver.h @@ -0,0 +1,59 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONSTRAINT_SOLVER_H +#define BT_CONSTRAINT_SOLVER_H + +#include "LinearMath/btScalar.h" + +class btPersistentManifold; +class btRigidBody; +class btCollisionObject; +class btTypedConstraint; +struct btContactSolverInfo; +struct btBroadphaseProxy; +class btIDebugDraw; +class btStackAlloc; +class btDispatcher; +/// btConstraintSolver provides solver interface + +enum btConstraintSolverType +{ + BT_SEQUENTIAL_IMPULSE_SOLVER = 1, + BT_MLCP_SOLVER = 2, + BT_NNCG_SOLVER = 4, + BT_MULTIBODY_SOLVER = 8, + BT_BLOCK_SOLVER = 16, +}; + +class btConstraintSolver +{ +public: + virtual ~btConstraintSolver() {} + + virtual void prepareSolve(int /* numBodies */, int /* numManifolds */) { ; } + + ///solve a group of constraints + virtual btScalar solveGroup(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifold, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& info, class btIDebugDraw* debugDrawer, btDispatcher* dispatcher) = 0; + + virtual void allSolved(const btContactSolverInfo& /* info */, class btIDebugDraw* /* debugDrawer */) { ; } + + ///clear internal cached data and reset random seed + virtual void reset() = 0; + + virtual btConstraintSolverType getSolverType() const = 0; +}; + +#endif //BT_CONSTRAINT_SOLVER_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConstraintSolver.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConstraintSolver.h.i new file mode 100644 index 00000000..f54adfad --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btConstraintSolver.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btConstraintSolver.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.cpp new file mode 100644 index 00000000..e8ebe3a7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.cpp @@ -0,0 +1,153 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btContactConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btVector3.h" +#include "btJacobianEntry.h" +#include "btContactSolverInfo.h" +#include "LinearMath/btMinMax.h" +#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" + +btContactConstraint::btContactConstraint(btPersistentManifold* contactManifold, btRigidBody& rbA, btRigidBody& rbB) + : btTypedConstraint(CONTACT_CONSTRAINT_TYPE, rbA, rbB), + m_contactManifold(*contactManifold) +{ +} + +btContactConstraint::~btContactConstraint() +{ +} + +void btContactConstraint::setContactManifold(btPersistentManifold* contactManifold) +{ + m_contactManifold = *contactManifold; +} + +void btContactConstraint::getInfo1(btConstraintInfo1* info) +{ +} + +void btContactConstraint::getInfo2(btConstraintInfo2* info) +{ +} + +void btContactConstraint::buildJacobian() +{ +} + +#include "btContactConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btVector3.h" +#include "btJacobianEntry.h" +#include "btContactSolverInfo.h" +#include "LinearMath/btMinMax.h" +#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" + +//response between two dynamic objects without friction and no restitution, assuming 0 penetration depth +btScalar resolveSingleCollision( + btRigidBody* body1, + btCollisionObject* colObj2, + const btVector3& contactPositionWorld, + const btVector3& contactNormalOnB, + const btContactSolverInfo& solverInfo, + btScalar distance) +{ + btRigidBody* body2 = btRigidBody::upcast(colObj2); + + const btVector3& normal = contactNormalOnB; + + btVector3 rel_pos1 = contactPositionWorld - body1->getWorldTransform().getOrigin(); + btVector3 rel_pos2 = contactPositionWorld - colObj2->getWorldTransform().getOrigin(); + + btVector3 vel1 = body1->getVelocityInLocalPoint(rel_pos1); + btVector3 vel2 = body2 ? body2->getVelocityInLocalPoint(rel_pos2) : btVector3(0, 0, 0); + btVector3 vel = vel1 - vel2; + btScalar rel_vel; + rel_vel = normal.dot(vel); + + btScalar combinedRestitution = 0.f; + btScalar restitution = combinedRestitution * -rel_vel; + + btScalar positionalError = solverInfo.m_erp * -distance / solverInfo.m_timeStep; + btScalar velocityError = -(1.0f + restitution) * rel_vel; // * damping; + btScalar denom0 = body1->computeImpulseDenominator(contactPositionWorld, normal); + btScalar denom1 = body2 ? body2->computeImpulseDenominator(contactPositionWorld, normal) : 0.f; + btScalar relaxation = 1.f; + btScalar jacDiagABInv = relaxation / (denom0 + denom1); + + btScalar penetrationImpulse = positionalError * jacDiagABInv; + btScalar velocityImpulse = velocityError * jacDiagABInv; + + btScalar normalImpulse = penetrationImpulse + velocityImpulse; + normalImpulse = 0.f > normalImpulse ? 0.f : normalImpulse; + + body1->applyImpulse(normal * (normalImpulse), rel_pos1); + if (body2) + body2->applyImpulse(-normal * (normalImpulse), rel_pos2); + + return normalImpulse; +} + +//bilateral constraint between two dynamic objects +void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1, + btRigidBody& body2, const btVector3& pos2, + btScalar distance, const btVector3& normal, btScalar& impulse, btScalar timeStep) +{ + (void)timeStep; + (void)distance; + + btScalar normalLenSqr = normal.length2(); + btAssert(btFabs(normalLenSqr) < btScalar(1.1)); + if (normalLenSqr > btScalar(1.1)) + { + impulse = btScalar(0.); + return; + } + btVector3 rel_pos1 = pos1 - body1.getCenterOfMassPosition(); + btVector3 rel_pos2 = pos2 - body2.getCenterOfMassPosition(); + //this jacobian entry could be re-used for all iterations + + btVector3 vel1 = body1.getVelocityInLocalPoint(rel_pos1); + btVector3 vel2 = body2.getVelocityInLocalPoint(rel_pos2); + btVector3 vel = vel1 - vel2; + + btJacobianEntry jac(body1.getCenterOfMassTransform().getBasis().transpose(), + body2.getCenterOfMassTransform().getBasis().transpose(), + rel_pos1, rel_pos2, normal, body1.getInvInertiaDiagLocal(), body1.getInvMass(), + body2.getInvInertiaDiagLocal(), body2.getInvMass()); + + btScalar jacDiagAB = jac.getDiagonal(); + btScalar jacDiagABInv = btScalar(1.) / jacDiagAB; + + btScalar rel_vel = jac.getRelativeVelocity( + body1.getLinearVelocity(), + body1.getCenterOfMassTransform().getBasis().transpose() * body1.getAngularVelocity(), + body2.getLinearVelocity(), + body2.getCenterOfMassTransform().getBasis().transpose() * body2.getAngularVelocity()); + + rel_vel = normal.dot(vel); + + //todo: move this into proper structure + btScalar contactDamping = btScalar(0.2); + +#ifdef ONLY_USE_LINEAR_MASS + btScalar massTerm = btScalar(1.) / (body1.getInvMass() + body2.getInvMass()); + impulse = -contactDamping * rel_vel * massTerm; +#else + btScalar velocityImpulse = -contactDamping * rel_vel * jacDiagABInv; + impulse = velocityImpulse; +#endif +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.cpp.i new file mode 100644 index 00000000..10e6b446 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btContactConstraint.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btContactConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btContactConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.h new file mode 100644 index 00000000..b213a385 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.h @@ -0,0 +1,65 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONTACT_CONSTRAINT_H +#define BT_CONTACT_CONSTRAINT_H + +#include "LinearMath/btVector3.h" +#include "btJacobianEntry.h" +#include "btTypedConstraint.h" +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" + +///btContactConstraint can be automatically created to solve contact constraints using the unified btTypedConstraint interface +ATTRIBUTE_ALIGNED16(class) +btContactConstraint : public btTypedConstraint +{ +protected: + btPersistentManifold m_contactManifold; + +protected: + btContactConstraint(btPersistentManifold * contactManifold, btRigidBody & rbA, btRigidBody & rbB); + +public: + void setContactManifold(btPersistentManifold * contactManifold); + + btPersistentManifold* getContactManifold() + { + return &m_contactManifold; + } + + const btPersistentManifold* getContactManifold() const + { + return &m_contactManifold; + } + + virtual ~btContactConstraint(); + + virtual void getInfo1(btConstraintInfo1 * info); + + virtual void getInfo2(btConstraintInfo2 * info); + + ///obsolete methods + virtual void buildJacobian(); +}; + +///very basic collision resolution without friction +btScalar resolveSingleCollision(btRigidBody* body1, class btCollisionObject* colObj2, const btVector3& contactPositionWorld, const btVector3& contactNormalOnB, const struct btContactSolverInfo& solverInfo, btScalar distance); + +///resolveSingleBilateral is an obsolete methods used for vehicle friction between two dynamic objects +void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1, + btRigidBody& body2, const btVector3& pos2, + btScalar distance, const btVector3& normal, btScalar& impulse, btScalar timeStep); + +#endif //BT_CONTACT_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.h.i new file mode 100644 index 00000000..f65bb317 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btContactConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btContactConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btContactConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactSolverInfo.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactSolverInfo.h new file mode 100644 index 00000000..63041677 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactSolverInfo.h @@ -0,0 +1,177 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_CONTACT_SOLVER_INFO +#define BT_CONTACT_SOLVER_INFO + +#include "LinearMath/btScalar.h" + +enum btSolverMode +{ + SOLVER_RANDMIZE_ORDER = 1, + SOLVER_FRICTION_SEPARATE = 2, + SOLVER_USE_WARMSTARTING = 4, + SOLVER_USE_2_FRICTION_DIRECTIONS = 16, + SOLVER_ENABLE_FRICTION_DIRECTION_CACHING = 32, + SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION = 64, + SOLVER_CACHE_FRIENDLY = 128, + SOLVER_SIMD = 256, + SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS = 512, + SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS = 1024, + SOLVER_DISABLE_IMPLICIT_CONE_FRICTION = 2048, + SOLVER_USE_ARTICULATED_WARMSTARTING = 4096, +}; + +struct btContactSolverInfoData +{ + btScalar m_tau; + btScalar m_damping; //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + btScalar m_friction; + btScalar m_timeStep; + btScalar m_restitution; + int m_numIterations; + btScalar m_maxErrorReduction; + btScalar m_sor; //successive over-relaxation term + btScalar m_erp; //error reduction for non-contact constraints + btScalar m_erp2; //error reduction for contact constraints + btScalar m_deformable_erp; //error reduction for deformable constraints + btScalar m_deformable_cfm; //constraint force mixing for deformable constraints + btScalar m_deformable_maxErrorReduction; // maxErrorReduction for deformable contact + btScalar m_globalCfm; //constraint force mixing for contacts and non-contacts + btScalar m_frictionERP; //error reduction for friction constraints + btScalar m_frictionCFM; //constraint force mixing for friction constraints + + int m_splitImpulse; + btScalar m_splitImpulsePenetrationThreshold; + btScalar m_splitImpulseTurnErp; + btScalar m_linearSlop; + btScalar m_warmstartingFactor; + btScalar m_articulatedWarmstartingFactor; + int m_solverMode; + int m_restingContactRestitutionThreshold; + int m_minimumSolverBatchSize; + btScalar m_maxGyroscopicForce; + btScalar m_singleAxisRollingFrictionThreshold; + btScalar m_leastSquaresResidualThreshold; + btScalar m_restitutionVelocityThreshold; + bool m_jointFeedbackInWorldSpace; + bool m_jointFeedbackInJointFrame; + int m_reportSolverAnalytics; + int m_numNonContactInnerIterations; +}; + +struct btContactSolverInfo : public btContactSolverInfoData +{ + inline btContactSolverInfo() + { + m_tau = btScalar(0.6); + m_damping = btScalar(1.0); + m_friction = btScalar(0.3); + m_timeStep = btScalar(1.f / 60.f); + m_restitution = btScalar(0.); + m_maxErrorReduction = btScalar(20.); + m_numIterations = 10; + m_erp = btScalar(0.2); + m_erp2 = btScalar(0.2); + m_deformable_erp = btScalar(0.06); + m_deformable_cfm = btScalar(0.01); + m_deformable_maxErrorReduction = btScalar(0.1); + m_globalCfm = btScalar(0.); + m_frictionERP = btScalar(0.2); //positional friction 'anchors' are disabled by default + m_frictionCFM = btScalar(0.); + m_sor = btScalar(1.); + m_splitImpulse = true; + m_splitImpulsePenetrationThreshold = -.04f; + m_splitImpulseTurnErp = 0.1f; + m_linearSlop = btScalar(0.0); + m_warmstartingFactor = btScalar(0.85); + m_articulatedWarmstartingFactor = btScalar(0.85); + //m_solverMode = SOLVER_USE_WARMSTARTING | SOLVER_SIMD | SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION|SOLVER_USE_2_FRICTION_DIRECTIONS|SOLVER_ENABLE_FRICTION_DIRECTION_CACHING;// | SOLVER_RANDMIZE_ORDER; + m_solverMode = SOLVER_USE_WARMSTARTING | SOLVER_SIMD; // | SOLVER_RANDMIZE_ORDER; + m_restingContactRestitutionThreshold = 2; //unused as of 2.81 + m_minimumSolverBatchSize = 128; //try to combine islands until the amount of constraints reaches this limit + m_maxGyroscopicForce = 100.f; ///it is only used for 'explicit' version of gyroscopic force + m_singleAxisRollingFrictionThreshold = 1e30f; ///if the velocity is above this threshold, it will use a single constraint row (axis), otherwise 3 rows. + m_leastSquaresResidualThreshold = 0.f; + m_restitutionVelocityThreshold = 0.2f; //if the relative velocity is below this threshold, there is zero restitution + m_jointFeedbackInWorldSpace = false; + m_jointFeedbackInJointFrame = false; + m_reportSolverAnalytics = 0; + m_numNonContactInnerIterations = 1; // the number of inner iterations for solving motor constraint in a single iteration of the constraint solve + } +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btContactSolverInfoDoubleData +{ + double m_tau; + double m_damping; //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + double m_friction; + double m_timeStep; + double m_restitution; + double m_maxErrorReduction; + double m_sor; + double m_erp; //used as Baumgarte factor + double m_erp2; //used in Split Impulse + double m_globalCfm; //constraint force mixing + double m_splitImpulsePenetrationThreshold; + double m_splitImpulseTurnErp; + double m_linearSlop; + double m_warmstartingFactor; + double m_articulatedWarmstartingFactor; + double m_maxGyroscopicForce; ///it is only used for 'explicit' version of gyroscopic force + double m_singleAxisRollingFrictionThreshold; + + int m_numIterations; + int m_solverMode; + int m_restingContactRestitutionThreshold; + int m_minimumSolverBatchSize; + int m_splitImpulse; + char m_padding[4]; +}; +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btContactSolverInfoFloatData +{ + float m_tau; + float m_damping; //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + float m_friction; + float m_timeStep; + + float m_restitution; + float m_maxErrorReduction; + float m_sor; + float m_erp; //used as Baumgarte factor + + float m_erp2; //used in Split Impulse + float m_globalCfm; //constraint force mixing + float m_splitImpulsePenetrationThreshold; + float m_splitImpulseTurnErp; + + float m_linearSlop; + float m_warmstartingFactor; + float m_articulatedWarmstartingFactor; + float m_maxGyroscopicForce; + + float m_singleAxisRollingFrictionThreshold; + int m_numIterations; + int m_solverMode; + int m_restingContactRestitutionThreshold; + + int m_minimumSolverBatchSize; + int m_splitImpulse; + +}; + +#endif //BT_CONTACT_SOLVER_INFO diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactSolverInfo.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactSolverInfo.h.i new file mode 100644 index 00000000..e86c07f6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btContactSolverInfo.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btContactSolverInfo.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.cpp new file mode 100644 index 00000000..bba102d9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.cpp @@ -0,0 +1,32 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btFixedConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btTransformUtil.h" +#include + +btFixedConstraint::btFixedConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB) + : btGeneric6DofSpring2Constraint(rbA, rbB, frameInA, frameInB) +{ + setAngularLowerLimit(btVector3(0, 0, 0)); + setAngularUpperLimit(btVector3(0, 0, 0)); + setLinearLowerLimit(btVector3(0, 0, 0)); + setLinearUpperLimit(btVector3(0, 0, 0)); +} + +btFixedConstraint::~btFixedConstraint() +{ +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.cpp.i new file mode 100644 index 00000000..3cc96f65 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btFixedConstraint.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btFixedConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btFixedConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.h new file mode 100644 index 00000000..6d474ea8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.h @@ -0,0 +1,30 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_FIXED_CONSTRAINT_H +#define BT_FIXED_CONSTRAINT_H + +#include "btGeneric6DofSpring2Constraint.h" + +ATTRIBUTE_ALIGNED16(class) +btFixedConstraint : public btGeneric6DofSpring2Constraint +{ +public: + btFixedConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB); + + virtual ~btFixedConstraint(); +}; + +#endif //BT_FIXED_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.h.i new file mode 100644 index 00000000..b6c002d9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btFixedConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btFixedConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btFixedConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btFixedConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.cpp new file mode 100644 index 00000000..7535c52c --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.cpp @@ -0,0 +1,52 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2012 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/// Implemented by Erwin Coumans. The idea for the constraint comes from Dimitris Papavasiliou. + +#include "btGearConstraint.h" + +btGearConstraint::btGearConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& axisInA, const btVector3& axisInB, btScalar ratio) + : btTypedConstraint(GEAR_CONSTRAINT_TYPE, rbA, rbB), + m_axisInA(axisInA), + m_axisInB(axisInB), + m_ratio(ratio) +{ +} + +btGearConstraint::~btGearConstraint() +{ +} + +void btGearConstraint::getInfo1(btConstraintInfo1* info) +{ + info->m_numConstraintRows = 1; + info->nub = 1; +} + +void btGearConstraint::getInfo2(btConstraintInfo2* info) +{ + btVector3 globalAxisA, globalAxisB; + + globalAxisA = m_rbA.getWorldTransform().getBasis() * this->m_axisInA; + globalAxisB = m_rbB.getWorldTransform().getBasis() * this->m_axisInB; + + info->m_J1angularAxis[0] = globalAxisA[0]; + info->m_J1angularAxis[1] = globalAxisA[1]; + info->m_J1angularAxis[2] = globalAxisA[2]; + + info->m_J2angularAxis[0] = m_ratio * globalAxisB[0]; + info->m_J2angularAxis[1] = m_ratio * globalAxisB[1]; + info->m_J2angularAxis[2] = m_ratio * globalAxisB[2]; +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.cpp.i new file mode 100644 index 00000000..d7abf988 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btGearConstraint.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btGearConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btGearConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.h new file mode 100644 index 00000000..64b15dfb --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.h @@ -0,0 +1,146 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2012 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_GEAR_CONSTRAINT_H +#define BT_GEAR_CONSTRAINT_H + +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define btGearConstraintData btGearConstraintDoubleData +#define btGearConstraintDataName "btGearConstraintDoubleData" +#else +#define btGearConstraintData btGearConstraintFloatData +#define btGearConstraintDataName "btGearConstraintFloatData" +#endif //BT_USE_DOUBLE_PRECISION + +///The btGeatConstraint will couple the angular velocity for two bodies around given local axis and ratio. +///See Bullet/Demos/ConstraintDemo for an example use. +class btGearConstraint : public btTypedConstraint +{ +protected: + btVector3 m_axisInA; + btVector3 m_axisInB; + bool m_useFrameA; + btScalar m_ratio; + +public: + btGearConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& axisInA, const btVector3& axisInB, btScalar ratio = 1.f); + virtual ~btGearConstraint(); + + ///internal method used by the constraint solver, don't use them directly + virtual void getInfo1(btConstraintInfo1* info); + + ///internal method used by the constraint solver, don't use them directly + virtual void getInfo2(btConstraintInfo2* info); + + void setAxisA(btVector3& axisA) + { + m_axisInA = axisA; + } + void setAxisB(btVector3& axisB) + { + m_axisInB = axisB; + } + void setRatio(btScalar ratio) + { + m_ratio = ratio; + } + const btVector3& getAxisA() const + { + return m_axisInA; + } + const btVector3& getAxisB() const + { + return m_axisInB; + } + btScalar getRatio() const + { + return m_ratio; + } + + virtual void setParam(int num, btScalar value, int axis = -1) + { + (void)num; + (void)value; + (void)axis; + btAssert(0); + } + + ///return the local value of parameter + virtual btScalar getParam(int num, int axis = -1) const + { + (void)num; + (void)axis; + btAssert(0); + return 0.f; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btGearConstraintFloatData +{ + btTypedConstraintFloatData m_typeConstraintData; + + btVector3FloatData m_axisInA; + btVector3FloatData m_axisInB; + + float m_ratio; + char m_padding[4]; +}; + +struct btGearConstraintDoubleData +{ + btTypedConstraintDoubleData m_typeConstraintData; + + btVector3DoubleData m_axisInA; + btVector3DoubleData m_axisInB; + + double m_ratio; +}; + +SIMD_FORCE_INLINE int btGearConstraint::calculateSerializeBufferSize() const +{ + return sizeof(btGearConstraintData); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btGearConstraint::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btGearConstraintData* gear = (btGearConstraintData*)dataBuffer; + btTypedConstraint::serialize(&gear->m_typeConstraintData, serializer); + + m_axisInA.serialize(gear->m_axisInA); + m_axisInB.serialize(gear->m_axisInB); + + gear->m_ratio = m_ratio; + + // Fill padding with zeros to appease msan. +#ifndef BT_USE_DOUBLE_PRECISION + gear->m_padding[0] = 0; + gear->m_padding[1] = 0; + gear->m_padding[2] = 0; + gear->m_padding[3] = 0; +#endif + + return btGearConstraintDataName; +} + +#endif //BT_GEAR_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.h.i new file mode 100644 index 00000000..f9b05f05 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGearConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btGearConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btGearConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btGearConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp new file mode 100644 index 00000000..14ec4a8e --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp @@ -0,0 +1,975 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/* +2007-09-09 +Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ + +#include "btGeneric6DofConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btTransformUtil.h" +#include "LinearMath/btTransformUtil.h" +#include + +#define D6_USE_OBSOLETE_METHOD false +#define D6_USE_FRAME_OFFSET true + +btGeneric6DofConstraint::btGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA) + : btTypedConstraint(D6_CONSTRAINT_TYPE, rbA, rbB), m_frameInA(frameInA), m_frameInB(frameInB), m_useLinearReferenceFrameA(useLinearReferenceFrameA), m_useOffsetForConstraintFrame(D6_USE_FRAME_OFFSET), m_flags(0), m_useSolveConstraintObsolete(D6_USE_OBSOLETE_METHOD) +{ + calculateTransforms(); +} + +btGeneric6DofConstraint::btGeneric6DofConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameB) + : btTypedConstraint(D6_CONSTRAINT_TYPE, getFixedBody(), rbB), + m_frameInB(frameInB), + m_useLinearReferenceFrameA(useLinearReferenceFrameB), + m_useOffsetForConstraintFrame(D6_USE_FRAME_OFFSET), + m_flags(0), + m_useSolveConstraintObsolete(false) +{ + ///not providing rigidbody A means implicitly using worldspace for body A + m_frameInA = rbB.getCenterOfMassTransform() * m_frameInB; + calculateTransforms(); +} + +#define GENERIC_D6_DISABLE_WARMSTARTING 1 + +btScalar btGetMatrixElem(const btMatrix3x3& mat, int index); +btScalar btGetMatrixElem(const btMatrix3x3& mat, int index) +{ + int i = index % 3; + int j = index / 3; + return mat[i][j]; +} + +///MatrixToEulerXYZ from http://www.geometrictools.com/LibFoundation/Mathematics/Wm4Matrix3.inl.html +bool matrixToEulerXYZ(const btMatrix3x3& mat, btVector3& xyz); +bool matrixToEulerXYZ(const btMatrix3x3& mat, btVector3& xyz) +{ + // // rot = cy*cz -cy*sz sy + // // cz*sx*sy+cx*sz cx*cz-sx*sy*sz -cy*sx + // // -cx*cz*sy+sx*sz cz*sx+cx*sy*sz cx*cy + // + + btScalar fi = btGetMatrixElem(mat, 2); + if (fi < btScalar(1.0f)) + { + if (fi > btScalar(-1.0f)) + { + xyz[0] = btAtan2(-btGetMatrixElem(mat, 5), btGetMatrixElem(mat, 8)); + xyz[1] = btAsin(btGetMatrixElem(mat, 2)); + xyz[2] = btAtan2(-btGetMatrixElem(mat, 1), btGetMatrixElem(mat, 0)); + return true; + } + else + { + // WARNING. Not unique. XA - ZA = -atan2(r10,r11) + xyz[0] = -btAtan2(btGetMatrixElem(mat, 3), btGetMatrixElem(mat, 4)); + xyz[1] = -SIMD_HALF_PI; + xyz[2] = btScalar(0.0); + return false; + } + } + else + { + // WARNING. Not unique. XAngle + ZAngle = atan2(r10,r11) + xyz[0] = btAtan2(btGetMatrixElem(mat, 3), btGetMatrixElem(mat, 4)); + xyz[1] = SIMD_HALF_PI; + xyz[2] = 0.0; + } + return false; +} + +//////////////////////////// btRotationalLimitMotor //////////////////////////////////// + +int btRotationalLimitMotor::testLimitValue(btScalar test_value) +{ + if (m_loLimit > m_hiLimit) + { + m_currentLimit = 0; //Free from violation + return 0; + } + if (test_value < m_loLimit) + { + m_currentLimit = 1; //low limit violation + m_currentLimitError = test_value - m_loLimit; + if (m_currentLimitError > SIMD_PI) + m_currentLimitError -= SIMD_2_PI; + else if (m_currentLimitError < -SIMD_PI) + m_currentLimitError += SIMD_2_PI; + return 1; + } + else if (test_value > m_hiLimit) + { + m_currentLimit = 2; //High limit violation + m_currentLimitError = test_value - m_hiLimit; + if (m_currentLimitError > SIMD_PI) + m_currentLimitError -= SIMD_2_PI; + else if (m_currentLimitError < -SIMD_PI) + m_currentLimitError += SIMD_2_PI; + return 2; + }; + + m_currentLimit = 0; //Free from violation + return 0; +} + +btScalar btRotationalLimitMotor::solveAngularLimits( + btScalar timeStep, btVector3& axis, btScalar jacDiagABInv, + btRigidBody* body0, btRigidBody* body1) +{ + if (needApplyTorques() == false) return 0.0f; + + btScalar target_velocity = m_targetVelocity; + btScalar maxMotorForce = m_maxMotorForce; + + //current error correction + if (m_currentLimit != 0) + { + target_velocity = -m_stopERP * m_currentLimitError / (timeStep); + maxMotorForce = m_maxLimitForce; + } + + maxMotorForce *= timeStep; + + // current velocity difference + + btVector3 angVelA = body0->getAngularVelocity(); + btVector3 angVelB = body1->getAngularVelocity(); + + btVector3 vel_diff; + vel_diff = angVelA - angVelB; + + btScalar rel_vel = axis.dot(vel_diff); + + // correction velocity + btScalar motor_relvel = m_limitSoftness * (target_velocity - m_damping * rel_vel); + + if (motor_relvel < SIMD_EPSILON && motor_relvel > -SIMD_EPSILON) + { + return 0.0f; //no need for applying force + } + + // correction impulse + btScalar unclippedMotorImpulse = (1 + m_bounce) * motor_relvel * jacDiagABInv; + + // clip correction impulse + btScalar clippedMotorImpulse; + + ///@todo: should clip against accumulated impulse + if (unclippedMotorImpulse > 0.0f) + { + clippedMotorImpulse = unclippedMotorImpulse > maxMotorForce ? maxMotorForce : unclippedMotorImpulse; + } + else + { + clippedMotorImpulse = unclippedMotorImpulse < -maxMotorForce ? -maxMotorForce : unclippedMotorImpulse; + } + + // sort with accumulated impulses + btScalar lo = btScalar(-BT_LARGE_FLOAT); + btScalar hi = btScalar(BT_LARGE_FLOAT); + + btScalar oldaccumImpulse = m_accumulatedImpulse; + btScalar sum = oldaccumImpulse + clippedMotorImpulse; + m_accumulatedImpulse = sum > hi ? btScalar(0.) : sum < lo ? btScalar(0.) : sum; + + clippedMotorImpulse = m_accumulatedImpulse - oldaccumImpulse; + + btVector3 motorImp = clippedMotorImpulse * axis; + + body0->applyTorqueImpulse(motorImp); + body1->applyTorqueImpulse(-motorImp); + + return clippedMotorImpulse; +} + +//////////////////////////// End btRotationalLimitMotor //////////////////////////////////// + +//////////////////////////// btTranslationalLimitMotor //////////////////////////////////// + +int btTranslationalLimitMotor::testLimitValue(int limitIndex, btScalar test_value) +{ + btScalar loLimit = m_lowerLimit[limitIndex]; + btScalar hiLimit = m_upperLimit[limitIndex]; + if (loLimit > hiLimit) + { + m_currentLimit[limitIndex] = 0; //Free from violation + m_currentLimitError[limitIndex] = btScalar(0.f); + return 0; + } + + if (test_value < loLimit) + { + m_currentLimit[limitIndex] = 2; //low limit violation + m_currentLimitError[limitIndex] = test_value - loLimit; + return 2; + } + else if (test_value > hiLimit) + { + m_currentLimit[limitIndex] = 1; //High limit violation + m_currentLimitError[limitIndex] = test_value - hiLimit; + return 1; + }; + + m_currentLimit[limitIndex] = 0; //Free from violation + m_currentLimitError[limitIndex] = btScalar(0.f); + return 0; +} + +btScalar btTranslationalLimitMotor::solveLinearAxis( + btScalar timeStep, + btScalar jacDiagABInv, + btRigidBody& body1, const btVector3& pointInA, + btRigidBody& body2, const btVector3& pointInB, + int limit_index, + const btVector3& axis_normal_on_a, + const btVector3& anchorPos) +{ + ///find relative velocity + // btVector3 rel_pos1 = pointInA - body1.getCenterOfMassPosition(); + // btVector3 rel_pos2 = pointInB - body2.getCenterOfMassPosition(); + btVector3 rel_pos1 = anchorPos - body1.getCenterOfMassPosition(); + btVector3 rel_pos2 = anchorPos - body2.getCenterOfMassPosition(); + + btVector3 vel1 = body1.getVelocityInLocalPoint(rel_pos1); + btVector3 vel2 = body2.getVelocityInLocalPoint(rel_pos2); + btVector3 vel = vel1 - vel2; + + btScalar rel_vel = axis_normal_on_a.dot(vel); + + /// apply displacement correction + + //positional error (zeroth order error) + btScalar depth = -(pointInA - pointInB).dot(axis_normal_on_a); + btScalar lo = btScalar(-BT_LARGE_FLOAT); + btScalar hi = btScalar(BT_LARGE_FLOAT); + + btScalar minLimit = m_lowerLimit[limit_index]; + btScalar maxLimit = m_upperLimit[limit_index]; + + //handle the limits + if (minLimit < maxLimit) + { + { + if (depth > maxLimit) + { + depth -= maxLimit; + lo = btScalar(0.); + } + else + { + if (depth < minLimit) + { + depth -= minLimit; + hi = btScalar(0.); + } + else + { + return 0.0f; + } + } + } + } + + btScalar normalImpulse = m_limitSoftness * (m_restitution * depth / timeStep - m_damping * rel_vel) * jacDiagABInv; + + btScalar oldNormalImpulse = m_accumulatedImpulse[limit_index]; + btScalar sum = oldNormalImpulse + normalImpulse; + m_accumulatedImpulse[limit_index] = sum > hi ? btScalar(0.) : sum < lo ? btScalar(0.) : sum; + normalImpulse = m_accumulatedImpulse[limit_index] - oldNormalImpulse; + + btVector3 impulse_vector = axis_normal_on_a * normalImpulse; + body1.applyImpulse(impulse_vector, rel_pos1); + body2.applyImpulse(-impulse_vector, rel_pos2); + + return normalImpulse; +} + +//////////////////////////// btTranslationalLimitMotor //////////////////////////////////// + +void btGeneric6DofConstraint::calculateAngleInfo() +{ + btMatrix3x3 relative_frame = m_calculatedTransformA.getBasis().inverse() * m_calculatedTransformB.getBasis(); + matrixToEulerXYZ(relative_frame, m_calculatedAxisAngleDiff); + // in euler angle mode we do not actually constrain the angular velocity + // along the axes axis[0] and axis[2] (although we do use axis[1]) : + // + // to get constrain w2-w1 along ...not + // ------ --------------------- ------ + // d(angle[0])/dt = 0 ax[1] x ax[2] ax[0] + // d(angle[1])/dt = 0 ax[1] + // d(angle[2])/dt = 0 ax[0] x ax[1] ax[2] + // + // constraining w2-w1 along an axis 'a' means that a'*(w2-w1)=0. + // to prove the result for angle[0], write the expression for angle[0] from + // GetInfo1 then take the derivative. to prove this for angle[2] it is + // easier to take the euler rate expression for d(angle[2])/dt with respect + // to the components of w and set that to 0. + btVector3 axis0 = m_calculatedTransformB.getBasis().getColumn(0); + btVector3 axis2 = m_calculatedTransformA.getBasis().getColumn(2); + + m_calculatedAxis[1] = axis2.cross(axis0); + m_calculatedAxis[0] = m_calculatedAxis[1].cross(axis2); + m_calculatedAxis[2] = axis0.cross(m_calculatedAxis[1]); + + m_calculatedAxis[0].normalize(); + m_calculatedAxis[1].normalize(); + m_calculatedAxis[2].normalize(); +} + +void btGeneric6DofConstraint::calculateTransforms() +{ + calculateTransforms(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); +} + +void btGeneric6DofConstraint::calculateTransforms(const btTransform& transA, const btTransform& transB) +{ + m_calculatedTransformA = transA * m_frameInA; + m_calculatedTransformB = transB * m_frameInB; + calculateLinearInfo(); + calculateAngleInfo(); + if (m_useOffsetForConstraintFrame) + { // get weight factors depending on masses + btScalar miA = getRigidBodyA().getInvMass(); + btScalar miB = getRigidBodyB().getInvMass(); + m_hasStaticBody = (miA < SIMD_EPSILON) || (miB < SIMD_EPSILON); + btScalar miS = miA + miB; + if (miS > btScalar(0.f)) + { + m_factA = miB / miS; + } + else + { + m_factA = btScalar(0.5f); + } + m_factB = btScalar(1.0f) - m_factA; + } +} + +void btGeneric6DofConstraint::buildLinearJacobian( + btJacobianEntry& jacLinear, const btVector3& normalWorld, + const btVector3& pivotAInW, const btVector3& pivotBInW) +{ + new (&jacLinear) btJacobianEntry( + m_rbA.getCenterOfMassTransform().getBasis().transpose(), + m_rbB.getCenterOfMassTransform().getBasis().transpose(), + pivotAInW - m_rbA.getCenterOfMassPosition(), + pivotBInW - m_rbB.getCenterOfMassPosition(), + normalWorld, + m_rbA.getInvInertiaDiagLocal(), + m_rbA.getInvMass(), + m_rbB.getInvInertiaDiagLocal(), + m_rbB.getInvMass()); +} + +void btGeneric6DofConstraint::buildAngularJacobian( + btJacobianEntry& jacAngular, const btVector3& jointAxisW) +{ + new (&jacAngular) btJacobianEntry(jointAxisW, + m_rbA.getCenterOfMassTransform().getBasis().transpose(), + m_rbB.getCenterOfMassTransform().getBasis().transpose(), + m_rbA.getInvInertiaDiagLocal(), + m_rbB.getInvInertiaDiagLocal()); +} + +bool btGeneric6DofConstraint::testAngularLimitMotor(int axis_index) +{ + btScalar angle = m_calculatedAxisAngleDiff[axis_index]; + angle = btAdjustAngleToLimits(angle, m_angularLimits[axis_index].m_loLimit, m_angularLimits[axis_index].m_hiLimit); + m_angularLimits[axis_index].m_currentPosition = angle; + //test limits + m_angularLimits[axis_index].testLimitValue(angle); + return m_angularLimits[axis_index].needApplyTorques(); +} + +void btGeneric6DofConstraint::buildJacobian() +{ +#ifndef __SPU__ + if (m_useSolveConstraintObsolete) + { + // Clear accumulated impulses for the next simulation step + m_linearLimits.m_accumulatedImpulse.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); + int i; + for (i = 0; i < 3; i++) + { + m_angularLimits[i].m_accumulatedImpulse = btScalar(0.); + } + //calculates transform + calculateTransforms(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); + + // const btVector3& pivotAInW = m_calculatedTransformA.getOrigin(); + // const btVector3& pivotBInW = m_calculatedTransformB.getOrigin(); + calcAnchorPos(); + btVector3 pivotAInW = m_AnchorPos; + btVector3 pivotBInW = m_AnchorPos; + + // not used here + // btVector3 rel_pos1 = pivotAInW - m_rbA.getCenterOfMassPosition(); + // btVector3 rel_pos2 = pivotBInW - m_rbB.getCenterOfMassPosition(); + + btVector3 normalWorld; + //linear part + for (i = 0; i < 3; i++) + { + if (m_linearLimits.isLimited(i)) + { + if (m_useLinearReferenceFrameA) + normalWorld = m_calculatedTransformA.getBasis().getColumn(i); + else + normalWorld = m_calculatedTransformB.getBasis().getColumn(i); + + buildLinearJacobian( + m_jacLinear[i], normalWorld, + pivotAInW, pivotBInW); + } + } + + // angular part + for (i = 0; i < 3; i++) + { + //calculates error angle + if (testAngularLimitMotor(i)) + { + normalWorld = this->getAxis(i); + // Create angular atom + buildAngularJacobian(m_jacAng[i], normalWorld); + } + } + } +#endif //__SPU__ +} + +void btGeneric6DofConstraint::getInfo1(btConstraintInfo1* info) +{ + if (m_useSolveConstraintObsolete) + { + info->m_numConstraintRows = 0; + info->nub = 0; + } + else + { + //prepare constraint + calculateTransforms(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); + info->m_numConstraintRows = 0; + info->nub = 6; + int i; + //test linear limits + for (i = 0; i < 3; i++) + { + if (m_linearLimits.needApplyForce(i)) + { + info->m_numConstraintRows++; + info->nub--; + } + } + //test angular limits + for (i = 0; i < 3; i++) + { + if (testAngularLimitMotor(i)) + { + info->m_numConstraintRows++; + info->nub--; + } + } + } +} + +void btGeneric6DofConstraint::getInfo1NonVirtual(btConstraintInfo1* info) +{ + if (m_useSolveConstraintObsolete) + { + info->m_numConstraintRows = 0; + info->nub = 0; + } + else + { + //pre-allocate all 6 + info->m_numConstraintRows = 6; + info->nub = 0; + } +} + +void btGeneric6DofConstraint::getInfo2(btConstraintInfo2* info) +{ + btAssert(!m_useSolveConstraintObsolete); + + const btTransform& transA = m_rbA.getCenterOfMassTransform(); + const btTransform& transB = m_rbB.getCenterOfMassTransform(); + const btVector3& linVelA = m_rbA.getLinearVelocity(); + const btVector3& linVelB = m_rbB.getLinearVelocity(); + const btVector3& angVelA = m_rbA.getAngularVelocity(); + const btVector3& angVelB = m_rbB.getAngularVelocity(); + + if (m_useOffsetForConstraintFrame) + { // for stability better to solve angular limits first + int row = setAngularLimits(info, 0, transA, transB, linVelA, linVelB, angVelA, angVelB); + setLinearLimits(info, row, transA, transB, linVelA, linVelB, angVelA, angVelB); + } + else + { // leave old version for compatibility + int row = setLinearLimits(info, 0, transA, transB, linVelA, linVelB, angVelA, angVelB); + setAngularLimits(info, row, transA, transB, linVelA, linVelB, angVelA, angVelB); + } +} + +void btGeneric6DofConstraint::getInfo2NonVirtual(btConstraintInfo2* info, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB) +{ + btAssert(!m_useSolveConstraintObsolete); + //prepare constraint + calculateTransforms(transA, transB); + + int i; + for (i = 0; i < 3; i++) + { + testAngularLimitMotor(i); + } + + if (m_useOffsetForConstraintFrame) + { // for stability better to solve angular limits first + int row = setAngularLimits(info, 0, transA, transB, linVelA, linVelB, angVelA, angVelB); + setLinearLimits(info, row, transA, transB, linVelA, linVelB, angVelA, angVelB); + } + else + { // leave old version for compatibility + int row = setLinearLimits(info, 0, transA, transB, linVelA, linVelB, angVelA, angVelB); + setAngularLimits(info, row, transA, transB, linVelA, linVelB, angVelA, angVelB); + } +} + +int btGeneric6DofConstraint::setLinearLimits(btConstraintInfo2* info, int row, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB) +{ + // int row = 0; + //solve linear limits + btRotationalLimitMotor limot; + for (int i = 0; i < 3; i++) + { + if (m_linearLimits.needApplyForce(i)) + { // re-use rotational motor code + limot.m_bounce = btScalar(0.f); + limot.m_currentLimit = m_linearLimits.m_currentLimit[i]; + limot.m_currentPosition = m_linearLimits.m_currentLinearDiff[i]; + limot.m_currentLimitError = m_linearLimits.m_currentLimitError[i]; + limot.m_damping = m_linearLimits.m_damping; + limot.m_enableMotor = m_linearLimits.m_enableMotor[i]; + limot.m_hiLimit = m_linearLimits.m_upperLimit[i]; + limot.m_limitSoftness = m_linearLimits.m_limitSoftness; + limot.m_loLimit = m_linearLimits.m_lowerLimit[i]; + limot.m_maxLimitForce = btScalar(0.f); + limot.m_maxMotorForce = m_linearLimits.m_maxMotorForce[i]; + limot.m_targetVelocity = m_linearLimits.m_targetVelocity[i]; + btVector3 axis = m_calculatedTransformA.getBasis().getColumn(i); + int flags = m_flags >> (i * BT_6DOF_FLAGS_AXIS_SHIFT); + limot.m_normalCFM = (flags & BT_6DOF_FLAGS_CFM_NORM) ? m_linearLimits.m_normalCFM[i] : info->cfm[0]; + limot.m_stopCFM = (flags & BT_6DOF_FLAGS_CFM_STOP) ? m_linearLimits.m_stopCFM[i] : info->cfm[0]; + limot.m_stopERP = (flags & BT_6DOF_FLAGS_ERP_STOP) ? m_linearLimits.m_stopERP[i] : info->erp; + if (m_useOffsetForConstraintFrame) + { + int indx1 = (i + 1) % 3; + int indx2 = (i + 2) % 3; + int rotAllowed = 1; // rotations around orthos to current axis + if (m_angularLimits[indx1].m_currentLimit && m_angularLimits[indx2].m_currentLimit) + { + rotAllowed = 0; + } + row += get_limit_motor_info2(&limot, transA, transB, linVelA, linVelB, angVelA, angVelB, info, row, axis, 0, rotAllowed); + } + else + { + row += get_limit_motor_info2(&limot, transA, transB, linVelA, linVelB, angVelA, angVelB, info, row, axis, 0); + } + } + } + return row; +} + +int btGeneric6DofConstraint::setAngularLimits(btConstraintInfo2* info, int row_offset, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB) +{ + btGeneric6DofConstraint* d6constraint = this; + int row = row_offset; + //solve angular limits + for (int i = 0; i < 3; i++) + { + if (d6constraint->getRotationalLimitMotor(i)->needApplyTorques()) + { + btVector3 axis = d6constraint->getAxis(i); + int flags = m_flags >> ((i + 3) * BT_6DOF_FLAGS_AXIS_SHIFT); + if (!(flags & BT_6DOF_FLAGS_CFM_NORM)) + { + m_angularLimits[i].m_normalCFM = info->cfm[0]; + } + if (!(flags & BT_6DOF_FLAGS_CFM_STOP)) + { + m_angularLimits[i].m_stopCFM = info->cfm[0]; + } + if (!(flags & BT_6DOF_FLAGS_ERP_STOP)) + { + m_angularLimits[i].m_stopERP = info->erp; + } + row += get_limit_motor_info2(d6constraint->getRotationalLimitMotor(i), + transA, transB, linVelA, linVelB, angVelA, angVelB, info, row, axis, 1); + } + } + + return row; +} + +void btGeneric6DofConstraint::updateRHS(btScalar timeStep) +{ + (void)timeStep; +} + +void btGeneric6DofConstraint::setFrames(const btTransform& frameA, const btTransform& frameB) +{ + m_frameInA = frameA; + m_frameInB = frameB; + buildJacobian(); + calculateTransforms(); +} + +btVector3 btGeneric6DofConstraint::getAxis(int axis_index) const +{ + return m_calculatedAxis[axis_index]; +} + +btScalar btGeneric6DofConstraint::getRelativePivotPosition(int axisIndex) const +{ + return m_calculatedLinearDiff[axisIndex]; +} + +btScalar btGeneric6DofConstraint::getAngle(int axisIndex) const +{ + return m_calculatedAxisAngleDiff[axisIndex]; +} + +void btGeneric6DofConstraint::calcAnchorPos(void) +{ + btScalar imA = m_rbA.getInvMass(); + btScalar imB = m_rbB.getInvMass(); + btScalar weight; + if (imB == btScalar(0.0)) + { + weight = btScalar(1.0); + } + else + { + weight = imA / (imA + imB); + } + const btVector3& pA = m_calculatedTransformA.getOrigin(); + const btVector3& pB = m_calculatedTransformB.getOrigin(); + m_AnchorPos = pA * weight + pB * (btScalar(1.0) - weight); + return; +} + +void btGeneric6DofConstraint::calculateLinearInfo() +{ + m_calculatedLinearDiff = m_calculatedTransformB.getOrigin() - m_calculatedTransformA.getOrigin(); + m_calculatedLinearDiff = m_calculatedTransformA.getBasis().inverse() * m_calculatedLinearDiff; + for (int i = 0; i < 3; i++) + { + m_linearLimits.m_currentLinearDiff[i] = m_calculatedLinearDiff[i]; + m_linearLimits.testLimitValue(i, m_calculatedLinearDiff[i]); + } +} + +int btGeneric6DofConstraint::get_limit_motor_info2( + btRotationalLimitMotor* limot, + const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB, + btConstraintInfo2* info, int row, btVector3& ax1, int rotational, int rotAllowed) +{ + int srow = row * info->rowskip; + bool powered = limot->m_enableMotor; + int limit = limot->m_currentLimit; + if (powered || limit) + { // if the joint is powered, or has joint limits, add in the extra row + btScalar* J1 = rotational ? info->m_J1angularAxis : info->m_J1linearAxis; + btScalar* J2 = rotational ? info->m_J2angularAxis : info->m_J2linearAxis; + J1[srow + 0] = ax1[0]; + J1[srow + 1] = ax1[1]; + J1[srow + 2] = ax1[2]; + + J2[srow + 0] = -ax1[0]; + J2[srow + 1] = -ax1[1]; + J2[srow + 2] = -ax1[2]; + + if ((!rotational)) + { + if (m_useOffsetForConstraintFrame) + { + btVector3 tmpA, tmpB, relA, relB; + // get vector from bodyB to frameB in WCS + relB = m_calculatedTransformB.getOrigin() - transB.getOrigin(); + // get its projection to constraint axis + btVector3 projB = ax1 * relB.dot(ax1); + // get vector directed from bodyB to constraint axis (and orthogonal to it) + btVector3 orthoB = relB - projB; + // same for bodyA + relA = m_calculatedTransformA.getOrigin() - transA.getOrigin(); + btVector3 projA = ax1 * relA.dot(ax1); + btVector3 orthoA = relA - projA; + // get desired offset between frames A and B along constraint axis + btScalar desiredOffs = limot->m_currentPosition - limot->m_currentLimitError; + // desired vector from projection of center of bodyA to projection of center of bodyB to constraint axis + btVector3 totalDist = projA + ax1 * desiredOffs - projB; + // get offset vectors relA and relB + relA = orthoA + totalDist * m_factA; + relB = orthoB - totalDist * m_factB; + tmpA = relA.cross(ax1); + tmpB = relB.cross(ax1); + if (m_hasStaticBody && (!rotAllowed)) + { + tmpA *= m_factA; + tmpB *= m_factB; + } + int i; + for (i = 0; i < 3; i++) info->m_J1angularAxis[srow + i] = tmpA[i]; + for (i = 0; i < 3; i++) info->m_J2angularAxis[srow + i] = -tmpB[i]; + } + else + { + btVector3 ltd; // Linear Torque Decoupling vector + btVector3 c = m_calculatedTransformB.getOrigin() - transA.getOrigin(); + ltd = c.cross(ax1); + info->m_J1angularAxis[srow + 0] = ltd[0]; + info->m_J1angularAxis[srow + 1] = ltd[1]; + info->m_J1angularAxis[srow + 2] = ltd[2]; + + c = m_calculatedTransformB.getOrigin() - transB.getOrigin(); + ltd = -c.cross(ax1); + info->m_J2angularAxis[srow + 0] = ltd[0]; + info->m_J2angularAxis[srow + 1] = ltd[1]; + info->m_J2angularAxis[srow + 2] = ltd[2]; + } + } + // if we're limited low and high simultaneously, the joint motor is + // ineffective + if (limit && (limot->m_loLimit == limot->m_hiLimit)) powered = false; + info->m_constraintError[srow] = btScalar(0.f); + if (powered) + { + info->cfm[srow] = limot->m_normalCFM; + if (!limit) + { + btScalar tag_vel = rotational ? limot->m_targetVelocity : -limot->m_targetVelocity; + + btScalar mot_fact = getMotorFactor(limot->m_currentPosition, + limot->m_loLimit, + limot->m_hiLimit, + tag_vel, + info->fps * limot->m_stopERP); + info->m_constraintError[srow] += mot_fact * limot->m_targetVelocity; + info->m_lowerLimit[srow] = -limot->m_maxMotorForce / info->fps; + info->m_upperLimit[srow] = limot->m_maxMotorForce / info->fps; + } + } + if (limit) + { + btScalar k = info->fps * limot->m_stopERP; + if (!rotational) + { + info->m_constraintError[srow] += k * limot->m_currentLimitError; + } + else + { + info->m_constraintError[srow] += -k * limot->m_currentLimitError; + } + info->cfm[srow] = limot->m_stopCFM; + if (limot->m_loLimit == limot->m_hiLimit) + { // limited low and high simultaneously + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + else + { + if (limit == 1) + { + info->m_lowerLimit[srow] = 0; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + else + { + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = 0; + } + // deal with bounce + if (limot->m_bounce > 0) + { + // calculate joint velocity + btScalar vel; + if (rotational) + { + vel = angVelA.dot(ax1); + //make sure that if no body -> angVelB == zero vec + // if (body1) + vel -= angVelB.dot(ax1); + } + else + { + vel = linVelA.dot(ax1); + //make sure that if no body -> angVelB == zero vec + // if (body1) + vel -= linVelB.dot(ax1); + } + // only apply bounce if the velocity is incoming, and if the + // resulting c[] exceeds what we already have. + if (limit == 1) + { + if (vel < 0) + { + btScalar newc = -limot->m_bounce * vel; + if (newc > info->m_constraintError[srow]) + info->m_constraintError[srow] = newc; + } + } + else + { + if (vel > 0) + { + btScalar newc = -limot->m_bounce * vel; + if (newc < info->m_constraintError[srow]) + info->m_constraintError[srow] = newc; + } + } + } + } + } + return 1; + } + else + return 0; +} + +///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). +///If no axis is provided, it uses the default axis for this constraint. +void btGeneric6DofConstraint::setParam(int num, btScalar value, int axis) +{ + if ((axis >= 0) && (axis < 3)) + { + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + m_linearLimits.m_stopERP[axis] = value; + m_flags |= BT_6DOF_FLAGS_ERP_STOP << (axis * BT_6DOF_FLAGS_AXIS_SHIFT); + break; + case BT_CONSTRAINT_STOP_CFM: + m_linearLimits.m_stopCFM[axis] = value; + m_flags |= BT_6DOF_FLAGS_CFM_STOP << (axis * BT_6DOF_FLAGS_AXIS_SHIFT); + break; + case BT_CONSTRAINT_CFM: + m_linearLimits.m_normalCFM[axis] = value; + m_flags |= BT_6DOF_FLAGS_CFM_NORM << (axis * BT_6DOF_FLAGS_AXIS_SHIFT); + break; + default: + btAssertConstrParams(0); + } + } + else if ((axis >= 3) && (axis < 6)) + { + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + m_angularLimits[axis - 3].m_stopERP = value; + m_flags |= BT_6DOF_FLAGS_ERP_STOP << (axis * BT_6DOF_FLAGS_AXIS_SHIFT); + break; + case BT_CONSTRAINT_STOP_CFM: + m_angularLimits[axis - 3].m_stopCFM = value; + m_flags |= BT_6DOF_FLAGS_CFM_STOP << (axis * BT_6DOF_FLAGS_AXIS_SHIFT); + break; + case BT_CONSTRAINT_CFM: + m_angularLimits[axis - 3].m_normalCFM = value; + m_flags |= BT_6DOF_FLAGS_CFM_NORM << (axis * BT_6DOF_FLAGS_AXIS_SHIFT); + break; + default: + btAssertConstrParams(0); + } + } + else + { + btAssertConstrParams(0); + } +} + +///return the local value of parameter +btScalar btGeneric6DofConstraint::getParam(int num, int axis) const +{ + btScalar retVal = 0; + if ((axis >= 0) && (axis < 3)) + { + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_ERP_STOP << (axis * BT_6DOF_FLAGS_AXIS_SHIFT))); + retVal = m_linearLimits.m_stopERP[axis]; + break; + case BT_CONSTRAINT_STOP_CFM: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_CFM_STOP << (axis * BT_6DOF_FLAGS_AXIS_SHIFT))); + retVal = m_linearLimits.m_stopCFM[axis]; + break; + case BT_CONSTRAINT_CFM: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_CFM_NORM << (axis * BT_6DOF_FLAGS_AXIS_SHIFT))); + retVal = m_linearLimits.m_normalCFM[axis]; + break; + default: + btAssertConstrParams(0); + } + } + else if ((axis >= 3) && (axis < 6)) + { + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_ERP_STOP << (axis * BT_6DOF_FLAGS_AXIS_SHIFT))); + retVal = m_angularLimits[axis - 3].m_stopERP; + break; + case BT_CONSTRAINT_STOP_CFM: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_CFM_STOP << (axis * BT_6DOF_FLAGS_AXIS_SHIFT))); + retVal = m_angularLimits[axis - 3].m_stopCFM; + break; + case BT_CONSTRAINT_CFM: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_CFM_NORM << (axis * BT_6DOF_FLAGS_AXIS_SHIFT))); + retVal = m_angularLimits[axis - 3].m_normalCFM; + break; + default: + btAssertConstrParams(0); + } + } + else + { + btAssertConstrParams(0); + } + return retVal; +} + +void btGeneric6DofConstraint::setAxis(const btVector3& axis1, const btVector3& axis2) +{ + btVector3 zAxis = axis1.normalized(); + btVector3 yAxis = axis2.normalized(); + btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system + + btTransform frameInW; + frameInW.setIdentity(); + frameInW.getBasis().setValue(xAxis[0], yAxis[0], zAxis[0], + xAxis[1], yAxis[1], zAxis[1], + xAxis[2], yAxis[2], zAxis[2]); + + // now get constraint frame in local coordinate systems + m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW; + m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW; + + calculateTransforms(); +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp.i new file mode 100644 index 00000000..c2770999 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp ---------------- + +// %include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h new file mode 100644 index 00000000..1febc2bc --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h @@ -0,0 +1,615 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/// 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev +/// Added support for generic constraint solver through getInfo1/getInfo2 methods + +/* +2007-09-09 +btGeneric6DofConstraint Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ + +#ifndef BT_GENERIC_6DOF_CONSTRAINT_H +#define BT_GENERIC_6DOF_CONSTRAINT_H + +#include "LinearMath/btVector3.h" +#include "btJacobianEntry.h" +#include "btTypedConstraint.h" + +class btRigidBody; + +#ifdef BT_USE_DOUBLE_PRECISION +#define btGeneric6DofConstraintData2 btGeneric6DofConstraintDoubleData2 +#define btGeneric6DofConstraintDataName "btGeneric6DofConstraintDoubleData2" +#else +#define btGeneric6DofConstraintData2 btGeneric6DofConstraintData +#define btGeneric6DofConstraintDataName "btGeneric6DofConstraintData" +#endif //BT_USE_DOUBLE_PRECISION + +//! Rotation Limit structure for generic joints +class btRotationalLimitMotor +{ +public: + //! limit_parameters + //!@{ + btScalar m_loLimit; //!< joint limit + btScalar m_hiLimit; //!< joint limit + btScalar m_targetVelocity; //!< target motor velocity + btScalar m_maxMotorForce; //!< max force on motor + btScalar m_maxLimitForce; //!< max force on limit + btScalar m_damping; //!< Damping. + btScalar m_limitSoftness; //! Relaxation factor + btScalar m_normalCFM; //!< Constraint force mixing factor + btScalar m_stopERP; //!< Error tolerance factor when joint is at limit + btScalar m_stopCFM; //!< Constraint force mixing factor when joint is at limit + btScalar m_bounce; //!< restitution factor + bool m_enableMotor; + + //!@} + + //! temp_variables + //!@{ + btScalar m_currentLimitError; //! How much is violated this limit + btScalar m_currentPosition; //! current value of angle + int m_currentLimit; //!< 0=free, 1=at lo limit, 2=at hi limit + btScalar m_accumulatedImpulse; + //!@} + + btRotationalLimitMotor() + { + m_accumulatedImpulse = 0.f; + m_targetVelocity = 0; + m_maxMotorForce = 6.0f; + m_maxLimitForce = 300.0f; + m_loLimit = 1.0f; + m_hiLimit = -1.0f; + m_normalCFM = 0.f; + m_stopERP = 0.2f; + m_stopCFM = 0.f; + m_bounce = 0.0f; + m_damping = 1.0f; + m_limitSoftness = 0.5f; + m_currentLimit = 0; + m_currentLimitError = 0; + m_enableMotor = false; + } + + btRotationalLimitMotor(const btRotationalLimitMotor& limot) + { + m_targetVelocity = limot.m_targetVelocity; + m_maxMotorForce = limot.m_maxMotorForce; + m_limitSoftness = limot.m_limitSoftness; + m_loLimit = limot.m_loLimit; + m_hiLimit = limot.m_hiLimit; + m_normalCFM = limot.m_normalCFM; + m_stopERP = limot.m_stopERP; + m_stopCFM = limot.m_stopCFM; + m_bounce = limot.m_bounce; + m_currentLimit = limot.m_currentLimit; + m_currentLimitError = limot.m_currentLimitError; + m_enableMotor = limot.m_enableMotor; + } + + //! Is limited + bool isLimited() const + { + if (m_loLimit > m_hiLimit) return false; + return true; + } + + //! Need apply correction + bool needApplyTorques() const + { + if (m_currentLimit == 0 && m_enableMotor == false) return false; + return true; + } + + //! calculates error + /*! + calculates m_currentLimit and m_currentLimitError. + */ + int testLimitValue(btScalar test_value); + + //! apply the correction impulses for two bodies + btScalar solveAngularLimits(btScalar timeStep, btVector3& axis, btScalar jacDiagABInv, btRigidBody* body0, btRigidBody* body1); +}; + +class btTranslationalLimitMotor +{ +public: + btVector3 m_lowerLimit; //!< the constraint lower limits + btVector3 m_upperLimit; //!< the constraint upper limits + btVector3 m_accumulatedImpulse; + //! Linear_Limit_parameters + //!@{ + btScalar m_limitSoftness; //!< Softness for linear limit + btScalar m_damping; //!< Damping for linear limit + btScalar m_restitution; //! Bounce parameter for linear limit + btVector3 m_normalCFM; //!< Constraint force mixing factor + btVector3 m_stopERP; //!< Error tolerance factor when joint is at limit + btVector3 m_stopCFM; //!< Constraint force mixing factor when joint is at limit + //!@} + bool m_enableMotor[3]; + btVector3 m_targetVelocity; //!< target motor velocity + btVector3 m_maxMotorForce; //!< max force on motor + btVector3 m_currentLimitError; //! How much is violated this limit + btVector3 m_currentLinearDiff; //! Current relative offset of constraint frames + int m_currentLimit[3]; //!< 0=free, 1=at lower limit, 2=at upper limit + + btTranslationalLimitMotor() + { + m_lowerLimit.setValue(0.f, 0.f, 0.f); + m_upperLimit.setValue(0.f, 0.f, 0.f); + m_accumulatedImpulse.setValue(0.f, 0.f, 0.f); + m_normalCFM.setValue(0.f, 0.f, 0.f); + m_stopERP.setValue(0.2f, 0.2f, 0.2f); + m_stopCFM.setValue(0.f, 0.f, 0.f); + + m_limitSoftness = 0.7f; + m_damping = btScalar(1.0f); + m_restitution = btScalar(0.5f); + for (int i = 0; i < 3; i++) + { + m_enableMotor[i] = false; + m_targetVelocity[i] = btScalar(0.f); + m_maxMotorForce[i] = btScalar(0.f); + } + } + + btTranslationalLimitMotor(const btTranslationalLimitMotor& other) + { + m_lowerLimit = other.m_lowerLimit; + m_upperLimit = other.m_upperLimit; + m_accumulatedImpulse = other.m_accumulatedImpulse; + + m_limitSoftness = other.m_limitSoftness; + m_damping = other.m_damping; + m_restitution = other.m_restitution; + m_normalCFM = other.m_normalCFM; + m_stopERP = other.m_stopERP; + m_stopCFM = other.m_stopCFM; + + for (int i = 0; i < 3; i++) + { + m_enableMotor[i] = other.m_enableMotor[i]; + m_targetVelocity[i] = other.m_targetVelocity[i]; + m_maxMotorForce[i] = other.m_maxMotorForce[i]; + } + } + + //! Test limit + /*! + - free means upper < lower, + - locked means upper == lower + - limited means upper > lower + - limitIndex: first 3 are linear, next 3 are angular + */ + inline bool isLimited(int limitIndex) const + { + return (m_upperLimit[limitIndex] >= m_lowerLimit[limitIndex]); + } + inline bool needApplyForce(int limitIndex) const + { + if (m_currentLimit[limitIndex] == 0 && m_enableMotor[limitIndex] == false) return false; + return true; + } + int testLimitValue(int limitIndex, btScalar test_value); + + btScalar solveLinearAxis( + btScalar timeStep, + btScalar jacDiagABInv, + btRigidBody& body1, const btVector3& pointInA, + btRigidBody& body2, const btVector3& pointInB, + int limit_index, + const btVector3& axis_normal_on_a, + const btVector3& anchorPos); +}; + +enum bt6DofFlags +{ + BT_6DOF_FLAGS_CFM_NORM = 1, + BT_6DOF_FLAGS_CFM_STOP = 2, + BT_6DOF_FLAGS_ERP_STOP = 4 +}; +#define BT_6DOF_FLAGS_AXIS_SHIFT 3 // bits per axis + +/// btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space +/*! +btGeneric6DofConstraint can leave any of the 6 degree of freedom 'free' or 'locked'. +currently this limit supports rotational motors
+
    +
  • For Linear limits, use btGeneric6DofConstraint.setLinearUpperLimit, btGeneric6DofConstraint.setLinearLowerLimit. You can set the parameters with the btTranslationalLimitMotor structure accsesible through the btGeneric6DofConstraint.getTranslationalLimitMotor method. +At this moment translational motors are not supported. May be in the future.
    • + +
  • For Angular limits, use the btRotationalLimitMotor structure for configuring the limit. +This is accessible through btGeneric6DofConstraint.getLimitMotor method, +This brings support for limit parameters and motors.
    • + +
  • Angulars limits have these possible ranges: + + + + + + + + + + + + + + + + + + +
    AXISMIN ANGLEMAX ANGLE
    X-PIPI
    Y-PI/2PI/2
    Z-PIPI
    +
    • +
+ +*/ +ATTRIBUTE_ALIGNED16(class) +btGeneric6DofConstraint : public btTypedConstraint +{ +protected: + //! relative_frames + //!@{ + btTransform m_frameInA; //!< the constraint space w.r.t body A + btTransform m_frameInB; //!< the constraint space w.r.t body B + //!@} + + //! Jacobians + //!@{ + btJacobianEntry m_jacLinear[3]; //!< 3 orthogonal linear constraints + btJacobianEntry m_jacAng[3]; //!< 3 orthogonal angular constraints + //!@} + + //! Linear_Limit_parameters + //!@{ + btTranslationalLimitMotor m_linearLimits; + //!@} + + //! hinge_parameters + //!@{ + btRotationalLimitMotor m_angularLimits[3]; + //!@} + +protected: + //! temporal variables + //!@{ + btScalar m_timeStep; + btTransform m_calculatedTransformA; + btTransform m_calculatedTransformB; + btVector3 m_calculatedAxisAngleDiff; + btVector3 m_calculatedAxis[3]; + btVector3 m_calculatedLinearDiff; + btScalar m_factA; + btScalar m_factB; + bool m_hasStaticBody; + + btVector3 m_AnchorPos; // point betwen pivots of bodies A and B to solve linear axes + + bool m_useLinearReferenceFrameA; + bool m_useOffsetForConstraintFrame; + + int m_flags; + + //!@} + + btGeneric6DofConstraint& operator=(btGeneric6DofConstraint& other) + { + btAssert(0); + (void)other; + return *this; + } + + int setAngularLimits(btConstraintInfo2 * info, int row_offset, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB); + + int setLinearLimits(btConstraintInfo2 * info, int row, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB); + + void buildLinearJacobian( + btJacobianEntry & jacLinear, const btVector3& normalWorld, + const btVector3& pivotAInW, const btVector3& pivotBInW); + + void buildAngularJacobian(btJacobianEntry & jacAngular, const btVector3& jointAxisW); + + // tests linear limits + void calculateLinearInfo(); + + //! calcs the euler angles between the two bodies. + void calculateAngleInfo(); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + ///for backwards compatibility during the transition to 'getInfo/getInfo2' + bool m_useSolveConstraintObsolete; + + btGeneric6DofConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA); + btGeneric6DofConstraint(btRigidBody & rbB, const btTransform& frameInB, bool useLinearReferenceFrameB); + + //! Calcs global transform of the offsets + /*! + Calcs the global transform for the joint offset for body A an B, and also calcs the agle differences between the bodies. + \sa btGeneric6DofConstraint.getCalculatedTransformA , btGeneric6DofConstraint.getCalculatedTransformB, btGeneric6DofConstraint.calculateAngleInfo + */ + void calculateTransforms(const btTransform& transA, const btTransform& transB); + + void calculateTransforms(); + + //! Gets the global transform of the offset for body A + /*! + \sa btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo. + */ + const btTransform& getCalculatedTransformA() const + { + return m_calculatedTransformA; + } + + //! Gets the global transform of the offset for body B + /*! + \sa btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo. + */ + const btTransform& getCalculatedTransformB() const + { + return m_calculatedTransformB; + } + + const btTransform& getFrameOffsetA() const + { + return m_frameInA; + } + + const btTransform& getFrameOffsetB() const + { + return m_frameInB; + } + + btTransform& getFrameOffsetA() + { + return m_frameInA; + } + + btTransform& getFrameOffsetB() + { + return m_frameInB; + } + + //! performs Jacobian calculation, and also calculates angle differences and axis + virtual void buildJacobian(); + + virtual void getInfo1(btConstraintInfo1 * info); + + void getInfo1NonVirtual(btConstraintInfo1 * info); + + virtual void getInfo2(btConstraintInfo2 * info); + + void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB); + + void updateRHS(btScalar timeStep); + + //! Get the rotation axis in global coordinates + /*! + \pre btGeneric6DofConstraint.buildJacobian must be called previously. + */ + btVector3 getAxis(int axis_index) const; + + //! Get the relative Euler angle + /*! + \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. + */ + btScalar getAngle(int axis_index) const; + + //! Get the relative position of the constraint pivot + /*! + \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. + */ + btScalar getRelativePivotPosition(int axis_index) const; + + void setFrames(const btTransform& frameA, const btTransform& frameB); + + //! Test angular limit. + /*! + Calculates angular correction and returns true if limit needs to be corrected. + \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. + */ + bool testAngularLimitMotor(int axis_index); + + void setLinearLowerLimit(const btVector3& linearLower) + { + m_linearLimits.m_lowerLimit = linearLower; + } + + void getLinearLowerLimit(btVector3 & linearLower) const + { + linearLower = m_linearLimits.m_lowerLimit; + } + + void setLinearUpperLimit(const btVector3& linearUpper) + { + m_linearLimits.m_upperLimit = linearUpper; + } + + void getLinearUpperLimit(btVector3 & linearUpper) const + { + linearUpper = m_linearLimits.m_upperLimit; + } + + void setAngularLowerLimit(const btVector3& angularLower) + { + for (int i = 0; i < 3; i++) + m_angularLimits[i].m_loLimit = btNormalizeAngle(angularLower[i]); + } + + void getAngularLowerLimit(btVector3 & angularLower) const + { + for (int i = 0; i < 3; i++) + angularLower[i] = m_angularLimits[i].m_loLimit; + } + + void setAngularUpperLimit(const btVector3& angularUpper) + { + for (int i = 0; i < 3; i++) + m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]); + } + + void getAngularUpperLimit(btVector3 & angularUpper) const + { + for (int i = 0; i < 3; i++) + angularUpper[i] = m_angularLimits[i].m_hiLimit; + } + + //! Retrieves the angular limit informacion + btRotationalLimitMotor* getRotationalLimitMotor(int index) + { + return &m_angularLimits[index]; + } + + //! Retrieves the limit informacion + btTranslationalLimitMotor* getTranslationalLimitMotor() + { + return &m_linearLimits; + } + + //first 3 are linear, next 3 are angular + void setLimit(int axis, btScalar lo, btScalar hi) + { + if (axis < 3) + { + m_linearLimits.m_lowerLimit[axis] = lo; + m_linearLimits.m_upperLimit[axis] = hi; + } + else + { + lo = btNormalizeAngle(lo); + hi = btNormalizeAngle(hi); + m_angularLimits[axis - 3].m_loLimit = lo; + m_angularLimits[axis - 3].m_hiLimit = hi; + } + } + + //! Test limit + /*! + - free means upper < lower, + - locked means upper == lower + - limited means upper > lower + - limitIndex: first 3 are linear, next 3 are angular + */ + bool isLimited(int limitIndex) const + { + if (limitIndex < 3) + { + return m_linearLimits.isLimited(limitIndex); + } + return m_angularLimits[limitIndex - 3].isLimited(); + } + + virtual void calcAnchorPos(void); // overridable + + int get_limit_motor_info2(btRotationalLimitMotor * limot, + const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB, + btConstraintInfo2* info, int row, btVector3& ax1, int rotational, int rotAllowed = false); + + // access for UseFrameOffset + bool getUseFrameOffset() const { return m_useOffsetForConstraintFrame; } + void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; } + + bool getUseLinearReferenceFrameA() const { return m_useLinearReferenceFrameA; } + void setUseLinearReferenceFrameA(bool linearReferenceFrameA) { m_useLinearReferenceFrameA = linearReferenceFrameA; } + + ///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + ///If no axis is provided, it uses the default axis for this constraint. + virtual void setParam(int num, btScalar value, int axis = -1); + ///return the local value of parameter + virtual btScalar getParam(int num, int axis = -1) const; + + void setAxis(const btVector3& axis1, const btVector3& axis2); + + virtual int getFlags() const + { + return m_flags; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +struct btGeneric6DofConstraintData +{ + btTypedConstraintData m_typeConstraintData; + btTransformFloatData m_rbAFrame; // constraint axii. Assumes z is hinge axis. + btTransformFloatData m_rbBFrame; + + btVector3FloatData m_linearUpperLimit; + btVector3FloatData m_linearLowerLimit; + + btVector3FloatData m_angularUpperLimit; + btVector3FloatData m_angularLowerLimit; + + int m_useLinearReferenceFrameA; + int m_useOffsetForConstraintFrame; +}; + +struct btGeneric6DofConstraintDoubleData2 +{ + btTypedConstraintDoubleData m_typeConstraintData; + btTransformDoubleData m_rbAFrame; // constraint axii. Assumes z is hinge axis. + btTransformDoubleData m_rbBFrame; + + btVector3DoubleData m_linearUpperLimit; + btVector3DoubleData m_linearLowerLimit; + + btVector3DoubleData m_angularUpperLimit; + btVector3DoubleData m_angularLowerLimit; + + int m_useLinearReferenceFrameA; + int m_useOffsetForConstraintFrame; +}; + +SIMD_FORCE_INLINE int btGeneric6DofConstraint::calculateSerializeBufferSize() const +{ + return sizeof(btGeneric6DofConstraintData2); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btGeneric6DofConstraint::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btGeneric6DofConstraintData2* dof = (btGeneric6DofConstraintData2*)dataBuffer; + btTypedConstraint::serialize(&dof->m_typeConstraintData, serializer); + + m_frameInA.serialize(dof->m_rbAFrame); + m_frameInB.serialize(dof->m_rbBFrame); + + int i; + for (i = 0; i < 3; i++) + { + dof->m_angularLowerLimit.m_floats[i] = m_angularLimits[i].m_loLimit; + dof->m_angularUpperLimit.m_floats[i] = m_angularLimits[i].m_hiLimit; + dof->m_linearLowerLimit.m_floats[i] = m_linearLimits.m_lowerLimit[i]; + dof->m_linearUpperLimit.m_floats[i] = m_linearLimits.m_upperLimit[i]; + } + + dof->m_useLinearReferenceFrameA = m_useLinearReferenceFrameA ? 1 : 0; + dof->m_useOffsetForConstraintFrame = m_useOffsetForConstraintFrame ? 1 : 0; + + return btGeneric6DofConstraintDataName; +} + +#endif //BT_GENERIC_6DOF_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h.i new file mode 100644 index 00000000..8b6d4702 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp new file mode 100644 index 00000000..39e0cc0a --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp @@ -0,0 +1,1243 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +2014 May: btGeneric6DofSpring2Constraint is created from the original (2.82.2712) btGeneric6DofConstraint by Gabor Puhr and Tamas Umenhoffer +Pros: +- Much more accurate and stable in a lot of situation. (Especially when a sleeping chain of RBs connected with 6dof2 is pulled) +- Stable and accurate spring with minimal energy loss that works with all of the solvers. (latter is not true for the original 6dof spring) +- Servo motor functionality +- Much more accurate bouncing. 0 really means zero bouncing (not true for the original 6odf) and there is only a minimal energy loss when the value is 1 (because of the solvers' precision) +- Rotation order for the Euler system can be set. (One axis' freedom is still limited to pi/2) + +Cons: +- It is slower than the original 6dof. There is no exact ratio, but half speed is a good estimation. (with PGS) +- At bouncing the correct velocity is calculated, but not the correct position. (it is because of the solver can correct position or velocity, but not both.) +*/ + +/// 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev +/// Added support for generic constraint solver through getInfo1/getInfo2 methods + +/* +2007-09-09 +btGeneric6DofConstraint Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ + +#include "btGeneric6DofSpring2Constraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btTransformUtil.h" +#include +#include + +btGeneric6DofSpring2Constraint::btGeneric6DofSpring2Constraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, RotateOrder rotOrder) + : btTypedConstraint(D6_SPRING_2_CONSTRAINT_TYPE, rbA, rbB), m_frameInA(frameInA), m_frameInB(frameInB), m_rotateOrder(rotOrder), m_flags(0) +{ + calculateTransforms(); +} + +btGeneric6DofSpring2Constraint::btGeneric6DofSpring2Constraint(btRigidBody& rbB, const btTransform& frameInB, RotateOrder rotOrder) + : btTypedConstraint(D6_SPRING_2_CONSTRAINT_TYPE, getFixedBody(), rbB), m_frameInB(frameInB), m_rotateOrder(rotOrder), m_flags(0) +{ + ///not providing rigidbody A means implicitly using worldspace for body A + m_frameInA = rbB.getCenterOfMassTransform() * m_frameInB; + calculateTransforms(); +} + +btScalar btGeneric6DofSpring2Constraint::btGetMatrixElem(const btMatrix3x3& mat, int index) +{ + int i = index % 3; + int j = index / 3; + return mat[i][j]; +} + +// MatrixToEulerXYZ from http://www.geometrictools.com/LibFoundation/Mathematics/Wm4Matrix3.inl.html + +bool btGeneric6DofSpring2Constraint::matrixToEulerXYZ(const btMatrix3x3& mat, btVector3& xyz) +{ + // rot = cy*cz -cy*sz sy + // cz*sx*sy+cx*sz cx*cz-sx*sy*sz -cy*sx + // -cx*cz*sy+sx*sz cz*sx+cx*sy*sz cx*cy + + btScalar fi = btGetMatrixElem(mat, 2); + if (fi < btScalar(1.0f)) + { + if (fi > btScalar(-1.0f)) + { + xyz[0] = btAtan2(-btGetMatrixElem(mat, 5), btGetMatrixElem(mat, 8)); + xyz[1] = btAsin(btGetMatrixElem(mat, 2)); + xyz[2] = btAtan2(-btGetMatrixElem(mat, 1), btGetMatrixElem(mat, 0)); + return true; + } + else + { + // WARNING. Not unique. XA - ZA = -atan2(r10,r11) + xyz[0] = -btAtan2(btGetMatrixElem(mat, 3), btGetMatrixElem(mat, 4)); + xyz[1] = -SIMD_HALF_PI; + xyz[2] = btScalar(0.0); + return false; + } + } + else + { + // WARNING. Not unique. XAngle + ZAngle = atan2(r10,r11) + xyz[0] = btAtan2(btGetMatrixElem(mat, 3), btGetMatrixElem(mat, 4)); + xyz[1] = SIMD_HALF_PI; + xyz[2] = 0.0; + } + return false; +} + +bool btGeneric6DofSpring2Constraint::matrixToEulerXZY(const btMatrix3x3& mat, btVector3& xyz) +{ + // rot = cy*cz -sz sy*cz + // cy*cx*sz+sx*sy cx*cz sy*cx*sz-cy*sx + // cy*sx*sz-cx*sy sx*cz sy*sx*sz+cx*cy + + btScalar fi = btGetMatrixElem(mat, 1); + if (fi < btScalar(1.0f)) + { + if (fi > btScalar(-1.0f)) + { + xyz[0] = btAtan2(btGetMatrixElem(mat, 7), btGetMatrixElem(mat, 4)); + xyz[1] = btAtan2(btGetMatrixElem(mat, 2), btGetMatrixElem(mat, 0)); + xyz[2] = btAsin(-btGetMatrixElem(mat, 1)); + return true; + } + else + { + xyz[0] = -btAtan2(-btGetMatrixElem(mat, 6), btGetMatrixElem(mat, 8)); + xyz[1] = btScalar(0.0); + xyz[2] = SIMD_HALF_PI; + return false; + } + } + else + { + xyz[0] = btAtan2(-btGetMatrixElem(mat, 6), btGetMatrixElem(mat, 8)); + xyz[1] = 0.0; + xyz[2] = -SIMD_HALF_PI; + } + return false; +} + +bool btGeneric6DofSpring2Constraint::matrixToEulerYXZ(const btMatrix3x3& mat, btVector3& xyz) +{ + // rot = cy*cz+sy*sx*sz cz*sy*sx-cy*sz cx*sy + // cx*sz cx*cz -sx + // cy*sx*sz-cz*sy sy*sz+cy*cz*sx cy*cx + + btScalar fi = btGetMatrixElem(mat, 5); + if (fi < btScalar(1.0f)) + { + if (fi > btScalar(-1.0f)) + { + xyz[0] = btAsin(-btGetMatrixElem(mat, 5)); + xyz[1] = btAtan2(btGetMatrixElem(mat, 2), btGetMatrixElem(mat, 8)); + xyz[2] = btAtan2(btGetMatrixElem(mat, 3), btGetMatrixElem(mat, 4)); + return true; + } + else + { + xyz[0] = SIMD_HALF_PI; + xyz[1] = -btAtan2(-btGetMatrixElem(mat, 1), btGetMatrixElem(mat, 0)); + xyz[2] = btScalar(0.0); + return false; + } + } + else + { + xyz[0] = -SIMD_HALF_PI; + xyz[1] = btAtan2(-btGetMatrixElem(mat, 1), btGetMatrixElem(mat, 0)); + xyz[2] = 0.0; + } + return false; +} + +bool btGeneric6DofSpring2Constraint::matrixToEulerYZX(const btMatrix3x3& mat, btVector3& xyz) +{ + // rot = cy*cz sy*sx-cy*cx*sz cx*sy+cy*sz*sx + // sz cz*cx -cz*sx + // -cz*sy cy*sx+cx*sy*sz cy*cx-sy*sz*sx + + btScalar fi = btGetMatrixElem(mat, 3); + if (fi < btScalar(1.0f)) + { + if (fi > btScalar(-1.0f)) + { + xyz[0] = btAtan2(-btGetMatrixElem(mat, 5), btGetMatrixElem(mat, 4)); + xyz[1] = btAtan2(-btGetMatrixElem(mat, 6), btGetMatrixElem(mat, 0)); + xyz[2] = btAsin(btGetMatrixElem(mat, 3)); + return true; + } + else + { + xyz[0] = btScalar(0.0); + xyz[1] = -btAtan2(btGetMatrixElem(mat, 7), btGetMatrixElem(mat, 8)); + xyz[2] = -SIMD_HALF_PI; + return false; + } + } + else + { + xyz[0] = btScalar(0.0); + xyz[1] = btAtan2(btGetMatrixElem(mat, 7), btGetMatrixElem(mat, 8)); + xyz[2] = SIMD_HALF_PI; + } + return false; +} + +bool btGeneric6DofSpring2Constraint::matrixToEulerZXY(const btMatrix3x3& mat, btVector3& xyz) +{ + // rot = cz*cy-sz*sx*sy -cx*sz cz*sy+cy*sz*sx + // cy*sz+cz*sx*sy cz*cx sz*sy-cz*xy*sx + // -cx*sy sx cx*cy + + btScalar fi = btGetMatrixElem(mat, 7); + if (fi < btScalar(1.0f)) + { + if (fi > btScalar(-1.0f)) + { + xyz[0] = btAsin(btGetMatrixElem(mat, 7)); + xyz[1] = btAtan2(-btGetMatrixElem(mat, 6), btGetMatrixElem(mat, 8)); + xyz[2] = btAtan2(-btGetMatrixElem(mat, 1), btGetMatrixElem(mat, 4)); + return true; + } + else + { + xyz[0] = -SIMD_HALF_PI; + xyz[1] = btScalar(0.0); + xyz[2] = -btAtan2(btGetMatrixElem(mat, 2), btGetMatrixElem(mat, 0)); + return false; + } + } + else + { + xyz[0] = SIMD_HALF_PI; + xyz[1] = btScalar(0.0); + xyz[2] = btAtan2(btGetMatrixElem(mat, 2), btGetMatrixElem(mat, 0)); + } + return false; +} + +bool btGeneric6DofSpring2Constraint::matrixToEulerZYX(const btMatrix3x3& mat, btVector3& xyz) +{ + // rot = cz*cy cz*sy*sx-cx*sz sz*sx+cz*cx*sy + // cy*sz cz*cx+sz*sy*sx cx*sz*sy-cz*sx + // -sy cy*sx cy*cx + + btScalar fi = btGetMatrixElem(mat, 6); + if (fi < btScalar(1.0f)) + { + if (fi > btScalar(-1.0f)) + { + xyz[0] = btAtan2(btGetMatrixElem(mat, 7), btGetMatrixElem(mat, 8)); + xyz[1] = btAsin(-btGetMatrixElem(mat, 6)); + xyz[2] = btAtan2(btGetMatrixElem(mat, 3), btGetMatrixElem(mat, 0)); + return true; + } + else + { + xyz[0] = btScalar(0.0); + xyz[1] = SIMD_HALF_PI; + xyz[2] = -btAtan2(btGetMatrixElem(mat, 1), btGetMatrixElem(mat, 2)); + return false; + } + } + else + { + xyz[0] = btScalar(0.0); + xyz[1] = -SIMD_HALF_PI; + xyz[2] = btAtan2(-btGetMatrixElem(mat, 1), -btGetMatrixElem(mat, 2)); + } + return false; +} + +void btGeneric6DofSpring2Constraint::calculateAngleInfo() +{ + btMatrix3x3 relative_frame = m_calculatedTransformA.getBasis().inverse() * m_calculatedTransformB.getBasis(); + switch (m_rotateOrder) + { + case RO_XYZ: + matrixToEulerXYZ(relative_frame, m_calculatedAxisAngleDiff); + break; + case RO_XZY: + matrixToEulerXZY(relative_frame, m_calculatedAxisAngleDiff); + break; + case RO_YXZ: + matrixToEulerYXZ(relative_frame, m_calculatedAxisAngleDiff); + break; + case RO_YZX: + matrixToEulerYZX(relative_frame, m_calculatedAxisAngleDiff); + break; + case RO_ZXY: + matrixToEulerZXY(relative_frame, m_calculatedAxisAngleDiff); + break; + case RO_ZYX: + matrixToEulerZYX(relative_frame, m_calculatedAxisAngleDiff); + break; + default: + btAssert(false); + } + // in euler angle mode we do not actually constrain the angular velocity + // along the axes axis[0] and axis[2] (although we do use axis[1]) : + // + // to get constrain w2-w1 along ...not + // ------ --------------------- ------ + // d(angle[0])/dt = 0 ax[1] x ax[2] ax[0] + // d(angle[1])/dt = 0 ax[1] + // d(angle[2])/dt = 0 ax[0] x ax[1] ax[2] + // + // constraining w2-w1 along an axis 'a' means that a'*(w2-w1)=0. + // to prove the result for angle[0], write the expression for angle[0] from + // GetInfo1 then take the derivative. to prove this for angle[2] it is + // easier to take the euler rate expression for d(angle[2])/dt with respect + // to the components of w and set that to 0. + switch (m_rotateOrder) + { + case RO_XYZ: + { + //Is this the "line of nodes" calculation choosing planes YZ (B coordinate system) and xy (A coordinate system)? (http://en.wikipedia.org/wiki/Euler_angles) + //The two planes are non-homologous, so this is a Tait Bryan angle formalism and not a proper Euler + //Extrinsic rotations are equal to the reversed order intrinsic rotations so the above xyz extrinsic rotations (axes are fixed) are the same as the zy'x" intrinsic rotations (axes are refreshed after each rotation) + //that is why xy and YZ planes are chosen (this will describe a zy'x" intrinsic rotation) (see the figure on the left at http://en.wikipedia.org/wiki/Euler_angles under Tait Bryan angles) + // x' = Nperp = N.cross(axis2) + // y' = N = axis2.cross(axis0) + // z' = z + // + // x" = X + // y" = y' + // z" = ?? + //in other words: + //first rotate around z + //second rotate around y'= z.cross(X) + //third rotate around x" = X + //Original XYZ extrinsic rotation order. + //Planes: xy and YZ normals: z, X. Plane intersection (N) is z.cross(X) + btVector3 axis0 = m_calculatedTransformB.getBasis().getColumn(0); + btVector3 axis2 = m_calculatedTransformA.getBasis().getColumn(2); + m_calculatedAxis[1] = axis2.cross(axis0); + m_calculatedAxis[0] = m_calculatedAxis[1].cross(axis2); + m_calculatedAxis[2] = axis0.cross(m_calculatedAxis[1]); + break; + } + case RO_XZY: + { + //planes: xz,ZY normals: y, X + //first rotate around y + //second rotate around z'= y.cross(X) + //third rotate around x" = X + btVector3 axis0 = m_calculatedTransformB.getBasis().getColumn(0); + btVector3 axis1 = m_calculatedTransformA.getBasis().getColumn(1); + m_calculatedAxis[2] = axis0.cross(axis1); + m_calculatedAxis[0] = axis1.cross(m_calculatedAxis[2]); + m_calculatedAxis[1] = m_calculatedAxis[2].cross(axis0); + break; + } + case RO_YXZ: + { + //planes: yx,XZ normals: z, Y + //first rotate around z + //second rotate around x'= z.cross(Y) + //third rotate around y" = Y + btVector3 axis1 = m_calculatedTransformB.getBasis().getColumn(1); + btVector3 axis2 = m_calculatedTransformA.getBasis().getColumn(2); + m_calculatedAxis[0] = axis1.cross(axis2); + m_calculatedAxis[1] = axis2.cross(m_calculatedAxis[0]); + m_calculatedAxis[2] = m_calculatedAxis[0].cross(axis1); + break; + } + case RO_YZX: + { + //planes: yz,ZX normals: x, Y + //first rotate around x + //second rotate around z'= x.cross(Y) + //third rotate around y" = Y + btVector3 axis0 = m_calculatedTransformA.getBasis().getColumn(0); + btVector3 axis1 = m_calculatedTransformB.getBasis().getColumn(1); + m_calculatedAxis[2] = axis0.cross(axis1); + m_calculatedAxis[0] = axis1.cross(m_calculatedAxis[2]); + m_calculatedAxis[1] = m_calculatedAxis[2].cross(axis0); + break; + } + case RO_ZXY: + { + //planes: zx,XY normals: y, Z + //first rotate around y + //second rotate around x'= y.cross(Z) + //third rotate around z" = Z + btVector3 axis1 = m_calculatedTransformA.getBasis().getColumn(1); + btVector3 axis2 = m_calculatedTransformB.getBasis().getColumn(2); + m_calculatedAxis[0] = axis1.cross(axis2); + m_calculatedAxis[1] = axis2.cross(m_calculatedAxis[0]); + m_calculatedAxis[2] = m_calculatedAxis[0].cross(axis1); + break; + } + case RO_ZYX: + { + //planes: zy,YX normals: x, Z + //first rotate around x + //second rotate around y' = x.cross(Z) + //third rotate around z" = Z + btVector3 axis0 = m_calculatedTransformA.getBasis().getColumn(0); + btVector3 axis2 = m_calculatedTransformB.getBasis().getColumn(2); + m_calculatedAxis[1] = axis2.cross(axis0); + m_calculatedAxis[0] = m_calculatedAxis[1].cross(axis2); + m_calculatedAxis[2] = axis0.cross(m_calculatedAxis[1]); + break; + } + default: + btAssert(false); + } + + m_calculatedAxis[0].normalize(); + m_calculatedAxis[1].normalize(); + m_calculatedAxis[2].normalize(); +} + +void btGeneric6DofSpring2Constraint::calculateTransforms() +{ + calculateTransforms(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); +} + +void btGeneric6DofSpring2Constraint::calculateTransforms(const btTransform& transA, const btTransform& transB) +{ + m_calculatedTransformA = transA * m_frameInA; + m_calculatedTransformB = transB * m_frameInB; + calculateLinearInfo(); + calculateAngleInfo(); + + btScalar miA = getRigidBodyA().getInvMass(); + btScalar miB = getRigidBodyB().getInvMass(); + m_hasStaticBody = (miA < SIMD_EPSILON) || (miB < SIMD_EPSILON); + btScalar miS = miA + miB; + if (miS > btScalar(0.f)) + { + m_factA = miB / miS; + } + else + { + m_factA = btScalar(0.5f); + } + m_factB = btScalar(1.0f) - m_factA; +} + +void btGeneric6DofSpring2Constraint::testAngularLimitMotor(int axis_index) +{ + btScalar angle = m_calculatedAxisAngleDiff[axis_index]; + angle = btAdjustAngleToLimits(angle, m_angularLimits[axis_index].m_loLimit, m_angularLimits[axis_index].m_hiLimit); + m_angularLimits[axis_index].m_currentPosition = angle; + m_angularLimits[axis_index].testLimitValue(angle); +} + +void btGeneric6DofSpring2Constraint::getInfo1(btConstraintInfo1* info) +{ + //prepare constraint + calculateTransforms(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); + info->m_numConstraintRows = 0; + info->nub = 0; + int i; + //test linear limits + for (i = 0; i < 3; i++) + { + if (m_linearLimits.m_currentLimit[i] == 4) + info->m_numConstraintRows += 2; + else if (m_linearLimits.m_currentLimit[i] != 0) + info->m_numConstraintRows += 1; + if (m_linearLimits.m_enableMotor[i]) info->m_numConstraintRows += 1; + if (m_linearLimits.m_enableSpring[i]) info->m_numConstraintRows += 1; + } + //test angular limits + for (i = 0; i < 3; i++) + { + testAngularLimitMotor(i); + if (m_angularLimits[i].m_currentLimit == 4) + info->m_numConstraintRows += 2; + else if (m_angularLimits[i].m_currentLimit != 0) + info->m_numConstraintRows += 1; + if (m_angularLimits[i].m_enableMotor) info->m_numConstraintRows += 1; + if (m_angularLimits[i].m_enableSpring) info->m_numConstraintRows += 1; + } +} + +void btGeneric6DofSpring2Constraint::getInfo2(btConstraintInfo2* info) +{ + const btTransform& transA = m_rbA.getCenterOfMassTransform(); + const btTransform& transB = m_rbB.getCenterOfMassTransform(); + const btVector3& linVelA = m_rbA.getLinearVelocity(); + const btVector3& linVelB = m_rbB.getLinearVelocity(); + const btVector3& angVelA = m_rbA.getAngularVelocity(); + const btVector3& angVelB = m_rbB.getAngularVelocity(); + + // for stability better to solve angular limits first + int row = setAngularLimits(info, 0, transA, transB, linVelA, linVelB, angVelA, angVelB); + setLinearLimits(info, row, transA, transB, linVelA, linVelB, angVelA, angVelB); +} + +int btGeneric6DofSpring2Constraint::setLinearLimits(btConstraintInfo2* info, int row, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB) +{ + //solve linear limits + btRotationalLimitMotor2 limot; + for (int i = 0; i < 3; i++) + { + if (m_linearLimits.m_currentLimit[i] || m_linearLimits.m_enableMotor[i] || m_linearLimits.m_enableSpring[i]) + { // re-use rotational motor code + limot.m_bounce = m_linearLimits.m_bounce[i]; + limot.m_currentLimit = m_linearLimits.m_currentLimit[i]; + limot.m_currentPosition = m_linearLimits.m_currentLinearDiff[i]; + limot.m_currentLimitError = m_linearLimits.m_currentLimitError[i]; + limot.m_currentLimitErrorHi = m_linearLimits.m_currentLimitErrorHi[i]; + limot.m_enableMotor = m_linearLimits.m_enableMotor[i]; + limot.m_servoMotor = m_linearLimits.m_servoMotor[i]; + limot.m_servoTarget = m_linearLimits.m_servoTarget[i]; + limot.m_enableSpring = m_linearLimits.m_enableSpring[i]; + limot.m_springStiffness = m_linearLimits.m_springStiffness[i]; + limot.m_springStiffnessLimited = m_linearLimits.m_springStiffnessLimited[i]; + limot.m_springDamping = m_linearLimits.m_springDamping[i]; + limot.m_springDampingLimited = m_linearLimits.m_springDampingLimited[i]; + limot.m_equilibriumPoint = m_linearLimits.m_equilibriumPoint[i]; + limot.m_hiLimit = m_linearLimits.m_upperLimit[i]; + limot.m_loLimit = m_linearLimits.m_lowerLimit[i]; + limot.m_maxMotorForce = m_linearLimits.m_maxMotorForce[i]; + limot.m_targetVelocity = m_linearLimits.m_targetVelocity[i]; + btVector3 axis = m_calculatedTransformA.getBasis().getColumn(i); + int flags = m_flags >> (i * BT_6DOF_FLAGS_AXIS_SHIFT2); + limot.m_stopCFM = (flags & BT_6DOF_FLAGS_CFM_STOP2) ? m_linearLimits.m_stopCFM[i] : info->cfm[0]; + limot.m_stopERP = (flags & BT_6DOF_FLAGS_ERP_STOP2) ? m_linearLimits.m_stopERP[i] : info->erp; + limot.m_motorCFM = (flags & BT_6DOF_FLAGS_CFM_MOTO2) ? m_linearLimits.m_motorCFM[i] : info->cfm[0]; + limot.m_motorERP = (flags & BT_6DOF_FLAGS_ERP_MOTO2) ? m_linearLimits.m_motorERP[i] : info->erp; + + //rotAllowed is a bit of a magic from the original 6dof. The calculation of it here is something that imitates the original behavior as much as possible. + int indx1 = (i + 1) % 3; + int indx2 = (i + 2) % 3; + int rotAllowed = 1; // rotations around orthos to current axis (it is used only when one of the body is static) +#define D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION 1.0e-3 + bool indx1Violated = m_angularLimits[indx1].m_currentLimit == 1 || + m_angularLimits[indx1].m_currentLimit == 2 || + (m_angularLimits[indx1].m_currentLimit == 3 && (m_angularLimits[indx1].m_currentLimitError < -D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION || m_angularLimits[indx1].m_currentLimitError > D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION)) || + (m_angularLimits[indx1].m_currentLimit == 4 && (m_angularLimits[indx1].m_currentLimitError < -D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION || m_angularLimits[indx1].m_currentLimitErrorHi > D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION)); + bool indx2Violated = m_angularLimits[indx2].m_currentLimit == 1 || + m_angularLimits[indx2].m_currentLimit == 2 || + (m_angularLimits[indx2].m_currentLimit == 3 && (m_angularLimits[indx2].m_currentLimitError < -D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION || m_angularLimits[indx2].m_currentLimitError > D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION)) || + (m_angularLimits[indx2].m_currentLimit == 4 && (m_angularLimits[indx2].m_currentLimitError < -D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION || m_angularLimits[indx2].m_currentLimitErrorHi > D6_LIMIT_ERROR_THRESHOLD_FOR_ROTATION)); + if (indx1Violated && indx2Violated) + { + rotAllowed = 0; + } + row += get_limit_motor_info2(&limot, transA, transB, linVelA, linVelB, angVelA, angVelB, info, row, axis, 0, rotAllowed); + } + } + return row; +} + +int btGeneric6DofSpring2Constraint::setAngularLimits(btConstraintInfo2* info, int row_offset, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB) +{ + int row = row_offset; + + //order of rotational constraint rows + int cIdx[] = {0, 1, 2}; + switch (m_rotateOrder) + { + case RO_XYZ: + cIdx[0] = 0; + cIdx[1] = 1; + cIdx[2] = 2; + break; + case RO_XZY: + cIdx[0] = 0; + cIdx[1] = 2; + cIdx[2] = 1; + break; + case RO_YXZ: + cIdx[0] = 1; + cIdx[1] = 0; + cIdx[2] = 2; + break; + case RO_YZX: + cIdx[0] = 1; + cIdx[1] = 2; + cIdx[2] = 0; + break; + case RO_ZXY: + cIdx[0] = 2; + cIdx[1] = 0; + cIdx[2] = 1; + break; + case RO_ZYX: + cIdx[0] = 2; + cIdx[1] = 1; + cIdx[2] = 0; + break; + default: + btAssert(false); + } + + for (int ii = 0; ii < 3; ii++) + { + int i = cIdx[ii]; + if (m_angularLimits[i].m_currentLimit || m_angularLimits[i].m_enableMotor || m_angularLimits[i].m_enableSpring) + { + btVector3 axis = getAxis(i); + int flags = m_flags >> ((i + 3) * BT_6DOF_FLAGS_AXIS_SHIFT2); + if (!(flags & BT_6DOF_FLAGS_CFM_STOP2)) + { + m_angularLimits[i].m_stopCFM = info->cfm[0]; + } + if (!(flags & BT_6DOF_FLAGS_ERP_STOP2)) + { + m_angularLimits[i].m_stopERP = info->erp; + } + if (!(flags & BT_6DOF_FLAGS_CFM_MOTO2)) + { + m_angularLimits[i].m_motorCFM = info->cfm[0]; + } + if (!(flags & BT_6DOF_FLAGS_ERP_MOTO2)) + { + m_angularLimits[i].m_motorERP = info->erp; + } + row += get_limit_motor_info2(&m_angularLimits[i], transA, transB, linVelA, linVelB, angVelA, angVelB, info, row, axis, 1); + } + } + + return row; +} + +void btGeneric6DofSpring2Constraint::setFrames(const btTransform& frameA, const btTransform& frameB) +{ + m_frameInA = frameA; + m_frameInB = frameB; + buildJacobian(); + calculateTransforms(); +} + +void btGeneric6DofSpring2Constraint::calculateLinearInfo() +{ + m_calculatedLinearDiff = m_calculatedTransformB.getOrigin() - m_calculatedTransformA.getOrigin(); + m_calculatedLinearDiff = m_calculatedTransformA.getBasis().inverse() * m_calculatedLinearDiff; + for (int i = 0; i < 3; i++) + { + m_linearLimits.m_currentLinearDiff[i] = m_calculatedLinearDiff[i]; + m_linearLimits.testLimitValue(i, m_calculatedLinearDiff[i]); + } +} + +void btGeneric6DofSpring2Constraint::calculateJacobi(btRotationalLimitMotor2* limot, const btTransform& transA, const btTransform& transB, btConstraintInfo2* info, int srow, btVector3& ax1, int rotational, int rotAllowed) +{ + btScalar* J1 = rotational ? info->m_J1angularAxis : info->m_J1linearAxis; + btScalar* J2 = rotational ? info->m_J2angularAxis : info->m_J2linearAxis; + + J1[srow + 0] = ax1[0]; + J1[srow + 1] = ax1[1]; + J1[srow + 2] = ax1[2]; + + J2[srow + 0] = -ax1[0]; + J2[srow + 1] = -ax1[1]; + J2[srow + 2] = -ax1[2]; + + if (!rotational) + { + btVector3 tmpA, tmpB, relA, relB; + // get vector from bodyB to frameB in WCS + relB = m_calculatedTransformB.getOrigin() - transB.getOrigin(); + // same for bodyA + relA = m_calculatedTransformA.getOrigin() - transA.getOrigin(); + tmpA = relA.cross(ax1); + tmpB = relB.cross(ax1); + if (m_hasStaticBody && (!rotAllowed)) + { + tmpA *= m_factA; + tmpB *= m_factB; + } + int i; + for (i = 0; i < 3; i++) info->m_J1angularAxis[srow + i] = tmpA[i]; + for (i = 0; i < 3; i++) info->m_J2angularAxis[srow + i] = -tmpB[i]; + } +} + +int btGeneric6DofSpring2Constraint::get_limit_motor_info2( + btRotationalLimitMotor2* limot, + const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB, + btConstraintInfo2* info, int row, btVector3& ax1, int rotational, int rotAllowed) +{ + int count = 0; + int srow = row * info->rowskip; + + if (limot->m_currentLimit == 4) + { + btScalar vel = rotational ? angVelA.dot(ax1) - angVelB.dot(ax1) : linVelA.dot(ax1) - linVelB.dot(ax1); + + calculateJacobi(limot, transA, transB, info, srow, ax1, rotational, rotAllowed); + info->m_constraintError[srow] = info->fps * limot->m_stopERP * limot->m_currentLimitError * (rotational ? -1 : 1); + if (rotational) + { + if (info->m_constraintError[srow] - vel * limot->m_stopERP > 0) + { + btScalar bounceerror = -limot->m_bounce * vel; + if (bounceerror > info->m_constraintError[srow]) info->m_constraintError[srow] = bounceerror; + } + } + else + { + if (info->m_constraintError[srow] - vel * limot->m_stopERP < 0) + { + btScalar bounceerror = -limot->m_bounce * vel; + if (bounceerror < info->m_constraintError[srow]) info->m_constraintError[srow] = bounceerror; + } + } + info->m_lowerLimit[srow] = rotational ? 0 : -SIMD_INFINITY; + info->m_upperLimit[srow] = rotational ? SIMD_INFINITY : 0; + info->cfm[srow] = limot->m_stopCFM; + srow += info->rowskip; + ++count; + + calculateJacobi(limot, transA, transB, info, srow, ax1, rotational, rotAllowed); + info->m_constraintError[srow] = info->fps * limot->m_stopERP * limot->m_currentLimitErrorHi * (rotational ? -1 : 1); + if (rotational) + { + if (info->m_constraintError[srow] - vel * limot->m_stopERP < 0) + { + btScalar bounceerror = -limot->m_bounce * vel; + if (bounceerror < info->m_constraintError[srow]) info->m_constraintError[srow] = bounceerror; + } + } + else + { + if (info->m_constraintError[srow] - vel * limot->m_stopERP > 0) + { + btScalar bounceerror = -limot->m_bounce * vel; + if (bounceerror > info->m_constraintError[srow]) info->m_constraintError[srow] = bounceerror; + } + } + info->m_lowerLimit[srow] = rotational ? -SIMD_INFINITY : 0; + info->m_upperLimit[srow] = rotational ? 0 : SIMD_INFINITY; + info->cfm[srow] = limot->m_stopCFM; + srow += info->rowskip; + ++count; + } + else if (limot->m_currentLimit == 3) + { + calculateJacobi(limot, transA, transB, info, srow, ax1, rotational, rotAllowed); + info->m_constraintError[srow] = info->fps * limot->m_stopERP * limot->m_currentLimitError * (rotational ? -1 : 1); + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = SIMD_INFINITY; + info->cfm[srow] = limot->m_stopCFM; + srow += info->rowskip; + ++count; + } + + if (limot->m_enableMotor && !limot->m_servoMotor) + { + calculateJacobi(limot, transA, transB, info, srow, ax1, rotational, rotAllowed); + btScalar tag_vel = rotational ? limot->m_targetVelocity : -limot->m_targetVelocity; + btScalar mot_fact = getMotorFactor(limot->m_currentPosition, + limot->m_loLimit, + limot->m_hiLimit, + tag_vel, + info->fps * limot->m_motorERP); + info->m_constraintError[srow] = mot_fact * limot->m_targetVelocity; + info->m_lowerLimit[srow] = -limot->m_maxMotorForce / info->fps; + info->m_upperLimit[srow] = limot->m_maxMotorForce / info->fps; + info->cfm[srow] = limot->m_motorCFM; + srow += info->rowskip; + ++count; + } + + if (limot->m_enableMotor && limot->m_servoMotor) + { + btScalar error = limot->m_currentPosition - limot->m_servoTarget; + btScalar curServoTarget = limot->m_servoTarget; + if (rotational) + { + if (error > SIMD_PI) + { + error -= SIMD_2_PI; + curServoTarget += SIMD_2_PI; + } + if (error < -SIMD_PI) + { + error += SIMD_2_PI; + curServoTarget -= SIMD_2_PI; + } + } + + calculateJacobi(limot, transA, transB, info, srow, ax1, rotational, rotAllowed); + btScalar targetvelocity = error < 0 ? -limot->m_targetVelocity : limot->m_targetVelocity; + btScalar tag_vel = -targetvelocity; + btScalar mot_fact; + if (error != 0) + { + btScalar lowLimit; + btScalar hiLimit; + if (limot->m_loLimit > limot->m_hiLimit) + { + lowLimit = error > 0 ? curServoTarget : -SIMD_INFINITY; + hiLimit = error < 0 ? curServoTarget : SIMD_INFINITY; + } + else + { + lowLimit = error > 0 && curServoTarget > limot->m_loLimit ? curServoTarget : limot->m_loLimit; + hiLimit = error < 0 && curServoTarget < limot->m_hiLimit ? curServoTarget : limot->m_hiLimit; + } + mot_fact = getMotorFactor(limot->m_currentPosition, lowLimit, hiLimit, tag_vel, info->fps * limot->m_motorERP); + } + else + { + mot_fact = 0; + } + info->m_constraintError[srow] = mot_fact * targetvelocity * (rotational ? -1 : 1); + info->m_lowerLimit[srow] = -limot->m_maxMotorForce / info->fps; + info->m_upperLimit[srow] = limot->m_maxMotorForce / info->fps; + info->cfm[srow] = limot->m_motorCFM; + srow += info->rowskip; + ++count; + } + + if (limot->m_enableSpring) + { + btScalar error = limot->m_currentPosition - limot->m_equilibriumPoint; + calculateJacobi(limot, transA, transB, info, srow, ax1, rotational, rotAllowed); + + //btScalar cfm = 1.0 / ((1.0/info->fps)*limot->m_springStiffness+ limot->m_springDamping); + //if(cfm > 0.99999) + // cfm = 0.99999; + //btScalar erp = (1.0/info->fps)*limot->m_springStiffness / ((1.0/info->fps)*limot->m_springStiffness + limot->m_springDamping); + //info->m_constraintError[srow] = info->fps * erp * error * (rotational ? -1.0 : 1.0); + //info->m_lowerLimit[srow] = -SIMD_INFINITY; + //info->m_upperLimit[srow] = SIMD_INFINITY; + + btScalar dt = BT_ONE / info->fps; + btScalar kd = limot->m_springDamping; + btScalar ks = limot->m_springStiffness; + btScalar vel; + if (rotational) + { + vel = angVelA.dot(ax1) - angVelB.dot(ax1); + } + else + { + btVector3 tanVelA = angVelA.cross(m_calculatedTransformA.getOrigin() - transA.getOrigin()); + btVector3 tanVelB = angVelB.cross(m_calculatedTransformB.getOrigin() - transB.getOrigin()); + vel = (linVelA + tanVelA).dot(ax1) - (linVelB + tanVelB).dot(ax1); + } + btScalar cfm = BT_ZERO; + btScalar mA = BT_ONE / m_rbA.getInvMass(); + btScalar mB = BT_ONE / m_rbB.getInvMass(); + if (rotational) + { + btScalar rrA = (m_calculatedTransformA.getOrigin() - transA.getOrigin()).length2(); + btScalar rrB = (m_calculatedTransformB.getOrigin() - transB.getOrigin()).length2(); + if (m_rbA.getInvMass()) mA = mA * rrA + 1 / (m_rbA.getInvInertiaTensorWorld() * ax1).length(); + if (m_rbB.getInvMass()) mB = mB * rrB + 1 / (m_rbB.getInvInertiaTensorWorld() * ax1).length(); + } + btScalar m; + if (m_rbA.getInvMass() == 0) m = mB; else + if (m_rbB.getInvMass() == 0) m = mA; else + m = mA*mB / (mA + mB); + btScalar angularfreq = btSqrt(ks / m); + + //limit stiffness (the spring should not be sampled faster that the quarter of its angular frequency) + if (limot->m_springStiffnessLimited && 0.25 < angularfreq * dt) + { + ks = BT_ONE / dt / dt / btScalar(16.0) * m; + } + //avoid damping that would blow up the spring + if (limot->m_springDampingLimited && kd * dt > m) + { + kd = m / dt; + } + btScalar fs = ks * error * dt; + btScalar fd = -kd * (vel) * (rotational ? -1 : 1) * dt; + btScalar f = (fs + fd); + + // after the spring force affecting the body(es) the new velocity will be + // vel + f / m * (rotational ? -1 : 1) + // so in theory this should be set here for m_constraintError + // (with m_constraintError we set a desired velocity for the affected body(es)) + // however in practice any value is fine as long as it is greater than the "proper" velocity, + // because the m_lowerLimit and the m_upperLimit will determinate the strength of the final pulling force + // so it is much simpler (and more robust) just to simply use inf (with the proper sign) + // (Even with our best intent the "new" velocity is only an estimation. If we underestimate + // the "proper" velocity that will weaken the spring, however if we overestimate it, it doesn't + // matter, because the solver will limit it according the force limit) + // you may also wonder what if the current velocity (vel) so high that the pulling force will not change its direction (in this iteration) + // will we not request a velocity with the wrong direction ? + // and the answer is not, because in practice during the solving the current velocity is subtracted from the m_constraintError + // so the sign of the force that is really matters + if (m_flags & BT_6DOF_FLAGS_USE_INFINITE_ERROR) + info->m_constraintError[srow] = (rotational ? -1 : 1) * (f < 0 ? -SIMD_INFINITY : SIMD_INFINITY); + else + info->m_constraintError[srow] = vel + f / m * (rotational ? -1 : 1); + + btScalar minf = f < fd ? f : fd; + btScalar maxf = f < fd ? fd : f; + if (!rotational) + { + info->m_lowerLimit[srow] = minf > 0 ? 0 : minf; + info->m_upperLimit[srow] = maxf < 0 ? 0 : maxf; + } + else + { + info->m_lowerLimit[srow] = -maxf > 0 ? 0 : -maxf; + info->m_upperLimit[srow] = -minf < 0 ? 0 : -minf; + } + + info->cfm[srow] = cfm; + srow += info->rowskip; + ++count; + } + + return count; +} + +//override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). +//If no axis is provided, it uses the default axis for this constraint. +void btGeneric6DofSpring2Constraint::setParam(int num, btScalar value, int axis) +{ + if ((axis >= 0) && (axis < 3)) + { + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + m_linearLimits.m_stopERP[axis] = value; + m_flags |= BT_6DOF_FLAGS_ERP_STOP2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2); + break; + case BT_CONSTRAINT_STOP_CFM: + m_linearLimits.m_stopCFM[axis] = value; + m_flags |= BT_6DOF_FLAGS_CFM_STOP2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2); + break; + case BT_CONSTRAINT_ERP: + m_linearLimits.m_motorERP[axis] = value; + m_flags |= BT_6DOF_FLAGS_ERP_MOTO2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2); + break; + case BT_CONSTRAINT_CFM: + m_linearLimits.m_motorCFM[axis] = value; + m_flags |= BT_6DOF_FLAGS_CFM_MOTO2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2); + break; + default: + btAssertConstrParams(0); + } + } + else if ((axis >= 3) && (axis < 6)) + { + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + m_angularLimits[axis - 3].m_stopERP = value; + m_flags |= BT_6DOF_FLAGS_ERP_STOP2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2); + break; + case BT_CONSTRAINT_STOP_CFM: + m_angularLimits[axis - 3].m_stopCFM = value; + m_flags |= BT_6DOF_FLAGS_CFM_STOP2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2); + break; + case BT_CONSTRAINT_ERP: + m_angularLimits[axis - 3].m_motorERP = value; + m_flags |= BT_6DOF_FLAGS_ERP_MOTO2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2); + break; + case BT_CONSTRAINT_CFM: + m_angularLimits[axis - 3].m_motorCFM = value; + m_flags |= BT_6DOF_FLAGS_CFM_MOTO2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2); + break; + default: + btAssertConstrParams(0); + } + } + else + { + btAssertConstrParams(0); + } +} + +//return the local value of parameter +btScalar btGeneric6DofSpring2Constraint::getParam(int num, int axis) const +{ + btScalar retVal = 0; + if ((axis >= 0) && (axis < 3)) + { + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_ERP_STOP2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2))); + retVal = m_linearLimits.m_stopERP[axis]; + break; + case BT_CONSTRAINT_STOP_CFM: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_CFM_STOP2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2))); + retVal = m_linearLimits.m_stopCFM[axis]; + break; + case BT_CONSTRAINT_ERP: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_ERP_MOTO2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2))); + retVal = m_linearLimits.m_motorERP[axis]; + break; + case BT_CONSTRAINT_CFM: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_CFM_MOTO2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2))); + retVal = m_linearLimits.m_motorCFM[axis]; + break; + default: + btAssertConstrParams(0); + } + } + else if ((axis >= 3) && (axis < 6)) + { + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_ERP_STOP2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2))); + retVal = m_angularLimits[axis - 3].m_stopERP; + break; + case BT_CONSTRAINT_STOP_CFM: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_CFM_STOP2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2))); + retVal = m_angularLimits[axis - 3].m_stopCFM; + break; + case BT_CONSTRAINT_ERP: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_ERP_MOTO2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2))); + retVal = m_angularLimits[axis - 3].m_motorERP; + break; + case BT_CONSTRAINT_CFM: + btAssertConstrParams(m_flags & (BT_6DOF_FLAGS_CFM_MOTO2 << (axis * BT_6DOF_FLAGS_AXIS_SHIFT2))); + retVal = m_angularLimits[axis - 3].m_motorCFM; + break; + default: + btAssertConstrParams(0); + } + } + else + { + btAssertConstrParams(0); + } + return retVal; +} + +void btGeneric6DofSpring2Constraint::setAxis(const btVector3& axis1, const btVector3& axis2) +{ + btVector3 zAxis = axis1.normalized(); + btVector3 yAxis = axis2.normalized(); + btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system + + btTransform frameInW; + frameInW.setIdentity(); + frameInW.getBasis().setValue(xAxis[0], yAxis[0], zAxis[0], + xAxis[1], yAxis[1], zAxis[1], + xAxis[2], yAxis[2], zAxis[2]); + + // now get constraint frame in local coordinate systems + m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW; + m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW; + + calculateTransforms(); +} + +void btGeneric6DofSpring2Constraint::setBounce(int index, btScalar bounce) +{ + btAssert((index >= 0) && (index < 6)); + if (index < 3) + m_linearLimits.m_bounce[index] = bounce; + else + m_angularLimits[index - 3].m_bounce = bounce; +} + +void btGeneric6DofSpring2Constraint::enableMotor(int index, bool onOff) +{ + btAssert((index >= 0) && (index < 6)); + if (index < 3) + m_linearLimits.m_enableMotor[index] = onOff; + else + m_angularLimits[index - 3].m_enableMotor = onOff; +} + +void btGeneric6DofSpring2Constraint::setServo(int index, bool onOff) +{ + btAssert((index >= 0) && (index < 6)); + if (index < 3) + m_linearLimits.m_servoMotor[index] = onOff; + else + m_angularLimits[index - 3].m_servoMotor = onOff; +} + +void btGeneric6DofSpring2Constraint::setTargetVelocity(int index, btScalar velocity) +{ + btAssert((index >= 0) && (index < 6)); + if (index < 3) + m_linearLimits.m_targetVelocity[index] = velocity; + else + m_angularLimits[index - 3].m_targetVelocity = velocity; +} + +void btGeneric6DofSpring2Constraint::setServoTarget(int index, btScalar targetOrg) +{ + btAssert((index >= 0) && (index < 6)); + if (index < 3) + { + m_linearLimits.m_servoTarget[index] = targetOrg; + } + else + { + //wrap between -PI and PI, see also + //https://stackoverflow.com/questions/4633177/c-how-to-wrap-a-float-to-the-interval-pi-pi + + btScalar target = targetOrg + SIMD_PI; + if (1) + { + btScalar m = target - SIMD_2_PI * std::floor(target / SIMD_2_PI); + // handle boundary cases resulted from floating-point cut off: + { + if (m >= SIMD_2_PI) + { + target = 0; + } + else + { + if (m < 0) + { + if (SIMD_2_PI + m == SIMD_2_PI) + target = 0; + else + target = SIMD_2_PI + m; + } + else + { + target = m; + } + } + } + target -= SIMD_PI; + } + + m_angularLimits[index - 3].m_servoTarget = target; + } +} + +void btGeneric6DofSpring2Constraint::setMaxMotorForce(int index, btScalar force) +{ + btAssert((index >= 0) && (index < 6)); + if (index < 3) + m_linearLimits.m_maxMotorForce[index] = force; + else + m_angularLimits[index - 3].m_maxMotorForce = force; +} + +void btGeneric6DofSpring2Constraint::enableSpring(int index, bool onOff) +{ + btAssert((index >= 0) && (index < 6)); + if (index < 3) + m_linearLimits.m_enableSpring[index] = onOff; + else + m_angularLimits[index - 3].m_enableSpring = onOff; +} + +void btGeneric6DofSpring2Constraint::setStiffness(int index, btScalar stiffness, bool limitIfNeeded) +{ + btAssert((index >= 0) && (index < 6)); + if (index < 3) + { + m_linearLimits.m_springStiffness[index] = stiffness; + m_linearLimits.m_springStiffnessLimited[index] = limitIfNeeded; + } + else + { + m_angularLimits[index - 3].m_springStiffness = stiffness; + m_angularLimits[index - 3].m_springStiffnessLimited = limitIfNeeded; + } +} + +void btGeneric6DofSpring2Constraint::setDamping(int index, btScalar damping, bool limitIfNeeded) +{ + btAssert((index >= 0) && (index < 6)); + if (index < 3) + { + m_linearLimits.m_springDamping[index] = damping; + m_linearLimits.m_springDampingLimited[index] = limitIfNeeded; + } + else + { + m_angularLimits[index - 3].m_springDamping = damping; + m_angularLimits[index - 3].m_springDampingLimited = limitIfNeeded; + } +} + +void btGeneric6DofSpring2Constraint::setEquilibriumPoint() +{ + calculateTransforms(); + int i; + for (i = 0; i < 3; i++) + m_linearLimits.m_equilibriumPoint[i] = m_calculatedLinearDiff[i]; + for (i = 0; i < 3; i++) + m_angularLimits[i].m_equilibriumPoint = m_calculatedAxisAngleDiff[i]; +} + +void btGeneric6DofSpring2Constraint::setEquilibriumPoint(int index) +{ + btAssert((index >= 0) && (index < 6)); + calculateTransforms(); + if (index < 3) + m_linearLimits.m_equilibriumPoint[index] = m_calculatedLinearDiff[index]; + else + m_angularLimits[index - 3].m_equilibriumPoint = m_calculatedAxisAngleDiff[index - 3]; +} + +void btGeneric6DofSpring2Constraint::setEquilibriumPoint(int index, btScalar val) +{ + btAssert((index >= 0) && (index < 6)); + if (index < 3) + m_linearLimits.m_equilibriumPoint[index] = val; + else + m_angularLimits[index - 3].m_equilibriumPoint = val; +} + +//////////////////////////// btRotationalLimitMotor2 //////////////////////////////////// + +void btRotationalLimitMotor2::testLimitValue(btScalar test_value) +{ + //we can't normalize the angles here because we would lost the sign that we use later, but it doesn't seem to be a problem + if (m_loLimit > m_hiLimit) + { + m_currentLimit = 0; + m_currentLimitError = btScalar(0.f); + } + else if (m_loLimit == m_hiLimit) + { + m_currentLimitError = test_value - m_loLimit; + m_currentLimit = 3; + } + else + { + m_currentLimitError = test_value - m_loLimit; + m_currentLimitErrorHi = test_value - m_hiLimit; + m_currentLimit = 4; + } +} + +//////////////////////////// btTranslationalLimitMotor2 //////////////////////////////////// + +void btTranslationalLimitMotor2::testLimitValue(int limitIndex, btScalar test_value) +{ + btScalar loLimit = m_lowerLimit[limitIndex]; + btScalar hiLimit = m_upperLimit[limitIndex]; + if (loLimit > hiLimit) + { + m_currentLimitError[limitIndex] = 0; + m_currentLimit[limitIndex] = 0; + } + else if (loLimit == hiLimit) + { + m_currentLimitError[limitIndex] = test_value - loLimit; + m_currentLimit[limitIndex] = 3; + } + else + { + m_currentLimitError[limitIndex] = test_value - loLimit; + m_currentLimitErrorHi[limitIndex] = test_value - hiLimit; + m_currentLimit[limitIndex] = 4; + } +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp.i new file mode 100644 index 00000000..39013438 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h new file mode 100644 index 00000000..d2fe24b8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h @@ -0,0 +1,667 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +2014 May: btGeneric6DofSpring2Constraint is created from the original (2.82.2712) btGeneric6DofConstraint by Gabor Puhr and Tamas Umenhoffer +Pros: +- Much more accurate and stable in a lot of situation. (Especially when a sleeping chain of RBs connected with 6dof2 is pulled) +- Stable and accurate spring with minimal energy loss that works with all of the solvers. (latter is not true for the original 6dof spring) +- Servo motor functionality +- Much more accurate bouncing. 0 really means zero bouncing (not true for the original 6odf) and there is only a minimal energy loss when the value is 1 (because of the solvers' precision) +- Rotation order for the Euler system can be set. (One axis' freedom is still limited to pi/2) + +Cons: +- It is slower than the original 6dof. There is no exact ratio, but half speed is a good estimation. +- At bouncing the correct velocity is calculated, but not the correct position. (it is because of the solver can correct position or velocity, but not both.) +*/ + +/// 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev +/// Added support for generic constraint solver through getInfo1/getInfo2 methods + +/* +2007-09-09 +btGeneric6DofConstraint Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ + +#ifndef BT_GENERIC_6DOF_CONSTRAINT2_H +#define BT_GENERIC_6DOF_CONSTRAINT2_H + +#include "LinearMath/btVector3.h" +#include "btJacobianEntry.h" +#include "btTypedConstraint.h" + +class btRigidBody; + +#ifdef BT_USE_DOUBLE_PRECISION +#define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintDoubleData2 +#define btGeneric6DofSpring2ConstraintDataName "btGeneric6DofSpring2ConstraintDoubleData2" +#else +#define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData +#define btGeneric6DofSpring2ConstraintDataName "btGeneric6DofSpring2ConstraintData" +#endif //BT_USE_DOUBLE_PRECISION + +enum RotateOrder +{ + RO_XYZ = 0, + RO_XZY, + RO_YXZ, + RO_YZX, + RO_ZXY, + RO_ZYX +}; + +class btRotationalLimitMotor2 +{ +public: + // upper < lower means free + // upper == lower means locked + // upper > lower means limited + btScalar m_loLimit; + btScalar m_hiLimit; + btScalar m_bounce; + btScalar m_stopERP; + btScalar m_stopCFM; + btScalar m_motorERP; + btScalar m_motorCFM; + bool m_enableMotor; + btScalar m_targetVelocity; + btScalar m_maxMotorForce; + bool m_servoMotor; + btScalar m_servoTarget; + bool m_enableSpring; + btScalar m_springStiffness; + bool m_springStiffnessLimited; + btScalar m_springDamping; + bool m_springDampingLimited; + btScalar m_equilibriumPoint; + + btScalar m_currentLimitError; + btScalar m_currentLimitErrorHi; + btScalar m_currentPosition; + int m_currentLimit; + + btRotationalLimitMotor2() + { + m_loLimit = 1.0f; + m_hiLimit = -1.0f; + m_bounce = 0.0f; + m_stopERP = 0.2f; + m_stopCFM = 0.f; + m_motorERP = 0.9f; + m_motorCFM = 0.f; + m_enableMotor = false; + m_targetVelocity = 0; + m_maxMotorForce = 6.0f; + m_servoMotor = false; + m_servoTarget = 0; + m_enableSpring = false; + m_springStiffness = 0; + m_springStiffnessLimited = false; + m_springDamping = 0; + m_springDampingLimited = false; + m_equilibriumPoint = 0; + + m_currentLimitError = 0; + m_currentLimitErrorHi = 0; + m_currentPosition = 0; + m_currentLimit = 0; + } + + btRotationalLimitMotor2(const btRotationalLimitMotor2& limot) + { + m_loLimit = limot.m_loLimit; + m_hiLimit = limot.m_hiLimit; + m_bounce = limot.m_bounce; + m_stopERP = limot.m_stopERP; + m_stopCFM = limot.m_stopCFM; + m_motorERP = limot.m_motorERP; + m_motorCFM = limot.m_motorCFM; + m_enableMotor = limot.m_enableMotor; + m_targetVelocity = limot.m_targetVelocity; + m_maxMotorForce = limot.m_maxMotorForce; + m_servoMotor = limot.m_servoMotor; + m_servoTarget = limot.m_servoTarget; + m_enableSpring = limot.m_enableSpring; + m_springStiffness = limot.m_springStiffness; + m_springStiffnessLimited = limot.m_springStiffnessLimited; + m_springDamping = limot.m_springDamping; + m_springDampingLimited = limot.m_springDampingLimited; + m_equilibriumPoint = limot.m_equilibriumPoint; + + m_currentLimitError = limot.m_currentLimitError; + m_currentLimitErrorHi = limot.m_currentLimitErrorHi; + m_currentPosition = limot.m_currentPosition; + m_currentLimit = limot.m_currentLimit; + } + + bool isLimited() + { + if (m_loLimit > m_hiLimit) return false; + return true; + } + + void testLimitValue(btScalar test_value); +}; + +class btTranslationalLimitMotor2 +{ +public: + // upper < lower means free + // upper == lower means locked + // upper > lower means limited + btVector3 m_lowerLimit; + btVector3 m_upperLimit; + btVector3 m_bounce; + btVector3 m_stopERP; + btVector3 m_stopCFM; + btVector3 m_motorERP; + btVector3 m_motorCFM; + bool m_enableMotor[3]; + bool m_servoMotor[3]; + bool m_enableSpring[3]; + btVector3 m_servoTarget; + btVector3 m_springStiffness; + bool m_springStiffnessLimited[3]; + btVector3 m_springDamping; + bool m_springDampingLimited[3]; + btVector3 m_equilibriumPoint; + btVector3 m_targetVelocity; + btVector3 m_maxMotorForce; + + btVector3 m_currentLimitError; + btVector3 m_currentLimitErrorHi; + btVector3 m_currentLinearDiff; + int m_currentLimit[3]; + + btTranslationalLimitMotor2() + { + m_lowerLimit.setValue(0.f, 0.f, 0.f); + m_upperLimit.setValue(0.f, 0.f, 0.f); + m_bounce.setValue(0.f, 0.f, 0.f); + m_stopERP.setValue(0.2f, 0.2f, 0.2f); + m_stopCFM.setValue(0.f, 0.f, 0.f); + m_motorERP.setValue(0.9f, 0.9f, 0.9f); + m_motorCFM.setValue(0.f, 0.f, 0.f); + + m_currentLimitError.setValue(0.f, 0.f, 0.f); + m_currentLimitErrorHi.setValue(0.f, 0.f, 0.f); + m_currentLinearDiff.setValue(0.f, 0.f, 0.f); + + for (int i = 0; i < 3; i++) + { + m_enableMotor[i] = false; + m_servoMotor[i] = false; + m_enableSpring[i] = false; + m_servoTarget[i] = btScalar(0.f); + m_springStiffness[i] = btScalar(0.f); + m_springStiffnessLimited[i] = false; + m_springDamping[i] = btScalar(0.f); + m_springDampingLimited[i] = false; + m_equilibriumPoint[i] = btScalar(0.f); + m_targetVelocity[i] = btScalar(0.f); + m_maxMotorForce[i] = btScalar(0.f); + + m_currentLimit[i] = 0; + } + } + + btTranslationalLimitMotor2(const btTranslationalLimitMotor2& other) + { + m_lowerLimit = other.m_lowerLimit; + m_upperLimit = other.m_upperLimit; + m_bounce = other.m_bounce; + m_stopERP = other.m_stopERP; + m_stopCFM = other.m_stopCFM; + m_motorERP = other.m_motorERP; + m_motorCFM = other.m_motorCFM; + + m_currentLimitError = other.m_currentLimitError; + m_currentLimitErrorHi = other.m_currentLimitErrorHi; + m_currentLinearDiff = other.m_currentLinearDiff; + + for (int i = 0; i < 3; i++) + { + m_enableMotor[i] = other.m_enableMotor[i]; + m_servoMotor[i] = other.m_servoMotor[i]; + m_enableSpring[i] = other.m_enableSpring[i]; + m_servoTarget[i] = other.m_servoTarget[i]; + m_springStiffness[i] = other.m_springStiffness[i]; + m_springStiffnessLimited[i] = other.m_springStiffnessLimited[i]; + m_springDamping[i] = other.m_springDamping[i]; + m_springDampingLimited[i] = other.m_springDampingLimited[i]; + m_equilibriumPoint[i] = other.m_equilibriumPoint[i]; + m_targetVelocity[i] = other.m_targetVelocity[i]; + m_maxMotorForce[i] = other.m_maxMotorForce[i]; + + m_currentLimit[i] = other.m_currentLimit[i]; + } + } + + inline bool isLimited(int limitIndex) + { + return (m_upperLimit[limitIndex] >= m_lowerLimit[limitIndex]); + } + + void testLimitValue(int limitIndex, btScalar test_value); +}; + +enum bt6DofFlags2 +{ + BT_6DOF_FLAGS_CFM_STOP2 = 1, + BT_6DOF_FLAGS_ERP_STOP2 = 2, + BT_6DOF_FLAGS_CFM_MOTO2 = 4, + BT_6DOF_FLAGS_ERP_MOTO2 = 8, + BT_6DOF_FLAGS_USE_INFINITE_ERROR = (1<<16) +}; +#define BT_6DOF_FLAGS_AXIS_SHIFT2 4 // bits per axis + +ATTRIBUTE_ALIGNED16(class) +btGeneric6DofSpring2Constraint : public btTypedConstraint +{ +protected: + btTransform m_frameInA; + btTransform m_frameInB; + + btJacobianEntry m_jacLinear[3]; + btJacobianEntry m_jacAng[3]; + + btTranslationalLimitMotor2 m_linearLimits; + btRotationalLimitMotor2 m_angularLimits[3]; + + RotateOrder m_rotateOrder; + +protected: + btTransform m_calculatedTransformA; + btTransform m_calculatedTransformB; + btVector3 m_calculatedAxisAngleDiff; + btVector3 m_calculatedAxis[3]; + btVector3 m_calculatedLinearDiff; + btScalar m_factA; + btScalar m_factB; + bool m_hasStaticBody; + int m_flags; + + btGeneric6DofSpring2Constraint& operator=(const btGeneric6DofSpring2Constraint&) + { + btAssert(0); + return *this; + } + + int setAngularLimits(btConstraintInfo2 * info, int row_offset, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB); + int setLinearLimits(btConstraintInfo2 * info, int row, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB); + + void calculateLinearInfo(); + void calculateAngleInfo(); + void testAngularLimitMotor(int axis_index); + + void calculateJacobi(btRotationalLimitMotor2 * limot, const btTransform& transA, const btTransform& transB, btConstraintInfo2* info, int srow, btVector3& ax1, int rotational, int rotAllowed); + int get_limit_motor_info2(btRotationalLimitMotor2 * limot, + const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, const btVector3& angVelA, const btVector3& angVelB, + btConstraintInfo2* info, int row, btVector3& ax1, int rotational, int rotAllowed = false); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btGeneric6DofSpring2Constraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB, RotateOrder rotOrder = RO_XYZ); + btGeneric6DofSpring2Constraint(btRigidBody & rbB, const btTransform& frameInB, RotateOrder rotOrder = RO_XYZ); + + virtual void buildJacobian() {} + virtual void getInfo1(btConstraintInfo1 * info); + virtual void getInfo2(btConstraintInfo2 * info); + virtual int calculateSerializeBufferSize() const; + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; + + btRotationalLimitMotor2* getRotationalLimitMotor(int index) { return &m_angularLimits[index]; } + btTranslationalLimitMotor2* getTranslationalLimitMotor() { return &m_linearLimits; } + + // Calculates the global transform for the joint offset for body A an B, and also calculates the angle differences between the bodies. + void calculateTransforms(const btTransform& transA, const btTransform& transB); + void calculateTransforms(); + + // Gets the global transform of the offset for body A + const btTransform& getCalculatedTransformA() const { return m_calculatedTransformA; } + // Gets the global transform of the offset for body B + const btTransform& getCalculatedTransformB() const { return m_calculatedTransformB; } + + const btTransform& getFrameOffsetA() const { return m_frameInA; } + const btTransform& getFrameOffsetB() const { return m_frameInB; } + + btTransform& getFrameOffsetA() { return m_frameInA; } + btTransform& getFrameOffsetB() { return m_frameInB; } + + // Get the rotation axis in global coordinates ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) + btVector3 getAxis(int axis_index) const { return m_calculatedAxis[axis_index]; } + + // Get the relative Euler angle ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) + btScalar getAngle(int axis_index) const { return m_calculatedAxisAngleDiff[axis_index]; } + + // Get the relative position of the constraint pivot ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) + btScalar getRelativePivotPosition(int axis_index) const { return m_calculatedLinearDiff[axis_index]; } + + void setFrames(const btTransform& frameA, const btTransform& frameB); + + void setLinearLowerLimit(const btVector3& linearLower) { m_linearLimits.m_lowerLimit = linearLower; } + void getLinearLowerLimit(btVector3 & linearLower) { linearLower = m_linearLimits.m_lowerLimit; } + void setLinearUpperLimit(const btVector3& linearUpper) { m_linearLimits.m_upperLimit = linearUpper; } + void getLinearUpperLimit(btVector3 & linearUpper) { linearUpper = m_linearLimits.m_upperLimit; } + + void setAngularLowerLimit(const btVector3& angularLower) + { + for (int i = 0; i < 3; i++) + m_angularLimits[i].m_loLimit = btNormalizeAngle(angularLower[i]); + } + + void setAngularLowerLimitReversed(const btVector3& angularLower) + { + for (int i = 0; i < 3; i++) + m_angularLimits[i].m_hiLimit = btNormalizeAngle(-angularLower[i]); + } + + void getAngularLowerLimit(btVector3 & angularLower) + { + for (int i = 0; i < 3; i++) + angularLower[i] = m_angularLimits[i].m_loLimit; + } + + void getAngularLowerLimitReversed(btVector3 & angularLower) + { + for (int i = 0; i < 3; i++) + angularLower[i] = -m_angularLimits[i].m_hiLimit; + } + + void setAngularUpperLimit(const btVector3& angularUpper) + { + for (int i = 0; i < 3; i++) + m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]); + } + + void setAngularUpperLimitReversed(const btVector3& angularUpper) + { + for (int i = 0; i < 3; i++) + m_angularLimits[i].m_loLimit = btNormalizeAngle(-angularUpper[i]); + } + + void getAngularUpperLimit(btVector3 & angularUpper) + { + for (int i = 0; i < 3; i++) + angularUpper[i] = m_angularLimits[i].m_hiLimit; + } + + void getAngularUpperLimitReversed(btVector3 & angularUpper) + { + for (int i = 0; i < 3; i++) + angularUpper[i] = -m_angularLimits[i].m_loLimit; + } + + //first 3 are linear, next 3 are angular + + void setLimit(int axis, btScalar lo, btScalar hi) + { + if (axis < 3) + { + m_linearLimits.m_lowerLimit[axis] = lo; + m_linearLimits.m_upperLimit[axis] = hi; + } + else + { + lo = btNormalizeAngle(lo); + hi = btNormalizeAngle(hi); + m_angularLimits[axis - 3].m_loLimit = lo; + m_angularLimits[axis - 3].m_hiLimit = hi; + } + } + + void setLimitReversed(int axis, btScalar lo, btScalar hi) + { + if (axis < 3) + { + m_linearLimits.m_lowerLimit[axis] = lo; + m_linearLimits.m_upperLimit[axis] = hi; + } + else + { + lo = btNormalizeAngle(lo); + hi = btNormalizeAngle(hi); + m_angularLimits[axis - 3].m_hiLimit = -lo; + m_angularLimits[axis - 3].m_loLimit = -hi; + } + } + + bool isLimited(int limitIndex) + { + if (limitIndex < 3) + { + return m_linearLimits.isLimited(limitIndex); + } + return m_angularLimits[limitIndex - 3].isLimited(); + } + + void setRotationOrder(RotateOrder order) { m_rotateOrder = order; } + RotateOrder getRotationOrder() { return m_rotateOrder; } + + void setAxis(const btVector3& axis1, const btVector3& axis2); + + void setBounce(int index, btScalar bounce); + + void enableMotor(int index, bool onOff); + void setServo(int index, bool onOff); // set the type of the motor (servo or not) (the motor has to be turned on for servo also) + void setTargetVelocity(int index, btScalar velocity); + void setServoTarget(int index, btScalar target); + void setMaxMotorForce(int index, btScalar force); + + void enableSpring(int index, bool onOff); + void setStiffness(int index, btScalar stiffness, bool limitIfNeeded = true); // if limitIfNeeded is true the system will automatically limit the stiffness in necessary situations where otherwise the spring would move unrealistically too widely + void setDamping(int index, btScalar damping, bool limitIfNeeded = true); // if limitIfNeeded is true the system will automatically limit the damping in necessary situations where otherwise the spring would blow up + void setEquilibriumPoint(); // set the current constraint position/orientation as an equilibrium point for all DOF + void setEquilibriumPoint(int index); // set the current constraint position/orientation as an equilibrium point for given DOF + void setEquilibriumPoint(int index, btScalar val); + + //override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + //If no axis is provided, it uses the default axis for this constraint. + virtual void setParam(int num, btScalar value, int axis = -1); + virtual btScalar getParam(int num, int axis = -1) const; + + static btScalar btGetMatrixElem(const btMatrix3x3& mat, int index); + static bool matrixToEulerXYZ(const btMatrix3x3& mat, btVector3& xyz); + static bool matrixToEulerXZY(const btMatrix3x3& mat, btVector3& xyz); + static bool matrixToEulerYXZ(const btMatrix3x3& mat, btVector3& xyz); + static bool matrixToEulerYZX(const btMatrix3x3& mat, btVector3& xyz); + static bool matrixToEulerZXY(const btMatrix3x3& mat, btVector3& xyz); + static bool matrixToEulerZYX(const btMatrix3x3& mat, btVector3& xyz); +}; + +struct btGeneric6DofSpring2ConstraintData +{ + btTypedConstraintData m_typeConstraintData; + btTransformFloatData m_rbAFrame; + btTransformFloatData m_rbBFrame; + + btVector3FloatData m_linearUpperLimit; + btVector3FloatData m_linearLowerLimit; + btVector3FloatData m_linearBounce; + btVector3FloatData m_linearStopERP; + btVector3FloatData m_linearStopCFM; + btVector3FloatData m_linearMotorERP; + btVector3FloatData m_linearMotorCFM; + btVector3FloatData m_linearTargetVelocity; + btVector3FloatData m_linearMaxMotorForce; + btVector3FloatData m_linearServoTarget; + btVector3FloatData m_linearSpringStiffness; + btVector3FloatData m_linearSpringDamping; + btVector3FloatData m_linearEquilibriumPoint; + char m_linearEnableMotor[4]; + char m_linearServoMotor[4]; + char m_linearEnableSpring[4]; + char m_linearSpringStiffnessLimited[4]; + char m_linearSpringDampingLimited[4]; + char m_padding1[4]; + + btVector3FloatData m_angularUpperLimit; + btVector3FloatData m_angularLowerLimit; + btVector3FloatData m_angularBounce; + btVector3FloatData m_angularStopERP; + btVector3FloatData m_angularStopCFM; + btVector3FloatData m_angularMotorERP; + btVector3FloatData m_angularMotorCFM; + btVector3FloatData m_angularTargetVelocity; + btVector3FloatData m_angularMaxMotorForce; + btVector3FloatData m_angularServoTarget; + btVector3FloatData m_angularSpringStiffness; + btVector3FloatData m_angularSpringDamping; + btVector3FloatData m_angularEquilibriumPoint; + char m_angularEnableMotor[4]; + char m_angularServoMotor[4]; + char m_angularEnableSpring[4]; + char m_angularSpringStiffnessLimited[4]; + char m_angularSpringDampingLimited[4]; + + int m_rotateOrder; +}; + +struct btGeneric6DofSpring2ConstraintDoubleData2 +{ + btTypedConstraintDoubleData m_typeConstraintData; + btTransformDoubleData m_rbAFrame; + btTransformDoubleData m_rbBFrame; + + btVector3DoubleData m_linearUpperLimit; + btVector3DoubleData m_linearLowerLimit; + btVector3DoubleData m_linearBounce; + btVector3DoubleData m_linearStopERP; + btVector3DoubleData m_linearStopCFM; + btVector3DoubleData m_linearMotorERP; + btVector3DoubleData m_linearMotorCFM; + btVector3DoubleData m_linearTargetVelocity; + btVector3DoubleData m_linearMaxMotorForce; + btVector3DoubleData m_linearServoTarget; + btVector3DoubleData m_linearSpringStiffness; + btVector3DoubleData m_linearSpringDamping; + btVector3DoubleData m_linearEquilibriumPoint; + char m_linearEnableMotor[4]; + char m_linearServoMotor[4]; + char m_linearEnableSpring[4]; + char m_linearSpringStiffnessLimited[4]; + char m_linearSpringDampingLimited[4]; + char m_padding1[4]; + + btVector3DoubleData m_angularUpperLimit; + btVector3DoubleData m_angularLowerLimit; + btVector3DoubleData m_angularBounce; + btVector3DoubleData m_angularStopERP; + btVector3DoubleData m_angularStopCFM; + btVector3DoubleData m_angularMotorERP; + btVector3DoubleData m_angularMotorCFM; + btVector3DoubleData m_angularTargetVelocity; + btVector3DoubleData m_angularMaxMotorForce; + btVector3DoubleData m_angularServoTarget; + btVector3DoubleData m_angularSpringStiffness; + btVector3DoubleData m_angularSpringDamping; + btVector3DoubleData m_angularEquilibriumPoint; + char m_angularEnableMotor[4]; + char m_angularServoMotor[4]; + char m_angularEnableSpring[4]; + char m_angularSpringStiffnessLimited[4]; + char m_angularSpringDampingLimited[4]; + + int m_rotateOrder; +}; + +SIMD_FORCE_INLINE int btGeneric6DofSpring2Constraint::calculateSerializeBufferSize() const +{ + return sizeof(btGeneric6DofSpring2ConstraintData2); +} + +SIMD_FORCE_INLINE const char* btGeneric6DofSpring2Constraint::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btGeneric6DofSpring2ConstraintData2* dof = (btGeneric6DofSpring2ConstraintData2*)dataBuffer; + btTypedConstraint::serialize(&dof->m_typeConstraintData, serializer); + + m_frameInA.serialize(dof->m_rbAFrame); + m_frameInB.serialize(dof->m_rbBFrame); + + int i; + for (i = 0; i < 3; i++) + { + dof->m_angularLowerLimit.m_floats[i] = m_angularLimits[i].m_loLimit; + dof->m_angularUpperLimit.m_floats[i] = m_angularLimits[i].m_hiLimit; + dof->m_angularBounce.m_floats[i] = m_angularLimits[i].m_bounce; + dof->m_angularStopERP.m_floats[i] = m_angularLimits[i].m_stopERP; + dof->m_angularStopCFM.m_floats[i] = m_angularLimits[i].m_stopCFM; + dof->m_angularMotorERP.m_floats[i] = m_angularLimits[i].m_motorERP; + dof->m_angularMotorCFM.m_floats[i] = m_angularLimits[i].m_motorCFM; + dof->m_angularTargetVelocity.m_floats[i] = m_angularLimits[i].m_targetVelocity; + dof->m_angularMaxMotorForce.m_floats[i] = m_angularLimits[i].m_maxMotorForce; + dof->m_angularServoTarget.m_floats[i] = m_angularLimits[i].m_servoTarget; + dof->m_angularSpringStiffness.m_floats[i] = m_angularLimits[i].m_springStiffness; + dof->m_angularSpringDamping.m_floats[i] = m_angularLimits[i].m_springDamping; + dof->m_angularEquilibriumPoint.m_floats[i] = m_angularLimits[i].m_equilibriumPoint; + } + dof->m_angularLowerLimit.m_floats[3] = 0; + dof->m_angularUpperLimit.m_floats[3] = 0; + dof->m_angularBounce.m_floats[3] = 0; + dof->m_angularStopERP.m_floats[3] = 0; + dof->m_angularStopCFM.m_floats[3] = 0; + dof->m_angularMotorERP.m_floats[3] = 0; + dof->m_angularMotorCFM.m_floats[3] = 0; + dof->m_angularTargetVelocity.m_floats[3] = 0; + dof->m_angularMaxMotorForce.m_floats[3] = 0; + dof->m_angularServoTarget.m_floats[3] = 0; + dof->m_angularSpringStiffness.m_floats[3] = 0; + dof->m_angularSpringDamping.m_floats[3] = 0; + dof->m_angularEquilibriumPoint.m_floats[3] = 0; + for (i = 0; i < 4; i++) + { + dof->m_angularEnableMotor[i] = i < 3 ? (m_angularLimits[i].m_enableMotor ? 1 : 0) : 0; + dof->m_angularServoMotor[i] = i < 3 ? (m_angularLimits[i].m_servoMotor ? 1 : 0) : 0; + dof->m_angularEnableSpring[i] = i < 3 ? (m_angularLimits[i].m_enableSpring ? 1 : 0) : 0; + dof->m_angularSpringStiffnessLimited[i] = i < 3 ? (m_angularLimits[i].m_springStiffnessLimited ? 1 : 0) : 0; + dof->m_angularSpringDampingLimited[i] = i < 3 ? (m_angularLimits[i].m_springDampingLimited ? 1 : 0) : 0; + } + + m_linearLimits.m_lowerLimit.serialize(dof->m_linearLowerLimit); + m_linearLimits.m_upperLimit.serialize(dof->m_linearUpperLimit); + m_linearLimits.m_bounce.serialize(dof->m_linearBounce); + m_linearLimits.m_stopERP.serialize(dof->m_linearStopERP); + m_linearLimits.m_stopCFM.serialize(dof->m_linearStopCFM); + m_linearLimits.m_motorERP.serialize(dof->m_linearMotorERP); + m_linearLimits.m_motorCFM.serialize(dof->m_linearMotorCFM); + m_linearLimits.m_targetVelocity.serialize(dof->m_linearTargetVelocity); + m_linearLimits.m_maxMotorForce.serialize(dof->m_linearMaxMotorForce); + m_linearLimits.m_servoTarget.serialize(dof->m_linearServoTarget); + m_linearLimits.m_springStiffness.serialize(dof->m_linearSpringStiffness); + m_linearLimits.m_springDamping.serialize(dof->m_linearSpringDamping); + m_linearLimits.m_equilibriumPoint.serialize(dof->m_linearEquilibriumPoint); + for (i = 0; i < 4; i++) + { + dof->m_linearEnableMotor[i] = i < 3 ? (m_linearLimits.m_enableMotor[i] ? 1 : 0) : 0; + dof->m_linearServoMotor[i] = i < 3 ? (m_linearLimits.m_servoMotor[i] ? 1 : 0) : 0; + dof->m_linearEnableSpring[i] = i < 3 ? (m_linearLimits.m_enableSpring[i] ? 1 : 0) : 0; + dof->m_linearSpringStiffnessLimited[i] = i < 3 ? (m_linearLimits.m_springStiffnessLimited[i] ? 1 : 0) : 0; + dof->m_linearSpringDampingLimited[i] = i < 3 ? (m_linearLimits.m_springDampingLimited[i] ? 1 : 0) : 0; + } + + dof->m_rotateOrder = m_rotateOrder; + + dof->m_padding1[0] = 0; + dof->m_padding1[1] = 0; + dof->m_padding1[2] = 0; + dof->m_padding1[3] = 0; + + return btGeneric6DofSpring2ConstraintDataName; +} + +#endif //BT_GENERIC_6DOF_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h.i new file mode 100644 index 00000000..c11b2a59 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp new file mode 100644 index 00000000..8baf52bc --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp @@ -0,0 +1,169 @@ +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btGeneric6DofSpringConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btTransformUtil.h" + +btGeneric6DofSpringConstraint::btGeneric6DofSpringConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA) + : btGeneric6DofConstraint(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA) +{ + init(); +} + +btGeneric6DofSpringConstraint::btGeneric6DofSpringConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameB) + : btGeneric6DofConstraint(rbB, frameInB, useLinearReferenceFrameB) +{ + init(); +} + +void btGeneric6DofSpringConstraint::init() +{ + m_objectType = D6_SPRING_CONSTRAINT_TYPE; + + for (int i = 0; i < 6; i++) + { + m_springEnabled[i] = false; + m_equilibriumPoint[i] = btScalar(0.f); + m_springStiffness[i] = btScalar(0.f); + m_springDamping[i] = btScalar(1.f); + } +} + +void btGeneric6DofSpringConstraint::enableSpring(int index, bool onOff) +{ + btAssert((index >= 0) && (index < 6)); + m_springEnabled[index] = onOff; + if (index < 3) + { + m_linearLimits.m_enableMotor[index] = onOff; + } + else + { + m_angularLimits[index - 3].m_enableMotor = onOff; + } +} + +void btGeneric6DofSpringConstraint::setStiffness(int index, btScalar stiffness) +{ + btAssert((index >= 0) && (index < 6)); + m_springStiffness[index] = stiffness; +} + +void btGeneric6DofSpringConstraint::setDamping(int index, btScalar damping) +{ + btAssert((index >= 0) && (index < 6)); + m_springDamping[index] = damping; +} + +void btGeneric6DofSpringConstraint::setEquilibriumPoint() +{ + calculateTransforms(); + int i; + + for (i = 0; i < 3; i++) + { + m_equilibriumPoint[i] = m_calculatedLinearDiff[i]; + } + for (i = 0; i < 3; i++) + { + m_equilibriumPoint[i + 3] = m_calculatedAxisAngleDiff[i]; + } +} + +void btGeneric6DofSpringConstraint::setEquilibriumPoint(int index) +{ + btAssert((index >= 0) && (index < 6)); + calculateTransforms(); + if (index < 3) + { + m_equilibriumPoint[index] = m_calculatedLinearDiff[index]; + } + else + { + m_equilibriumPoint[index] = m_calculatedAxisAngleDiff[index - 3]; + } +} + +void btGeneric6DofSpringConstraint::setEquilibriumPoint(int index, btScalar val) +{ + btAssert((index >= 0) && (index < 6)); + m_equilibriumPoint[index] = val; +} + +void btGeneric6DofSpringConstraint::internalUpdateSprings(btConstraintInfo2* info) +{ + // it is assumed that calculateTransforms() have been called before this call + int i; + //btVector3 relVel = m_rbB.getLinearVelocity() - m_rbA.getLinearVelocity(); + for (i = 0; i < 3; i++) + { + if (m_springEnabled[i]) + { + // get current position of constraint + btScalar currPos = m_calculatedLinearDiff[i]; + // calculate difference + btScalar delta = currPos - m_equilibriumPoint[i]; + // spring force is (delta * m_stiffness) according to Hooke's Law + btScalar force = delta * m_springStiffness[i]; + btScalar velFactor = info->fps * m_springDamping[i] / btScalar(info->m_numIterations); + m_linearLimits.m_targetVelocity[i] = velFactor * force; + m_linearLimits.m_maxMotorForce[i] = btFabs(force); + } + } + for (i = 0; i < 3; i++) + { + if (m_springEnabled[i + 3]) + { + // get current position of constraint + btScalar currPos = m_calculatedAxisAngleDiff[i]; + // calculate difference + btScalar delta = currPos - m_equilibriumPoint[i + 3]; + // spring force is (-delta * m_stiffness) according to Hooke's Law + btScalar force = -delta * m_springStiffness[i + 3]; + btScalar velFactor = info->fps * m_springDamping[i + 3] / btScalar(info->m_numIterations); + m_angularLimits[i].m_targetVelocity = velFactor * force; + m_angularLimits[i].m_maxMotorForce = btFabs(force); + } + } +} + +void btGeneric6DofSpringConstraint::getInfo2(btConstraintInfo2* info) +{ + // this will be called by constraint solver at the constraint setup stage + // set current motor parameters + internalUpdateSprings(info); + // do the rest of job for constraint setup + btGeneric6DofConstraint::getInfo2(info); +} + +void btGeneric6DofSpringConstraint::setAxis(const btVector3& axis1, const btVector3& axis2) +{ + btVector3 zAxis = axis1.normalized(); + btVector3 yAxis = axis2.normalized(); + btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system + + btTransform frameInW; + frameInW.setIdentity(); + frameInW.getBasis().setValue(xAxis[0], yAxis[0], zAxis[0], + xAxis[1], yAxis[1], zAxis[1], + xAxis[2], yAxis[2], zAxis[2]); + + // now get constraint frame in local coordinate systems + m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW; + m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW; + + calculateTransforms(); +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp.i new file mode 100644 index 00000000..9adb64fb --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h new file mode 100644 index 00000000..02b9d4d0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h @@ -0,0 +1,135 @@ +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +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_GENERIC_6DOF_SPRING_CONSTRAINT_H +#define BT_GENERIC_6DOF_SPRING_CONSTRAINT_H + +#include "LinearMath/btVector3.h" +#include "btTypedConstraint.h" +#include "btGeneric6DofConstraint.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintDoubleData2 +#define btGeneric6DofSpringConstraintDataName "btGeneric6DofSpringConstraintDoubleData2" +#else +#define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintData +#define btGeneric6DofSpringConstraintDataName "btGeneric6DofSpringConstraintData" +#endif //BT_USE_DOUBLE_PRECISION + +/// Generic 6 DOF constraint that allows to set spring motors to any translational and rotational DOF + +/// DOF index used in enableSpring() and setStiffness() means: +/// 0 : translation X +/// 1 : translation Y +/// 2 : translation Z +/// 3 : rotation X (3rd Euler rotational around new position of X axis, range [-PI+epsilon, PI-epsilon] ) +/// 4 : rotation Y (2nd Euler rotational around new position of Y axis, range [-PI/2+epsilon, PI/2-epsilon] ) +/// 5 : rotation Z (1st Euler rotational around Z axis, range [-PI+epsilon, PI-epsilon] ) + +ATTRIBUTE_ALIGNED16(class) +btGeneric6DofSpringConstraint : public btGeneric6DofConstraint +{ +protected: + bool m_springEnabled[6]; + btScalar m_equilibriumPoint[6]; + btScalar m_springStiffness[6]; + btScalar m_springDamping[6]; // between 0 and 1 (1 == no damping) + void init(); + void internalUpdateSprings(btConstraintInfo2 * info); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btGeneric6DofSpringConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA); + btGeneric6DofSpringConstraint(btRigidBody & rbB, const btTransform& frameInB, bool useLinearReferenceFrameB); + void enableSpring(int index, bool onOff); + void setStiffness(int index, btScalar stiffness); + void setDamping(int index, btScalar damping); + void setEquilibriumPoint(); // set the current constraint position/orientation as an equilibrium point for all DOF + void setEquilibriumPoint(int index); // set the current constraint position/orientation as an equilibrium point for given DOF + void setEquilibriumPoint(int index, btScalar val); + + bool isSpringEnabled(int index) const + { + return m_springEnabled[index]; + } + + btScalar getStiffness(int index) const + { + return m_springStiffness[index]; + } + + btScalar getDamping(int index) const + { + return m_springDamping[index]; + } + + btScalar getEquilibriumPoint(int index) const + { + return m_equilibriumPoint[index]; + } + + virtual void setAxis(const btVector3& axis1, const btVector3& axis2); + + virtual void getInfo2(btConstraintInfo2 * info); + + virtual int calculateSerializeBufferSize() const; + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +struct btGeneric6DofSpringConstraintData +{ + btGeneric6DofConstraintData m_6dofData; + + int m_springEnabled[6]; + float m_equilibriumPoint[6]; + float m_springStiffness[6]; + float m_springDamping[6]; +}; + +struct btGeneric6DofSpringConstraintDoubleData2 +{ + btGeneric6DofConstraintDoubleData2 m_6dofData; + + int m_springEnabled[6]; + double m_equilibriumPoint[6]; + double m_springStiffness[6]; + double m_springDamping[6]; +}; + +SIMD_FORCE_INLINE int btGeneric6DofSpringConstraint::calculateSerializeBufferSize() const +{ + return sizeof(btGeneric6DofSpringConstraintData2); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btGeneric6DofSpringConstraint::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btGeneric6DofSpringConstraintData2* dof = (btGeneric6DofSpringConstraintData2*)dataBuffer; + btGeneric6DofConstraint::serialize(&dof->m_6dofData, serializer); + + int i; + for (i = 0; i < 6; i++) + { + dof->m_equilibriumPoint[i] = m_equilibriumPoint[i]; + dof->m_springDamping[i] = m_springDamping[i]; + dof->m_springEnabled[i] = m_springEnabled[i] ? 1 : 0; + dof->m_springStiffness[i] = m_springStiffness[i]; + } + return btGeneric6DofSpringConstraintDataName; +} + +#endif // BT_GENERIC_6DOF_SPRING_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h.i new file mode 100644 index 00000000..f70f6c9e --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp new file mode 100644 index 00000000..6507e1a0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp @@ -0,0 +1,61 @@ +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btHinge2Constraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btTransformUtil.h" + +// constructor +// anchor, axis1 and axis2 are in world coordinate system +// axis1 must be orthogonal to axis2 +btHinge2Constraint::btHinge2Constraint(btRigidBody& rbA, btRigidBody& rbB, btVector3& anchor, btVector3& axis1, btVector3& axis2) + : btGeneric6DofSpring2Constraint(rbA, rbB, btTransform::getIdentity(), btTransform::getIdentity(), RO_XYZ), + m_anchor(anchor), + m_axis1(axis1), + m_axis2(axis2) +{ + // build frame basis + // 6DOF constraint uses Euler angles and to define limits + // it is assumed that rotational order is : + // Z - first, allowed limits are (-PI,PI); + // new position of Y - second (allowed limits are (-PI/2 + epsilon, PI/2 - epsilon), where epsilon is a small positive number + // used to prevent constraint from instability on poles; + // new position of X, allowed limits are (-PI,PI); + // So to simulate ODE Universal joint we should use parent axis as Z, child axis as Y and limit all other DOFs + // Build the frame in world coordinate system first + btVector3 zAxis = axis1.normalize(); + btVector3 xAxis = axis2.normalize(); + btVector3 yAxis = zAxis.cross(xAxis); // we want right coordinate system + btTransform frameInW; + frameInW.setIdentity(); + frameInW.getBasis().setValue(xAxis[0], yAxis[0], zAxis[0], + xAxis[1], yAxis[1], zAxis[1], + xAxis[2], yAxis[2], zAxis[2]); + frameInW.setOrigin(anchor); + // now get constraint frame in local coordinate systems + m_frameInA = rbA.getCenterOfMassTransform().inverse() * frameInW; + m_frameInB = rbB.getCenterOfMassTransform().inverse() * frameInW; + // sei limits + setLinearLowerLimit(btVector3(0.f, 0.f, -1.f)); + setLinearUpperLimit(btVector3(0.f, 0.f, 1.f)); + // like front wheels of a car + setAngularLowerLimit(btVector3(1.f, 0.f, -SIMD_HALF_PI * 0.5f)); + setAngularUpperLimit(btVector3(-1.f, 0.f, SIMD_HALF_PI * 0.5f)); + // enable suspension + enableSpring(2, true); + setStiffness(2, SIMD_PI * SIMD_PI * 4.f); + setDamping(2, 0.01f); + setEquilibriumPoint(); +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp.i new file mode 100644 index 00000000..be9e223e --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btHinge2Constraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.h new file mode 100644 index 00000000..95f604a8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.h @@ -0,0 +1,55 @@ +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +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_HINGE2_CONSTRAINT_H +#define BT_HINGE2_CONSTRAINT_H + +#include "LinearMath/btVector3.h" +#include "btTypedConstraint.h" +#include "btGeneric6DofSpring2Constraint.h" + +// Constraint similar to ODE Hinge2 Joint +// has 3 degrees of frredom: +// 2 rotational degrees of freedom, similar to Euler rotations around Z (axis 1) and X (axis 2) +// 1 translational (along axis Z) with suspension spring + +ATTRIBUTE_ALIGNED16(class) +btHinge2Constraint : public btGeneric6DofSpring2Constraint +{ +protected: + btVector3 m_anchor; + btVector3 m_axis1; + btVector3 m_axis2; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + // constructor + // anchor, axis1 and axis2 are in world coordinate system + // axis1 must be orthogonal to axis2 + btHinge2Constraint(btRigidBody & rbA, btRigidBody & rbB, btVector3 & anchor, btVector3 & axis1, btVector3 & axis2); + // access + const btVector3& getAnchor() { return m_calculatedTransformA.getOrigin(); } + const btVector3& getAnchor2() { return m_calculatedTransformB.getOrigin(); } + const btVector3& getAxis1() { return m_axis1; } + const btVector3& getAxis2() { return m_axis2; } + btScalar getAngle1() { return getAngle(2); } + btScalar getAngle2() { return getAngle(0); } + // limits + void setUpperLimit(btScalar ang1max) { setAngularUpperLimit(btVector3(-1.f, 0.f, ang1max)); } + void setLowerLimit(btScalar ang1min) { setAngularLowerLimit(btVector3(1.f, 0.f, ang1min)); } +}; + +#endif // BT_HINGE2_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.h.i new file mode 100644 index 00000000..3c294e57 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHinge2Constraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btHinge2Constraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btHinge2Constraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btHinge2Constraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp new file mode 100644 index 00000000..cb59e5a5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp @@ -0,0 +1,1083 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btHingeConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btTransformUtil.h" +#include "LinearMath/btMinMax.h" +#include +#include "btSolverBody.h" + +//#define HINGE_USE_OBSOLETE_SOLVER false +#define HINGE_USE_OBSOLETE_SOLVER false + +#define HINGE_USE_FRAME_OFFSET true + +#ifndef __SPU__ + +btHingeConstraint::btHingeConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& pivotInA, const btVector3& pivotInB, + const btVector3& axisInA, const btVector3& axisInB, bool useReferenceFrameA) + : btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA, rbB), +#ifdef _BT_USE_CENTER_LIMIT_ + m_limit(), +#endif + m_angularOnly(false), + m_enableAngularMotor(false), + m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER), + m_useOffsetForConstraintFrame(HINGE_USE_FRAME_OFFSET), + m_useReferenceFrameA(useReferenceFrameA), + m_flags(0), + m_normalCFM(0), + m_normalERP(0), + m_stopCFM(0), + m_stopERP(0) +{ + m_rbAFrame.getOrigin() = pivotInA; + + // since no frame is given, assume this to be zero angle and just pick rb transform axis + btVector3 rbAxisA1 = rbA.getCenterOfMassTransform().getBasis().getColumn(0); + + btVector3 rbAxisA2; + btScalar projection = axisInA.dot(rbAxisA1); + if (projection >= 1.0f - SIMD_EPSILON) + { + rbAxisA1 = -rbA.getCenterOfMassTransform().getBasis().getColumn(2); + rbAxisA2 = rbA.getCenterOfMassTransform().getBasis().getColumn(1); + } + else if (projection <= -1.0f + SIMD_EPSILON) + { + rbAxisA1 = rbA.getCenterOfMassTransform().getBasis().getColumn(2); + rbAxisA2 = rbA.getCenterOfMassTransform().getBasis().getColumn(1); + } + else + { + rbAxisA2 = axisInA.cross(rbAxisA1); + rbAxisA1 = rbAxisA2.cross(axisInA); + } + + m_rbAFrame.getBasis().setValue(rbAxisA1.getX(), rbAxisA2.getX(), axisInA.getX(), + rbAxisA1.getY(), rbAxisA2.getY(), axisInA.getY(), + rbAxisA1.getZ(), rbAxisA2.getZ(), axisInA.getZ()); + + btQuaternion rotationArc = shortestArcQuat(axisInA, axisInB); + btVector3 rbAxisB1 = quatRotate(rotationArc, rbAxisA1); + btVector3 rbAxisB2 = axisInB.cross(rbAxisB1); + + m_rbBFrame.getOrigin() = pivotInB; + m_rbBFrame.getBasis().setValue(rbAxisB1.getX(), rbAxisB2.getX(), axisInB.getX(), + rbAxisB1.getY(), rbAxisB2.getY(), axisInB.getY(), + rbAxisB1.getZ(), rbAxisB2.getZ(), axisInB.getZ()); + +#ifndef _BT_USE_CENTER_LIMIT_ + //start with free + m_lowerLimit = btScalar(1.0f); + m_upperLimit = btScalar(-1.0f); + m_biasFactor = 0.3f; + m_relaxationFactor = 1.0f; + m_limitSoftness = 0.9f; + m_solveLimit = false; +#endif + m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f); +} + +btHingeConstraint::btHingeConstraint(btRigidBody& rbA, const btVector3& pivotInA, const btVector3& axisInA, bool useReferenceFrameA) + : btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA), +#ifdef _BT_USE_CENTER_LIMIT_ + m_limit(), +#endif + m_angularOnly(false), + m_enableAngularMotor(false), + m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER), + m_useOffsetForConstraintFrame(HINGE_USE_FRAME_OFFSET), + m_useReferenceFrameA(useReferenceFrameA), + m_flags(0), + m_normalCFM(0), + m_normalERP(0), + m_stopCFM(0), + m_stopERP(0) +{ + // since no frame is given, assume this to be zero angle and just pick rb transform axis + // fixed axis in worldspace + btVector3 rbAxisA1, rbAxisA2; + btPlaneSpace1(axisInA, rbAxisA1, rbAxisA2); + + m_rbAFrame.getOrigin() = pivotInA; + m_rbAFrame.getBasis().setValue(rbAxisA1.getX(), rbAxisA2.getX(), axisInA.getX(), + rbAxisA1.getY(), rbAxisA2.getY(), axisInA.getY(), + rbAxisA1.getZ(), rbAxisA2.getZ(), axisInA.getZ()); + + btVector3 axisInB = rbA.getCenterOfMassTransform().getBasis() * axisInA; + + btQuaternion rotationArc = shortestArcQuat(axisInA, axisInB); + btVector3 rbAxisB1 = quatRotate(rotationArc, rbAxisA1); + btVector3 rbAxisB2 = axisInB.cross(rbAxisB1); + + m_rbBFrame.getOrigin() = rbA.getCenterOfMassTransform()(pivotInA); + m_rbBFrame.getBasis().setValue(rbAxisB1.getX(), rbAxisB2.getX(), axisInB.getX(), + rbAxisB1.getY(), rbAxisB2.getY(), axisInB.getY(), + rbAxisB1.getZ(), rbAxisB2.getZ(), axisInB.getZ()); + +#ifndef _BT_USE_CENTER_LIMIT_ + //start with free + m_lowerLimit = btScalar(1.0f); + m_upperLimit = btScalar(-1.0f); + m_biasFactor = 0.3f; + m_relaxationFactor = 1.0f; + m_limitSoftness = 0.9f; + m_solveLimit = false; +#endif + m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f); +} + +btHingeConstraint::btHingeConstraint(btRigidBody& rbA, btRigidBody& rbB, + const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA) + : btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA, rbB), m_rbAFrame(rbAFrame), m_rbBFrame(rbBFrame), +#ifdef _BT_USE_CENTER_LIMIT_ + m_limit(), +#endif + m_angularOnly(false), + m_enableAngularMotor(false), + m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER), + m_useOffsetForConstraintFrame(HINGE_USE_FRAME_OFFSET), + m_useReferenceFrameA(useReferenceFrameA), + m_flags(0), + m_normalCFM(0), + m_normalERP(0), + m_stopCFM(0), + m_stopERP(0) +{ +#ifndef _BT_USE_CENTER_LIMIT_ + //start with free + m_lowerLimit = btScalar(1.0f); + m_upperLimit = btScalar(-1.0f); + m_biasFactor = 0.3f; + m_relaxationFactor = 1.0f; + m_limitSoftness = 0.9f; + m_solveLimit = false; +#endif + m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f); +} + +btHingeConstraint::btHingeConstraint(btRigidBody& rbA, const btTransform& rbAFrame, bool useReferenceFrameA) + : btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA), m_rbAFrame(rbAFrame), m_rbBFrame(rbAFrame), +#ifdef _BT_USE_CENTER_LIMIT_ + m_limit(), +#endif + m_angularOnly(false), + m_enableAngularMotor(false), + m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER), + m_useOffsetForConstraintFrame(HINGE_USE_FRAME_OFFSET), + m_useReferenceFrameA(useReferenceFrameA), + m_flags(0), + m_normalCFM(0), + m_normalERP(0), + m_stopCFM(0), + m_stopERP(0) +{ + ///not providing rigidbody B means implicitly using worldspace for body B + + m_rbBFrame.getOrigin() = m_rbA.getCenterOfMassTransform()(m_rbAFrame.getOrigin()); +#ifndef _BT_USE_CENTER_LIMIT_ + //start with free + m_lowerLimit = btScalar(1.0f); + m_upperLimit = btScalar(-1.0f); + m_biasFactor = 0.3f; + m_relaxationFactor = 1.0f; + m_limitSoftness = 0.9f; + m_solveLimit = false; +#endif + m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f); +} + +void btHingeConstraint::buildJacobian() +{ + if (m_useSolveConstraintObsolete) + { + m_appliedImpulse = btScalar(0.); + m_accMotorImpulse = btScalar(0.); + + if (!m_angularOnly) + { + btVector3 pivotAInW = m_rbA.getCenterOfMassTransform() * m_rbAFrame.getOrigin(); + btVector3 pivotBInW = m_rbB.getCenterOfMassTransform() * m_rbBFrame.getOrigin(); + btVector3 relPos = pivotBInW - pivotAInW; + + btVector3 normal[3]; + if (relPos.length2() > SIMD_EPSILON) + { + normal[0] = relPos.normalized(); + } + else + { + normal[0].setValue(btScalar(1.0), 0, 0); + } + + btPlaneSpace1(normal[0], normal[1], normal[2]); + + for (int i = 0; i < 3; i++) + { + new (&m_jac[i]) btJacobianEntry( + m_rbA.getCenterOfMassTransform().getBasis().transpose(), + m_rbB.getCenterOfMassTransform().getBasis().transpose(), + pivotAInW - m_rbA.getCenterOfMassPosition(), + pivotBInW - m_rbB.getCenterOfMassPosition(), + normal[i], + m_rbA.getInvInertiaDiagLocal(), + m_rbA.getInvMass(), + m_rbB.getInvInertiaDiagLocal(), + m_rbB.getInvMass()); + } + } + + //calculate two perpendicular jointAxis, orthogonal to hingeAxis + //these two jointAxis require equal angular velocities for both bodies + + //this is unused for now, it's a todo + btVector3 jointAxis0local; + btVector3 jointAxis1local; + + btPlaneSpace1(m_rbAFrame.getBasis().getColumn(2), jointAxis0local, jointAxis1local); + + btVector3 jointAxis0 = getRigidBodyA().getCenterOfMassTransform().getBasis() * jointAxis0local; + btVector3 jointAxis1 = getRigidBodyA().getCenterOfMassTransform().getBasis() * jointAxis1local; + btVector3 hingeAxisWorld = getRigidBodyA().getCenterOfMassTransform().getBasis() * m_rbAFrame.getBasis().getColumn(2); + + new (&m_jacAng[0]) btJacobianEntry(jointAxis0, + m_rbA.getCenterOfMassTransform().getBasis().transpose(), + m_rbB.getCenterOfMassTransform().getBasis().transpose(), + m_rbA.getInvInertiaDiagLocal(), + m_rbB.getInvInertiaDiagLocal()); + + new (&m_jacAng[1]) btJacobianEntry(jointAxis1, + m_rbA.getCenterOfMassTransform().getBasis().transpose(), + m_rbB.getCenterOfMassTransform().getBasis().transpose(), + m_rbA.getInvInertiaDiagLocal(), + m_rbB.getInvInertiaDiagLocal()); + + new (&m_jacAng[2]) btJacobianEntry(hingeAxisWorld, + m_rbA.getCenterOfMassTransform().getBasis().transpose(), + m_rbB.getCenterOfMassTransform().getBasis().transpose(), + m_rbA.getInvInertiaDiagLocal(), + m_rbB.getInvInertiaDiagLocal()); + + // clear accumulator + m_accLimitImpulse = btScalar(0.); + + // test angular limit + testLimit(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); + + //Compute K = J*W*J' for hinge axis + btVector3 axisA = getRigidBodyA().getCenterOfMassTransform().getBasis() * m_rbAFrame.getBasis().getColumn(2); + m_kHinge = 1.0f / (getRigidBodyA().computeAngularImpulseDenominator(axisA) + + getRigidBodyB().computeAngularImpulseDenominator(axisA)); + } +} + +#endif //__SPU__ + +static inline btScalar btNormalizeAnglePositive(btScalar angle) +{ + return btFmod(btFmod(angle, btScalar(2.0 * SIMD_PI)) + btScalar(2.0 * SIMD_PI), btScalar(2.0 * SIMD_PI)); +} + +static btScalar btShortestAngularDistance(btScalar accAngle, btScalar curAngle) +{ + btScalar result = btNormalizeAngle(btNormalizeAnglePositive(btNormalizeAnglePositive(curAngle) - + btNormalizeAnglePositive(accAngle))); + return result; +} + +static btScalar btShortestAngleUpdate(btScalar accAngle, btScalar curAngle) +{ + btScalar tol(0.3); + btScalar result = btShortestAngularDistance(accAngle, curAngle); + + if (btFabs(result) > tol) + return curAngle; + else + return accAngle + result; + + return curAngle; +} + +btScalar btHingeAccumulatedAngleConstraint::getAccumulatedHingeAngle() +{ + btScalar hingeAngle = getHingeAngle(); + m_accumulatedAngle = btShortestAngleUpdate(m_accumulatedAngle, hingeAngle); + return m_accumulatedAngle; +} +void btHingeAccumulatedAngleConstraint::setAccumulatedHingeAngle(btScalar accAngle) +{ + m_accumulatedAngle = accAngle; +} + +void btHingeAccumulatedAngleConstraint::getInfo1(btConstraintInfo1* info) +{ + //update m_accumulatedAngle + btScalar curHingeAngle = getHingeAngle(); + m_accumulatedAngle = btShortestAngleUpdate(m_accumulatedAngle, curHingeAngle); + + btHingeConstraint::getInfo1(info); +} + +void btHingeConstraint::getInfo1(btConstraintInfo1* info) +{ + if (m_useSolveConstraintObsolete) + { + info->m_numConstraintRows = 0; + info->nub = 0; + } + else + { + info->m_numConstraintRows = 5; // Fixed 3 linear + 2 angular + info->nub = 1; + //always add the row, to avoid computation (data is not available yet) + //prepare constraint + testLimit(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); + if (getSolveLimit() || getEnableAngularMotor()) + { + info->m_numConstraintRows++; // limit 3rd anguar as well + info->nub--; + } + } +} + +void btHingeConstraint::getInfo1NonVirtual(btConstraintInfo1* info) +{ + if (m_useSolveConstraintObsolete) + { + info->m_numConstraintRows = 0; + info->nub = 0; + } + else + { + //always add the 'limit' row, to avoid computation (data is not available yet) + info->m_numConstraintRows = 6; // Fixed 3 linear + 2 angular + info->nub = 0; + } +} + +void btHingeConstraint::getInfo2(btConstraintInfo2* info) +{ + if (m_useOffsetForConstraintFrame) + { + getInfo2InternalUsingFrameOffset(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getAngularVelocity(), m_rbB.getAngularVelocity()); + } + else + { + getInfo2Internal(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getAngularVelocity(), m_rbB.getAngularVelocity()); + } +} + +void btHingeConstraint::getInfo2NonVirtual(btConstraintInfo2* info, const btTransform& transA, const btTransform& transB, const btVector3& angVelA, const btVector3& angVelB) +{ + ///the regular (virtual) implementation getInfo2 already performs 'testLimit' during getInfo1, so we need to do it now + testLimit(transA, transB); + + getInfo2Internal(info, transA, transB, angVelA, angVelB); +} + +void btHingeConstraint::getInfo2Internal(btConstraintInfo2* info, const btTransform& transA, const btTransform& transB, const btVector3& angVelA, const btVector3& angVelB) +{ + btAssert(!m_useSolveConstraintObsolete); + int i, skip = info->rowskip; + // transforms in world space + btTransform trA = transA * m_rbAFrame; + btTransform trB = transB * m_rbBFrame; + // pivot point + btVector3 pivotAInW = trA.getOrigin(); + btVector3 pivotBInW = trB.getOrigin(); +#if 0 + if (0) + { + for (i=0;i<6;i++) + { + info->m_J1linearAxis[i*skip]=0; + info->m_J1linearAxis[i*skip+1]=0; + info->m_J1linearAxis[i*skip+2]=0; + + info->m_J1angularAxis[i*skip]=0; + info->m_J1angularAxis[i*skip+1]=0; + info->m_J1angularAxis[i*skip+2]=0; + + info->m_J2linearAxis[i*skip]=0; + info->m_J2linearAxis[i*skip+1]=0; + info->m_J2linearAxis[i*skip+2]=0; + + info->m_J2angularAxis[i*skip]=0; + info->m_J2angularAxis[i*skip+1]=0; + info->m_J2angularAxis[i*skip+2]=0; + + info->m_constraintError[i*skip]=0.f; + } + } +#endif //#if 0 + // linear (all fixed) + + if (!m_angularOnly) + { + info->m_J1linearAxis[0] = 1; + info->m_J1linearAxis[skip + 1] = 1; + info->m_J1linearAxis[2 * skip + 2] = 1; + + info->m_J2linearAxis[0] = -1; + info->m_J2linearAxis[skip + 1] = -1; + info->m_J2linearAxis[2 * skip + 2] = -1; + } + + btVector3 a1 = pivotAInW - transA.getOrigin(); + { + btVector3* angular0 = (btVector3*)(info->m_J1angularAxis); + btVector3* angular1 = (btVector3*)(info->m_J1angularAxis + skip); + btVector3* angular2 = (btVector3*)(info->m_J1angularAxis + 2 * skip); + btVector3 a1neg = -a1; + a1neg.getSkewSymmetricMatrix(angular0, angular1, angular2); + } + btVector3 a2 = pivotBInW - transB.getOrigin(); + { + btVector3* angular0 = (btVector3*)(info->m_J2angularAxis); + btVector3* angular1 = (btVector3*)(info->m_J2angularAxis + skip); + btVector3* angular2 = (btVector3*)(info->m_J2angularAxis + 2 * skip); + a2.getSkewSymmetricMatrix(angular0, angular1, angular2); + } + // linear RHS + btScalar normalErp = (m_flags & BT_HINGE_FLAGS_ERP_NORM) ? m_normalERP : info->erp; + + btScalar k = info->fps * normalErp; + if (!m_angularOnly) + { + for (i = 0; i < 3; i++) + { + info->m_constraintError[i * skip] = k * (pivotBInW[i] - pivotAInW[i]); + } + } + // make rotations around X and Y equal + // the hinge axis should be the only unconstrained + // rotational axis, the angular velocity of the two bodies perpendicular to + // the hinge axis should be equal. thus the constraint equations are + // p*w1 - p*w2 = 0 + // q*w1 - q*w2 = 0 + // where p and q are unit vectors normal to the hinge axis, and w1 and w2 + // are the angular velocity vectors of the two bodies. + // get hinge axis (Z) + btVector3 ax1 = trA.getBasis().getColumn(2); + // get 2 orthos to hinge axis (X, Y) + btVector3 p = trA.getBasis().getColumn(0); + btVector3 q = trA.getBasis().getColumn(1); + // set the two hinge angular rows + int s3 = 3 * info->rowskip; + int s4 = 4 * info->rowskip; + + info->m_J1angularAxis[s3 + 0] = p[0]; + info->m_J1angularAxis[s3 + 1] = p[1]; + info->m_J1angularAxis[s3 + 2] = p[2]; + info->m_J1angularAxis[s4 + 0] = q[0]; + info->m_J1angularAxis[s4 + 1] = q[1]; + info->m_J1angularAxis[s4 + 2] = q[2]; + + info->m_J2angularAxis[s3 + 0] = -p[0]; + info->m_J2angularAxis[s3 + 1] = -p[1]; + info->m_J2angularAxis[s3 + 2] = -p[2]; + info->m_J2angularAxis[s4 + 0] = -q[0]; + info->m_J2angularAxis[s4 + 1] = -q[1]; + info->m_J2angularAxis[s4 + 2] = -q[2]; + // compute the right hand side of the constraint equation. set relative + // body velocities along p and q to bring the hinge back into alignment. + // if ax1,ax2 are the unit length hinge axes as computed from body1 and + // body2, we need to rotate both bodies along the axis u = (ax1 x ax2). + // if `theta' is the angle between ax1 and ax2, we need an angular velocity + // along u to cover angle erp*theta in one step : + // |angular_velocity| = angle/time = erp*theta / stepsize + // = (erp*fps) * theta + // angular_velocity = |angular_velocity| * (ax1 x ax2) / |ax1 x ax2| + // = (erp*fps) * theta * (ax1 x ax2) / sin(theta) + // ...as ax1 and ax2 are unit length. if theta is smallish, + // theta ~= sin(theta), so + // angular_velocity = (erp*fps) * (ax1 x ax2) + // ax1 x ax2 is in the plane space of ax1, so we project the angular + // velocity to p and q to find the right hand side. + btVector3 ax2 = trB.getBasis().getColumn(2); + btVector3 u = ax1.cross(ax2); + info->m_constraintError[s3] = k * u.dot(p); + info->m_constraintError[s4] = k * u.dot(q); + // check angular limits + int nrow = 4; // last filled row + int srow; + btScalar limit_err = btScalar(0.0); + int limit = 0; + if (getSolveLimit()) + { +#ifdef _BT_USE_CENTER_LIMIT_ + limit_err = m_limit.getCorrection() * m_referenceSign; +#else + limit_err = m_correction * m_referenceSign; +#endif + limit = (limit_err > btScalar(0.0)) ? 1 : 2; + } + // if the hinge has joint limits or motor, add in the extra row + bool powered = getEnableAngularMotor(); + if (limit || powered) + { + nrow++; + srow = nrow * info->rowskip; + info->m_J1angularAxis[srow + 0] = ax1[0]; + info->m_J1angularAxis[srow + 1] = ax1[1]; + info->m_J1angularAxis[srow + 2] = ax1[2]; + + info->m_J2angularAxis[srow + 0] = -ax1[0]; + info->m_J2angularAxis[srow + 1] = -ax1[1]; + info->m_J2angularAxis[srow + 2] = -ax1[2]; + + btScalar lostop = getLowerLimit(); + btScalar histop = getUpperLimit(); + if (limit && (lostop == histop)) + { // the joint motor is ineffective + powered = false; + } + info->m_constraintError[srow] = btScalar(0.0f); + btScalar currERP = (m_flags & BT_HINGE_FLAGS_ERP_STOP) ? m_stopERP : normalErp; + if (powered) + { + if (m_flags & BT_HINGE_FLAGS_CFM_NORM) + { + info->cfm[srow] = m_normalCFM; + } + btScalar mot_fact = getMotorFactor(m_hingeAngle, lostop, histop, m_motorTargetVelocity, info->fps * currERP); + info->m_constraintError[srow] += mot_fact * m_motorTargetVelocity * m_referenceSign; + info->m_lowerLimit[srow] = -m_maxMotorImpulse; + info->m_upperLimit[srow] = m_maxMotorImpulse; + } + if (limit) + { + k = info->fps * currERP; + info->m_constraintError[srow] += k * limit_err; + if (m_flags & BT_HINGE_FLAGS_CFM_STOP) + { + info->cfm[srow] = m_stopCFM; + } + if (lostop == histop) + { + // limited low and high simultaneously + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + else if (limit == 1) + { // low limit + info->m_lowerLimit[srow] = 0; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + else + { // high limit + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = 0; + } + // bounce (we'll use slider parameter abs(1.0 - m_dampingLimAng) for that) +#ifdef _BT_USE_CENTER_LIMIT_ + btScalar bounce = m_limit.getRelaxationFactor(); +#else + btScalar bounce = m_relaxationFactor; +#endif + if (bounce > btScalar(0.0)) + { + btScalar vel = angVelA.dot(ax1); + vel -= angVelB.dot(ax1); + // only apply bounce if the velocity is incoming, and if the + // resulting c[] exceeds what we already have. + if (limit == 1) + { // low limit + if (vel < 0) + { + btScalar newc = -bounce * vel; + if (newc > info->m_constraintError[srow]) + { + info->m_constraintError[srow] = newc; + } + } + } + else + { // high limit - all those computations are reversed + if (vel > 0) + { + btScalar newc = -bounce * vel; + if (newc < info->m_constraintError[srow]) + { + info->m_constraintError[srow] = newc; + } + } + } + } +#ifdef _BT_USE_CENTER_LIMIT_ + info->m_constraintError[srow] *= m_limit.getBiasFactor(); +#else + info->m_constraintError[srow] *= m_biasFactor; +#endif + } // if(limit) + } // if angular limit or powered +} + +void btHingeConstraint::setFrames(const btTransform& frameA, const btTransform& frameB) +{ + m_rbAFrame = frameA; + m_rbBFrame = frameB; + buildJacobian(); +} + +void btHingeConstraint::updateRHS(btScalar timeStep) +{ + (void)timeStep; +} + +btScalar btHingeConstraint::getHingeAngle() +{ + return getHingeAngle(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); +} + +btScalar btHingeConstraint::getHingeAngle(const btTransform& transA, const btTransform& transB) +{ + const btVector3 refAxis0 = transA.getBasis() * m_rbAFrame.getBasis().getColumn(0); + const btVector3 refAxis1 = transA.getBasis() * m_rbAFrame.getBasis().getColumn(1); + const btVector3 swingAxis = transB.getBasis() * m_rbBFrame.getBasis().getColumn(1); + // btScalar angle = btAtan2Fast(swingAxis.dot(refAxis0), swingAxis.dot(refAxis1)); + btScalar angle = btAtan2(swingAxis.dot(refAxis0), swingAxis.dot(refAxis1)); + return m_referenceSign * angle; +} + +void btHingeConstraint::testLimit(const btTransform& transA, const btTransform& transB) +{ + // Compute limit information + m_hingeAngle = getHingeAngle(transA, transB); +#ifdef _BT_USE_CENTER_LIMIT_ + m_limit.test(m_hingeAngle); +#else + m_correction = btScalar(0.); + m_limitSign = btScalar(0.); + m_solveLimit = false; + if (m_lowerLimit <= m_upperLimit) + { + m_hingeAngle = btAdjustAngleToLimits(m_hingeAngle, m_lowerLimit, m_upperLimit); + if (m_hingeAngle <= m_lowerLimit) + { + m_correction = (m_lowerLimit - m_hingeAngle); + m_limitSign = 1.0f; + m_solveLimit = true; + } + else if (m_hingeAngle >= m_upperLimit) + { + m_correction = m_upperLimit - m_hingeAngle; + m_limitSign = -1.0f; + m_solveLimit = true; + } + } +#endif + return; +} + +static btVector3 vHinge(0, 0, btScalar(1)); + +void btHingeConstraint::setMotorTarget(const btQuaternion& qAinB, btScalar dt) +{ + // convert target from body to constraint space + btQuaternion qConstraint = m_rbBFrame.getRotation().inverse() * qAinB * m_rbAFrame.getRotation(); + qConstraint.normalize(); + + // extract "pure" hinge component + btVector3 vNoHinge = quatRotate(qConstraint, vHinge); + vNoHinge.normalize(); + btQuaternion qNoHinge = shortestArcQuat(vHinge, vNoHinge); + btQuaternion qHinge = qNoHinge.inverse() * qConstraint; + qHinge.normalize(); + + // compute angular target, clamped to limits + btScalar targetAngle = qHinge.getAngle(); + if (targetAngle > SIMD_PI) // long way around. flip quat and recalculate. + { + qHinge = -(qHinge); + targetAngle = qHinge.getAngle(); + } + if (qHinge.getZ() < 0) + targetAngle = -targetAngle; + + setMotorTarget(targetAngle, dt); +} + +void btHingeConstraint::setMotorTarget(btScalar targetAngle, btScalar dt) +{ +#ifdef _BT_USE_CENTER_LIMIT_ + m_limit.fit(targetAngle); +#else + if (m_lowerLimit < m_upperLimit) + { + if (targetAngle < m_lowerLimit) + targetAngle = m_lowerLimit; + else if (targetAngle > m_upperLimit) + targetAngle = m_upperLimit; + } +#endif + // compute angular velocity + btScalar curAngle = getHingeAngle(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); + btScalar dAngle = targetAngle - curAngle; + m_motorTargetVelocity = dAngle / dt; +} + +void btHingeConstraint::getInfo2InternalUsingFrameOffset(btConstraintInfo2* info, const btTransform& transA, const btTransform& transB, const btVector3& angVelA, const btVector3& angVelB) +{ + btAssert(!m_useSolveConstraintObsolete); + int i, s = info->rowskip; + // transforms in world space + btTransform trA = transA * m_rbAFrame; + btTransform trB = transB * m_rbBFrame; + // pivot point +// btVector3 pivotAInW = trA.getOrigin(); +// btVector3 pivotBInW = trB.getOrigin(); +#if 1 + // difference between frames in WCS + btVector3 ofs = trB.getOrigin() - trA.getOrigin(); + // now get weight factors depending on masses + btScalar miA = getRigidBodyA().getInvMass(); + btScalar miB = getRigidBodyB().getInvMass(); + bool hasStaticBody = (miA < SIMD_EPSILON) || (miB < SIMD_EPSILON); + btScalar miS = miA + miB; + btScalar factA, factB; + if (miS > btScalar(0.f)) + { + factA = miB / miS; + } + else + { + factA = btScalar(0.5f); + } + factB = btScalar(1.0f) - factA; + // get the desired direction of hinge axis + // as weighted sum of Z-orthos of frameA and frameB in WCS + btVector3 ax1A = trA.getBasis().getColumn(2); + btVector3 ax1B = trB.getBasis().getColumn(2); + btVector3 ax1 = ax1A * factA + ax1B * factB; + if (ax1.length2() SIMD_EPSILON) + { + p /= btSqrt(len2); + } + else + { + p = trA.getBasis().getColumn(1); + } + // make one more ortho + q = ax1.cross(p); + // fill three rows + tmpA = relA.cross(p); + tmpB = relB.cross(p); + for (i = 0; i < 3; i++) info->m_J1angularAxis[s0 + i] = tmpA[i]; + for (i = 0; i < 3; i++) info->m_J2angularAxis[s0 + i] = -tmpB[i]; + tmpA = relA.cross(q); + tmpB = relB.cross(q); + if (hasStaticBody && getSolveLimit()) + { // to make constraint between static and dynamic objects more rigid + // remove wA (or wB) from equation if angular limit is hit + tmpB *= factB; + tmpA *= factA; + } + for (i = 0; i < 3; i++) info->m_J1angularAxis[s1 + i] = tmpA[i]; + for (i = 0; i < 3; i++) info->m_J2angularAxis[s1 + i] = -tmpB[i]; + tmpA = relA.cross(ax1); + tmpB = relB.cross(ax1); + if (hasStaticBody) + { // to make constraint between static and dynamic objects more rigid + // remove wA (or wB) from equation + tmpB *= factB; + tmpA *= factA; + } + for (i = 0; i < 3; i++) info->m_J1angularAxis[s2 + i] = tmpA[i]; + for (i = 0; i < 3; i++) info->m_J2angularAxis[s2 + i] = -tmpB[i]; + + btScalar normalErp = (m_flags & BT_HINGE_FLAGS_ERP_NORM) ? m_normalERP : info->erp; + btScalar k = info->fps * normalErp; + + if (!m_angularOnly) + { + for (i = 0; i < 3; i++) info->m_J1linearAxis[s0 + i] = p[i]; + for (i = 0; i < 3; i++) info->m_J1linearAxis[s1 + i] = q[i]; + for (i = 0; i < 3; i++) info->m_J1linearAxis[s2 + i] = ax1[i]; + + for (i = 0; i < 3; i++) info->m_J2linearAxis[s0 + i] = -p[i]; + for (i = 0; i < 3; i++) info->m_J2linearAxis[s1 + i] = -q[i]; + for (i = 0; i < 3; i++) info->m_J2linearAxis[s2 + i] = -ax1[i]; + + // compute three elements of right hand side + + btScalar rhs = k * p.dot(ofs); + info->m_constraintError[s0] = rhs; + rhs = k * q.dot(ofs); + info->m_constraintError[s1] = rhs; + rhs = k * ax1.dot(ofs); + info->m_constraintError[s2] = rhs; + } + // the hinge axis should be the only unconstrained + // rotational axis, the angular velocity of the two bodies perpendicular to + // the hinge axis should be equal. thus the constraint equations are + // p*w1 - p*w2 = 0 + // q*w1 - q*w2 = 0 + // where p and q are unit vectors normal to the hinge axis, and w1 and w2 + // are the angular velocity vectors of the two bodies. + int s3 = 3 * s; + int s4 = 4 * s; + info->m_J1angularAxis[s3 + 0] = p[0]; + info->m_J1angularAxis[s3 + 1] = p[1]; + info->m_J1angularAxis[s3 + 2] = p[2]; + info->m_J1angularAxis[s4 + 0] = q[0]; + info->m_J1angularAxis[s4 + 1] = q[1]; + info->m_J1angularAxis[s4 + 2] = q[2]; + + info->m_J2angularAxis[s3 + 0] = -p[0]; + info->m_J2angularAxis[s3 + 1] = -p[1]; + info->m_J2angularAxis[s3 + 2] = -p[2]; + info->m_J2angularAxis[s4 + 0] = -q[0]; + info->m_J2angularAxis[s4 + 1] = -q[1]; + info->m_J2angularAxis[s4 + 2] = -q[2]; + // compute the right hand side of the constraint equation. set relative + // body velocities along p and q to bring the hinge back into alignment. + // if ax1A,ax1B are the unit length hinge axes as computed from bodyA and + // bodyB, we need to rotate both bodies along the axis u = (ax1 x ax2). + // if "theta" is the angle between ax1 and ax2, we need an angular velocity + // along u to cover angle erp*theta in one step : + // |angular_velocity| = angle/time = erp*theta / stepsize + // = (erp*fps) * theta + // angular_velocity = |angular_velocity| * (ax1 x ax2) / |ax1 x ax2| + // = (erp*fps) * theta * (ax1 x ax2) / sin(theta) + // ...as ax1 and ax2 are unit length. if theta is smallish, + // theta ~= sin(theta), so + // angular_velocity = (erp*fps) * (ax1 x ax2) + // ax1 x ax2 is in the plane space of ax1, so we project the angular + // velocity to p and q to find the right hand side. + k = info->fps * normalErp; //?? + + btVector3 u = ax1A.cross(ax1B); + info->m_constraintError[s3] = k * u.dot(p); + info->m_constraintError[s4] = k * u.dot(q); +#endif + // check angular limits + nrow = 4; // last filled row + int srow; + btScalar limit_err = btScalar(0.0); + int limit = 0; + if (getSolveLimit()) + { +#ifdef _BT_USE_CENTER_LIMIT_ + limit_err = m_limit.getCorrection() * m_referenceSign; +#else + limit_err = m_correction * m_referenceSign; +#endif + limit = (limit_err > btScalar(0.0)) ? 1 : 2; + } + // if the hinge has joint limits or motor, add in the extra row + bool powered = getEnableAngularMotor(); + if (limit || powered) + { + nrow++; + srow = nrow * info->rowskip; + info->m_J1angularAxis[srow + 0] = ax1[0]; + info->m_J1angularAxis[srow + 1] = ax1[1]; + info->m_J1angularAxis[srow + 2] = ax1[2]; + + info->m_J2angularAxis[srow + 0] = -ax1[0]; + info->m_J2angularAxis[srow + 1] = -ax1[1]; + info->m_J2angularAxis[srow + 2] = -ax1[2]; + + btScalar lostop = getLowerLimit(); + btScalar histop = getUpperLimit(); + if (limit && (lostop == histop)) + { // the joint motor is ineffective + powered = false; + } + info->m_constraintError[srow] = btScalar(0.0f); + btScalar currERP = (m_flags & BT_HINGE_FLAGS_ERP_STOP) ? m_stopERP : normalErp; + if (powered) + { + if (m_flags & BT_HINGE_FLAGS_CFM_NORM) + { + info->cfm[srow] = m_normalCFM; + } + btScalar mot_fact = getMotorFactor(m_hingeAngle, lostop, histop, m_motorTargetVelocity, info->fps * currERP); + info->m_constraintError[srow] += mot_fact * m_motorTargetVelocity * m_referenceSign; + info->m_lowerLimit[srow] = -m_maxMotorImpulse; + info->m_upperLimit[srow] = m_maxMotorImpulse; + } + if (limit) + { + k = info->fps * currERP; + info->m_constraintError[srow] += k * limit_err; + if (m_flags & BT_HINGE_FLAGS_CFM_STOP) + { + info->cfm[srow] = m_stopCFM; + } + if (lostop == histop) + { + // limited low and high simultaneously + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + else if (limit == 1) + { // low limit + info->m_lowerLimit[srow] = 0; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + else + { // high limit + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = 0; + } + // bounce (we'll use slider parameter abs(1.0 - m_dampingLimAng) for that) +#ifdef _BT_USE_CENTER_LIMIT_ + btScalar bounce = m_limit.getRelaxationFactor(); +#else + btScalar bounce = m_relaxationFactor; +#endif + if (bounce > btScalar(0.0)) + { + btScalar vel = angVelA.dot(ax1); + vel -= angVelB.dot(ax1); + // only apply bounce if the velocity is incoming, and if the + // resulting c[] exceeds what we already have. + if (limit == 1) + { // low limit + if (vel < 0) + { + btScalar newc = -bounce * vel; + if (newc > info->m_constraintError[srow]) + { + info->m_constraintError[srow] = newc; + } + } + } + else + { // high limit - all those computations are reversed + if (vel > 0) + { + btScalar newc = -bounce * vel; + if (newc < info->m_constraintError[srow]) + { + info->m_constraintError[srow] = newc; + } + } + } + } +#ifdef _BT_USE_CENTER_LIMIT_ + info->m_constraintError[srow] *= m_limit.getBiasFactor(); +#else + info->m_constraintError[srow] *= m_biasFactor; +#endif + } // if(limit) + } // if angular limit or powered +} + +///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). +///If no axis is provided, it uses the default axis for this constraint. +void btHingeConstraint::setParam(int num, btScalar value, int axis) +{ + if ((axis == -1) || (axis == 5)) + { + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + m_stopERP = value; + m_flags |= BT_HINGE_FLAGS_ERP_STOP; + break; + case BT_CONSTRAINT_STOP_CFM: + m_stopCFM = value; + m_flags |= BT_HINGE_FLAGS_CFM_STOP; + break; + case BT_CONSTRAINT_CFM: + m_normalCFM = value; + m_flags |= BT_HINGE_FLAGS_CFM_NORM; + break; + case BT_CONSTRAINT_ERP: + m_normalERP = value; + m_flags |= BT_HINGE_FLAGS_ERP_NORM; + break; + default: + btAssertConstrParams(0); + } + } + else + { + btAssertConstrParams(0); + } +} + +///return the local value of parameter +btScalar btHingeConstraint::getParam(int num, int axis) const +{ + btScalar retVal = 0; + if ((axis == -1) || (axis == 5)) + { + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + btAssertConstrParams(m_flags & BT_HINGE_FLAGS_ERP_STOP); + retVal = m_stopERP; + break; + case BT_CONSTRAINT_STOP_CFM: + btAssertConstrParams(m_flags & BT_HINGE_FLAGS_CFM_STOP); + retVal = m_stopCFM; + break; + case BT_CONSTRAINT_CFM: + btAssertConstrParams(m_flags & BT_HINGE_FLAGS_CFM_NORM); + retVal = m_normalCFM; + break; + case BT_CONSTRAINT_ERP: + btAssertConstrParams(m_flags & BT_HINGE_FLAGS_ERP_NORM); + retVal = m_normalERP; + break; + default: + btAssertConstrParams(0); + } + } + else + { + btAssertConstrParams(0); + } + return retVal; +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp.i new file mode 100644 index 00000000..d845145e --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btHingeConstraint.cpp ---------------- + +// %include "BulletDynamics/ConstraintSolver/btHingeConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btHingeConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.h new file mode 100644 index 00000000..8b1f1afd --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.h @@ -0,0 +1,480 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* Hinge Constraint by Dirk Gregorius. Limits added by Marcus Hennix at Starbreeze Studios */ + +#ifndef BT_HINGECONSTRAINT_H +#define BT_HINGECONSTRAINT_H + +#define _BT_USE_CENTER_LIMIT_ 1 + +#include "LinearMath/btVector3.h" +#include "btJacobianEntry.h" +#include "btTypedConstraint.h" + +class btRigidBody; + +#ifdef BT_USE_DOUBLE_PRECISION +#define btHingeConstraintData btHingeConstraintDoubleData2 //rename to 2 for backwards compatibility, so we can still load the 'btHingeConstraintDoubleData' version +#define btHingeConstraintDataName "btHingeConstraintDoubleData2" +#else +#define btHingeConstraintData btHingeConstraintFloatData +#define btHingeConstraintDataName "btHingeConstraintFloatData" +#endif //BT_USE_DOUBLE_PRECISION + +enum btHingeFlags +{ + BT_HINGE_FLAGS_CFM_STOP = 1, + BT_HINGE_FLAGS_ERP_STOP = 2, + BT_HINGE_FLAGS_CFM_NORM = 4, + BT_HINGE_FLAGS_ERP_NORM = 8 +}; + +/// hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space +/// axis defines the orientation of the hinge axis +ATTRIBUTE_ALIGNED16(class) +btHingeConstraint : public btTypedConstraint +{ +#ifdef IN_PARALLELL_SOLVER +public: +#endif + btJacobianEntry m_jac[3]; //3 orthogonal linear constraints + btJacobianEntry m_jacAng[3]; //2 orthogonal angular constraints+ 1 for limit/motor + + btTransform m_rbAFrame; // constraint axii. Assumes z is hinge axis. + btTransform m_rbBFrame; + + btScalar m_motorTargetVelocity; + btScalar m_maxMotorImpulse; + +#ifdef _BT_USE_CENTER_LIMIT_ + btAngularLimit m_limit; +#else + btScalar m_lowerLimit; + btScalar m_upperLimit; + btScalar m_limitSign; + btScalar m_correction; + + btScalar m_limitSoftness; + btScalar m_biasFactor; + btScalar m_relaxationFactor; + + bool m_solveLimit; +#endif + + btScalar m_kHinge; + + btScalar m_accLimitImpulse; + btScalar m_hingeAngle; + btScalar m_referenceSign; + + bool m_angularOnly; + bool m_enableAngularMotor; + bool m_useSolveConstraintObsolete; + bool m_useOffsetForConstraintFrame; + bool m_useReferenceFrameA; + + btScalar m_accMotorImpulse; + + int m_flags; + btScalar m_normalCFM; + btScalar m_normalERP; + btScalar m_stopCFM; + btScalar m_stopERP; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btHingeConstraint(btRigidBody & rbA, btRigidBody & rbB, const btVector3& pivotInA, const btVector3& pivotInB, const btVector3& axisInA, const btVector3& axisInB, bool useReferenceFrameA = false); + + btHingeConstraint(btRigidBody & rbA, const btVector3& pivotInA, const btVector3& axisInA, bool useReferenceFrameA = false); + + btHingeConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA = false); + + btHingeConstraint(btRigidBody & rbA, const btTransform& rbAFrame, bool useReferenceFrameA = false); + + virtual void buildJacobian(); + + virtual void getInfo1(btConstraintInfo1 * info); + + void getInfo1NonVirtual(btConstraintInfo1 * info); + + virtual void getInfo2(btConstraintInfo2 * info); + + void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& angVelA, const btVector3& angVelB); + + void getInfo2Internal(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& angVelA, const btVector3& angVelB); + void getInfo2InternalUsingFrameOffset(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& angVelA, const btVector3& angVelB); + + void updateRHS(btScalar timeStep); + + const btRigidBody& getRigidBodyA() const + { + return m_rbA; + } + const btRigidBody& getRigidBodyB() const + { + return m_rbB; + } + + btRigidBody& getRigidBodyA() + { + return m_rbA; + } + + btRigidBody& getRigidBodyB() + { + return m_rbB; + } + + btTransform& getFrameOffsetA() + { + return m_rbAFrame; + } + + btTransform& getFrameOffsetB() + { + return m_rbBFrame; + } + + void setFrames(const btTransform& frameA, const btTransform& frameB); + + void setAngularOnly(bool angularOnly) + { + m_angularOnly = angularOnly; + } + + void enableAngularMotor(bool enableMotor, btScalar targetVelocity, btScalar maxMotorImpulse) + { + m_enableAngularMotor = enableMotor; + m_motorTargetVelocity = targetVelocity; + m_maxMotorImpulse = maxMotorImpulse; + } + + // extra motor API, including ability to set a target rotation (as opposed to angular velocity) + // note: setMotorTarget sets angular velocity under the hood, so you must call it every tick to + // maintain a given angular target. + void enableMotor(bool enableMotor) { m_enableAngularMotor = enableMotor; } + void setMaxMotorImpulse(btScalar maxMotorImpulse) { m_maxMotorImpulse = maxMotorImpulse; } + void setMotorTargetVelocity(btScalar motorTargetVelocity) { m_motorTargetVelocity = motorTargetVelocity; } + void setMotorTarget(const btQuaternion& qAinB, btScalar dt); // qAinB is rotation of body A wrt body B. + void setMotorTarget(btScalar targetAngle, btScalar dt); + + void setLimit(btScalar low, btScalar high, btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f) + { +#ifdef _BT_USE_CENTER_LIMIT_ + m_limit.set(low, high, _softness, _biasFactor, _relaxationFactor); +#else + m_lowerLimit = btNormalizeAngle(low); + m_upperLimit = btNormalizeAngle(high); + m_limitSoftness = _softness; + m_biasFactor = _biasFactor; + m_relaxationFactor = _relaxationFactor; +#endif + } + + btScalar getLimitSoftness() const + { +#ifdef _BT_USE_CENTER_LIMIT_ + return m_limit.getSoftness(); +#else + return m_limitSoftness; +#endif + } + + btScalar getLimitBiasFactor() const + { +#ifdef _BT_USE_CENTER_LIMIT_ + return m_limit.getBiasFactor(); +#else + return m_biasFactor; +#endif + } + + btScalar getLimitRelaxationFactor() const + { +#ifdef _BT_USE_CENTER_LIMIT_ + return m_limit.getRelaxationFactor(); +#else + return m_relaxationFactor; +#endif + } + + void setAxis(btVector3 & axisInA) + { + btVector3 rbAxisA1, rbAxisA2; + btPlaneSpace1(axisInA, rbAxisA1, rbAxisA2); + btVector3 pivotInA = m_rbAFrame.getOrigin(); + // m_rbAFrame.getOrigin() = pivotInA; + m_rbAFrame.getBasis().setValue(rbAxisA1.getX(), rbAxisA2.getX(), axisInA.getX(), + rbAxisA1.getY(), rbAxisA2.getY(), axisInA.getY(), + rbAxisA1.getZ(), rbAxisA2.getZ(), axisInA.getZ()); + + btVector3 axisInB = m_rbA.getCenterOfMassTransform().getBasis() * axisInA; + + btQuaternion rotationArc = shortestArcQuat(axisInA, axisInB); + btVector3 rbAxisB1 = quatRotate(rotationArc, rbAxisA1); + btVector3 rbAxisB2 = axisInB.cross(rbAxisB1); + + m_rbBFrame.getOrigin() = m_rbB.getCenterOfMassTransform().inverse()(m_rbA.getCenterOfMassTransform()(pivotInA)); + + m_rbBFrame.getBasis().setValue(rbAxisB1.getX(), rbAxisB2.getX(), axisInB.getX(), + rbAxisB1.getY(), rbAxisB2.getY(), axisInB.getY(), + rbAxisB1.getZ(), rbAxisB2.getZ(), axisInB.getZ()); + m_rbBFrame.getBasis() = m_rbB.getCenterOfMassTransform().getBasis().inverse() * m_rbBFrame.getBasis(); + } + + bool hasLimit() const + { +#ifdef _BT_USE_CENTER_LIMIT_ + return m_limit.getHalfRange() > 0; +#else + return m_lowerLimit <= m_upperLimit; +#endif + } + + btScalar getLowerLimit() const + { +#ifdef _BT_USE_CENTER_LIMIT_ + return m_limit.getLow(); +#else + return m_lowerLimit; +#endif + } + + btScalar getUpperLimit() const + { +#ifdef _BT_USE_CENTER_LIMIT_ + return m_limit.getHigh(); +#else + return m_upperLimit; +#endif + } + + ///The getHingeAngle gives the hinge angle in range [-PI,PI] + btScalar getHingeAngle(); + + btScalar getHingeAngle(const btTransform& transA, const btTransform& transB); + + void testLimit(const btTransform& transA, const btTransform& transB); + + const btTransform& getAFrame() const { return m_rbAFrame; }; + const btTransform& getBFrame() const { return m_rbBFrame; }; + + btTransform& getAFrame() { return m_rbAFrame; }; + btTransform& getBFrame() { return m_rbBFrame; }; + + inline int getSolveLimit() + { +#ifdef _BT_USE_CENTER_LIMIT_ + return m_limit.isLimit(); +#else + return m_solveLimit; +#endif + } + + inline btScalar getLimitSign() + { +#ifdef _BT_USE_CENTER_LIMIT_ + return m_limit.getSign(); +#else + return m_limitSign; +#endif + } + + inline bool getAngularOnly() + { + return m_angularOnly; + } + inline bool getEnableAngularMotor() + { + return m_enableAngularMotor; + } + inline btScalar getMotorTargetVelocity() + { + return m_motorTargetVelocity; + } + inline btScalar getMaxMotorImpulse() + { + return m_maxMotorImpulse; + } + // access for UseFrameOffset + bool getUseFrameOffset() { return m_useOffsetForConstraintFrame; } + void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; } + // access for UseReferenceFrameA + bool getUseReferenceFrameA() const { return m_useReferenceFrameA; } + void setUseReferenceFrameA(bool useReferenceFrameA) { m_useReferenceFrameA = useReferenceFrameA; } + + ///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + ///If no axis is provided, it uses the default axis for this constraint. + virtual void setParam(int num, btScalar value, int axis = -1); + ///return the local value of parameter + virtual btScalar getParam(int num, int axis = -1) const; + + virtual int getFlags() const + { + return m_flags; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +//only for backward compatibility +#ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +///this structure is not used, except for loading pre-2.82 .bullet files +struct btHingeConstraintDoubleData +{ + btTypedConstraintData m_typeConstraintData; + btTransformDoubleData m_rbAFrame; // constraint axii. Assumes z is hinge axis. + btTransformDoubleData m_rbBFrame; + int m_useReferenceFrameA; + int m_angularOnly; + int m_enableAngularMotor; + float m_motorTargetVelocity; + float m_maxMotorImpulse; + + float m_lowerLimit; + float m_upperLimit; + float m_limitSoftness; + float m_biasFactor; + float m_relaxationFactor; +}; +#endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION + +///The getAccumulatedHingeAngle returns the accumulated hinge angle, taking rotation across the -PI/PI boundary into account +ATTRIBUTE_ALIGNED16(class) +btHingeAccumulatedAngleConstraint : public btHingeConstraint +{ +protected: + btScalar m_accumulatedAngle; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btHingeAccumulatedAngleConstraint(btRigidBody & rbA, btRigidBody & rbB, const btVector3& pivotInA, const btVector3& pivotInB, const btVector3& axisInA, const btVector3& axisInB, bool useReferenceFrameA = false) + : btHingeConstraint(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB, useReferenceFrameA) + { + m_accumulatedAngle = getHingeAngle(); + } + + btHingeAccumulatedAngleConstraint(btRigidBody & rbA, const btVector3& pivotInA, const btVector3& axisInA, bool useReferenceFrameA = false) + : btHingeConstraint(rbA, pivotInA, axisInA, useReferenceFrameA) + { + m_accumulatedAngle = getHingeAngle(); + } + + btHingeAccumulatedAngleConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA = false) + : btHingeConstraint(rbA, rbB, rbAFrame, rbBFrame, useReferenceFrameA) + { + m_accumulatedAngle = getHingeAngle(); + } + + btHingeAccumulatedAngleConstraint(btRigidBody & rbA, const btTransform& rbAFrame, bool useReferenceFrameA = false) + : btHingeConstraint(rbA, rbAFrame, useReferenceFrameA) + { + m_accumulatedAngle = getHingeAngle(); + } + btScalar getAccumulatedHingeAngle(); + void setAccumulatedHingeAngle(btScalar accAngle); + virtual void getInfo1(btConstraintInfo1 * info); +}; + +struct btHingeConstraintFloatData +{ + btTypedConstraintData m_typeConstraintData; + btTransformFloatData m_rbAFrame; // constraint axii. Assumes z is hinge axis. + btTransformFloatData m_rbBFrame; + int m_useReferenceFrameA; + int m_angularOnly; + + int m_enableAngularMotor; + float m_motorTargetVelocity; + float m_maxMotorImpulse; + + float m_lowerLimit; + float m_upperLimit; + float m_limitSoftness; + float m_biasFactor; + float m_relaxationFactor; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btHingeConstraintDoubleData2 +{ + btTypedConstraintDoubleData m_typeConstraintData; + btTransformDoubleData m_rbAFrame; // constraint axii. Assumes z is hinge axis. + btTransformDoubleData m_rbBFrame; + int m_useReferenceFrameA; + int m_angularOnly; + int m_enableAngularMotor; + double m_motorTargetVelocity; + double m_maxMotorImpulse; + + double m_lowerLimit; + double m_upperLimit; + double m_limitSoftness; + double m_biasFactor; + double m_relaxationFactor; + char m_padding1[4]; +}; + +SIMD_FORCE_INLINE int btHingeConstraint::calculateSerializeBufferSize() const +{ + return sizeof(btHingeConstraintData); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btHingeConstraint::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btHingeConstraintData* hingeData = (btHingeConstraintData*)dataBuffer; + btTypedConstraint::serialize(&hingeData->m_typeConstraintData, serializer); + + m_rbAFrame.serialize(hingeData->m_rbAFrame); + m_rbBFrame.serialize(hingeData->m_rbBFrame); + + hingeData->m_angularOnly = m_angularOnly; + hingeData->m_enableAngularMotor = m_enableAngularMotor; + hingeData->m_maxMotorImpulse = float(m_maxMotorImpulse); + hingeData->m_motorTargetVelocity = float(m_motorTargetVelocity); + hingeData->m_useReferenceFrameA = m_useReferenceFrameA; +#ifdef _BT_USE_CENTER_LIMIT_ + hingeData->m_lowerLimit = float(m_limit.getLow()); + hingeData->m_upperLimit = float(m_limit.getHigh()); + hingeData->m_limitSoftness = float(m_limit.getSoftness()); + hingeData->m_biasFactor = float(m_limit.getBiasFactor()); + hingeData->m_relaxationFactor = float(m_limit.getRelaxationFactor()); +#else + hingeData->m_lowerLimit = float(m_lowerLimit); + hingeData->m_upperLimit = float(m_upperLimit); + hingeData->m_limitSoftness = float(m_limitSoftness); + hingeData->m_biasFactor = float(m_biasFactor); + hingeData->m_relaxationFactor = float(m_relaxationFactor); +#endif + + // Fill padding with zeros to appease msan. +#ifdef BT_USE_DOUBLE_PRECISION + hingeData->m_padding1[0] = 0; + hingeData->m_padding1[1] = 0; + hingeData->m_padding1[2] = 0; + hingeData->m_padding1[3] = 0; +#endif + + return btHingeConstraintDataName; +} + +#endif //BT_HINGECONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.h.i new file mode 100644 index 00000000..2bd97ac6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btHingeConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btHingeConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btHingeConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btHingeConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btJacobianEntry.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btJacobianEntry.h new file mode 100644 index 00000000..a251073e --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btJacobianEntry.h @@ -0,0 +1,150 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_JACOBIAN_ENTRY_H +#define BT_JACOBIAN_ENTRY_H + +#include "LinearMath/btMatrix3x3.h" + +//notes: +// Another memory optimization would be to store m_1MinvJt in the remaining 3 w components +// which makes the btJacobianEntry memory layout 16 bytes +// if you only are interested in angular part, just feed massInvA and massInvB zero + +/// Jacobian entry is an abstraction that allows to describe constraints +/// it can be used in combination with a constraint solver +/// Can be used to relate the effect of an impulse to the constraint error +ATTRIBUTE_ALIGNED16(class) +btJacobianEntry +{ +public: + btJacobianEntry(){}; + //constraint between two different rigidbodies + btJacobianEntry( + const btMatrix3x3& world2A, + const btMatrix3x3& world2B, + const btVector3& rel_pos1, const btVector3& rel_pos2, + const btVector3& jointAxis, + const btVector3& inertiaInvA, + const btScalar massInvA, + const btVector3& inertiaInvB, + const btScalar massInvB) + : m_linearJointAxis(jointAxis) + { + m_aJ = world2A * (rel_pos1.cross(m_linearJointAxis)); + m_bJ = world2B * (rel_pos2.cross(-m_linearJointAxis)); + m_0MinvJt = inertiaInvA * m_aJ; + m_1MinvJt = inertiaInvB * m_bJ; + m_Adiag = massInvA + m_0MinvJt.dot(m_aJ) + massInvB + m_1MinvJt.dot(m_bJ); + + btAssert(m_Adiag > btScalar(0.0)); + } + + //angular constraint between two different rigidbodies + btJacobianEntry(const btVector3& jointAxis, + const btMatrix3x3& world2A, + const btMatrix3x3& world2B, + const btVector3& inertiaInvA, + const btVector3& inertiaInvB) + : m_linearJointAxis(btVector3(btScalar(0.), btScalar(0.), btScalar(0.))) + { + m_aJ = world2A * jointAxis; + m_bJ = world2B * -jointAxis; + m_0MinvJt = inertiaInvA * m_aJ; + m_1MinvJt = inertiaInvB * m_bJ; + m_Adiag = m_0MinvJt.dot(m_aJ) + m_1MinvJt.dot(m_bJ); + + btAssert(m_Adiag > btScalar(0.0)); + } + + //angular constraint between two different rigidbodies + btJacobianEntry(const btVector3& axisInA, + const btVector3& axisInB, + const btVector3& inertiaInvA, + const btVector3& inertiaInvB) + : m_linearJointAxis(btVector3(btScalar(0.), btScalar(0.), btScalar(0.))), m_aJ(axisInA), m_bJ(-axisInB) + { + m_0MinvJt = inertiaInvA * m_aJ; + m_1MinvJt = inertiaInvB * m_bJ; + m_Adiag = m_0MinvJt.dot(m_aJ) + m_1MinvJt.dot(m_bJ); + + btAssert(m_Adiag > btScalar(0.0)); + } + + //constraint on one rigidbody + btJacobianEntry( + const btMatrix3x3& world2A, + const btVector3& rel_pos1, const btVector3& rel_pos2, + const btVector3& jointAxis, + const btVector3& inertiaInvA, + const btScalar massInvA) + : m_linearJointAxis(jointAxis) + { + m_aJ = world2A * (rel_pos1.cross(jointAxis)); + m_bJ = world2A * (rel_pos2.cross(-jointAxis)); + m_0MinvJt = inertiaInvA * m_aJ; + m_1MinvJt = btVector3(btScalar(0.), btScalar(0.), btScalar(0.)); + m_Adiag = massInvA + m_0MinvJt.dot(m_aJ); + + btAssert(m_Adiag > btScalar(0.0)); + } + + btScalar getDiagonal() const { return m_Adiag; } + + // for two constraints on the same rigidbody (for example vehicle friction) + btScalar getNonDiagonal(const btJacobianEntry& jacB, const btScalar massInvA) const + { + const btJacobianEntry& jacA = *this; + btScalar lin = massInvA * jacA.m_linearJointAxis.dot(jacB.m_linearJointAxis); + btScalar ang = jacA.m_0MinvJt.dot(jacB.m_aJ); + return lin + ang; + } + + // for two constraints on sharing two same rigidbodies (for example two contact points between two rigidbodies) + btScalar getNonDiagonal(const btJacobianEntry& jacB, const btScalar massInvA, const btScalar massInvB) const + { + const btJacobianEntry& jacA = *this; + btVector3 lin = jacA.m_linearJointAxis * jacB.m_linearJointAxis; + btVector3 ang0 = jacA.m_0MinvJt * jacB.m_aJ; + btVector3 ang1 = jacA.m_1MinvJt * jacB.m_bJ; + btVector3 lin0 = massInvA * lin; + btVector3 lin1 = massInvB * lin; + btVector3 sum = ang0 + ang1 + lin0 + lin1; + return sum[0] + sum[1] + sum[2]; + } + + btScalar getRelativeVelocity(const btVector3& linvelA, const btVector3& angvelA, const btVector3& linvelB, const btVector3& angvelB) + { + btVector3 linrel = linvelA - linvelB; + btVector3 angvela = angvelA * m_aJ; + btVector3 angvelb = angvelB * m_bJ; + linrel *= m_linearJointAxis; + angvela += angvelb; + angvela += linrel; + btScalar rel_vel2 = angvela[0] + angvela[1] + angvela[2]; + return rel_vel2 + SIMD_EPSILON; + } + //private: + + btVector3 m_linearJointAxis; + btVector3 m_aJ; + btVector3 m_bJ; + btVector3 m_0MinvJt; + btVector3 m_1MinvJt; + //Optimization: can be stored in the w/last component of one of the vectors + btScalar m_Adiag; +}; + +#endif //BT_JACOBIAN_ENTRY_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btJacobianEntry.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btJacobianEntry.h.i new file mode 100644 index 00000000..f156d13f --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btJacobianEntry.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btJacobianEntry.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btJacobianEntry.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btJacobianEntry.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp new file mode 100644 index 00000000..454adc88 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp @@ -0,0 +1,368 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btNNCGConstraintSolver.h" + +btScalar btNNCGConstraintSolver::solveGroupCacheFriendlySetup(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) +{ + btScalar val = btSequentialImpulseConstraintSolver::solveGroupCacheFriendlySetup(bodies, numBodies, manifoldPtr, numManifolds, constraints, numConstraints, infoGlobal, debugDrawer); + + m_pNC.resizeNoInitialize(m_tmpSolverNonContactConstraintPool.size()); + m_pC.resizeNoInitialize(m_tmpSolverContactConstraintPool.size()); + m_pCF.resizeNoInitialize(m_tmpSolverContactFrictionConstraintPool.size()); + m_pCRF.resizeNoInitialize(m_tmpSolverContactRollingFrictionConstraintPool.size()); + + m_deltafNC.resizeNoInitialize(m_tmpSolverNonContactConstraintPool.size()); + m_deltafC.resizeNoInitialize(m_tmpSolverContactConstraintPool.size()); + m_deltafCF.resizeNoInitialize(m_tmpSolverContactFrictionConstraintPool.size()); + m_deltafCRF.resizeNoInitialize(m_tmpSolverContactRollingFrictionConstraintPool.size()); + + return val; +} + +btScalar btNNCGConstraintSolver::solveSingleIteration(int iteration, btCollisionObject** /*bodies */, int /*numBodies*/, btPersistentManifold** /*manifoldPtr*/, int /*numManifolds*/, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* /*debugDrawer*/) +{ + int numNonContactPool = m_tmpSolverNonContactConstraintPool.size(); + int numConstraintPool = m_tmpSolverContactConstraintPool.size(); + int numFrictionPool = m_tmpSolverContactFrictionConstraintPool.size(); + + if (infoGlobal.m_solverMode & SOLVER_RANDMIZE_ORDER) + { + if (1) // uncomment this for a bit less random ((iteration & 7) == 0) + { + for (int j = 0; j < numNonContactPool; ++j) + { + int tmp = m_orderNonContactConstraintPool[j]; + int swapi = btRandInt2(j + 1); + m_orderNonContactConstraintPool[j] = m_orderNonContactConstraintPool[swapi]; + m_orderNonContactConstraintPool[swapi] = tmp; + } + + //contact/friction constraints are not solved more than + if (iteration < infoGlobal.m_numIterations) + { + for (int j = 0; j < numConstraintPool; ++j) + { + int tmp = m_orderTmpConstraintPool[j]; + int swapi = btRandInt2(j + 1); + m_orderTmpConstraintPool[j] = m_orderTmpConstraintPool[swapi]; + m_orderTmpConstraintPool[swapi] = tmp; + } + + for (int j = 0; j < numFrictionPool; ++j) + { + int tmp = m_orderFrictionConstraintPool[j]; + int swapi = btRandInt2(j + 1); + m_orderFrictionConstraintPool[j] = m_orderFrictionConstraintPool[swapi]; + m_orderFrictionConstraintPool[swapi] = tmp; + } + } + } + } + + btScalar deltaflengthsqr = 0; + { + for (int j = 0; j < m_tmpSolverNonContactConstraintPool.size(); j++) + { + btSolverConstraint& constraint = m_tmpSolverNonContactConstraintPool[m_orderNonContactConstraintPool[j]]; + if (iteration < constraint.m_overrideNumSolverIterations) + { + btScalar deltaf = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[constraint.m_solverBodyIdA], m_tmpSolverBodyPool[constraint.m_solverBodyIdB], constraint); + m_deltafNC[j] = deltaf; + deltaflengthsqr += deltaf * deltaf; + } + } + } + + if (m_onlyForNoneContact) + { + if (iteration == 0) + { + for (int j = 0; j < m_tmpSolverNonContactConstraintPool.size(); j++) m_pNC[j] = m_deltafNC[j]; + } + else + { + // deltaflengthsqrprev can be 0 only if the solver solved the problem exactly in the previous iteration. In this case we should have quit, but mainly for debug reason with this 'hack' it is now allowed to continue the calculation + btScalar beta = m_deltafLengthSqrPrev > 0 ? deltaflengthsqr / m_deltafLengthSqrPrev : 2; + if (beta > 1) + { + for (int j = 0; j < m_tmpSolverNonContactConstraintPool.size(); j++) m_pNC[j] = 0; + } + else + { + for (int j = 0; j < m_tmpSolverNonContactConstraintPool.size(); j++) + { + btSolverConstraint& constraint = m_tmpSolverNonContactConstraintPool[m_orderNonContactConstraintPool[j]]; + if (iteration < constraint.m_overrideNumSolverIterations) + { + btScalar additionaldeltaimpulse = beta * m_pNC[j]; + constraint.m_appliedImpulse = btScalar(constraint.m_appliedImpulse) + additionaldeltaimpulse; + m_pNC[j] = beta * m_pNC[j] + m_deltafNC[j]; + btSolverBody& body1 = m_tmpSolverBodyPool[constraint.m_solverBodyIdA]; + btSolverBody& body2 = m_tmpSolverBodyPool[constraint.m_solverBodyIdB]; + const btSolverConstraint& c = constraint; + body1.internalApplyImpulse(c.m_contactNormal1 * body1.internalGetInvMass(), c.m_angularComponentA, additionaldeltaimpulse); + body2.internalApplyImpulse(c.m_contactNormal2 * body2.internalGetInvMass(), c.m_angularComponentB, additionaldeltaimpulse); + } + } + } + } + m_deltafLengthSqrPrev = deltaflengthsqr; + } + + { + if (iteration < infoGlobal.m_numIterations) + { + for (int j = 0; j < numConstraints; j++) + { + if (constraints[j]->isEnabled()) + { + int bodyAid = getOrInitSolverBody(constraints[j]->getRigidBodyA(), infoGlobal.m_timeStep); + int bodyBid = getOrInitSolverBody(constraints[j]->getRigidBodyB(), infoGlobal.m_timeStep); + btSolverBody& bodyA = m_tmpSolverBodyPool[bodyAid]; + btSolverBody& bodyB = m_tmpSolverBodyPool[bodyBid]; + constraints[j]->solveConstraintObsolete(bodyA, bodyB, infoGlobal.m_timeStep); + } + } + + ///solve all contact constraints + if (infoGlobal.m_solverMode & SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS) + { + int numPoolConstraints = m_tmpSolverContactConstraintPool.size(); + int multiplier = (infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS) ? 2 : 1; + + for (int c = 0; c < numPoolConstraints; c++) + { + btScalar totalImpulse = 0; + + { + const btSolverConstraint& solveManifold = m_tmpSolverContactConstraintPool[m_orderTmpConstraintPool[c]]; + btScalar deltaf = resolveSingleConstraintRowLowerLimit(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + m_deltafC[c] = deltaf; + deltaflengthsqr += deltaf * deltaf; + totalImpulse = solveManifold.m_appliedImpulse; + } + bool applyFriction = true; + if (applyFriction) + { + { + btSolverConstraint& solveManifold = m_tmpSolverContactFrictionConstraintPool[m_orderFrictionConstraintPool[c * multiplier]]; + + if (totalImpulse > btScalar(0)) + { + solveManifold.m_lowerLimit = -(solveManifold.m_friction * totalImpulse); + solveManifold.m_upperLimit = solveManifold.m_friction * totalImpulse; + btScalar deltaf = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + m_deltafCF[c * multiplier] = deltaf; + deltaflengthsqr += deltaf * deltaf; + } + else + { + m_deltafCF[c * multiplier] = 0; + } + } + + if (infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS) + { + btSolverConstraint& solveManifold = m_tmpSolverContactFrictionConstraintPool[m_orderFrictionConstraintPool[c * multiplier + 1]]; + + if (totalImpulse > btScalar(0)) + { + solveManifold.m_lowerLimit = -(solveManifold.m_friction * totalImpulse); + solveManifold.m_upperLimit = solveManifold.m_friction * totalImpulse; + btScalar deltaf = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + m_deltafCF[c * multiplier + 1] = deltaf; + deltaflengthsqr += deltaf * deltaf; + } + else + { + m_deltafCF[c * multiplier + 1] = 0; + } + } + } + } + } + else //SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS + { + //solve the friction constraints after all contact constraints, don't interleave them + int numPoolConstraints = m_tmpSolverContactConstraintPool.size(); + int j; + + for (j = 0; j < numPoolConstraints; j++) + { + const btSolverConstraint& solveManifold = m_tmpSolverContactConstraintPool[m_orderTmpConstraintPool[j]]; + btScalar deltaf = resolveSingleConstraintRowLowerLimit(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + m_deltafC[j] = deltaf; + deltaflengthsqr += deltaf * deltaf; + } + + ///solve all friction constraints + + int numFrictionPoolConstraints = m_tmpSolverContactFrictionConstraintPool.size(); + for (j = 0; j < numFrictionPoolConstraints; j++) + { + btSolverConstraint& solveManifold = m_tmpSolverContactFrictionConstraintPool[m_orderFrictionConstraintPool[j]]; + btScalar totalImpulse = m_tmpSolverContactConstraintPool[solveManifold.m_frictionIndex].m_appliedImpulse; + + if (totalImpulse > btScalar(0)) + { + solveManifold.m_lowerLimit = -(solveManifold.m_friction * totalImpulse); + solveManifold.m_upperLimit = solveManifold.m_friction * totalImpulse; + + btScalar deltaf = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + m_deltafCF[j] = deltaf; + deltaflengthsqr += deltaf * deltaf; + } + else + { + m_deltafCF[j] = 0; + } + } + } + + { + int numRollingFrictionPoolConstraints = m_tmpSolverContactRollingFrictionConstraintPool.size(); + for (int j = 0; j < numRollingFrictionPoolConstraints; j++) + { + btSolverConstraint& rollingFrictionConstraint = m_tmpSolverContactRollingFrictionConstraintPool[j]; + btScalar totalImpulse = m_tmpSolverContactConstraintPool[rollingFrictionConstraint.m_frictionIndex].m_appliedImpulse; + if (totalImpulse > btScalar(0)) + { + btScalar rollingFrictionMagnitude = rollingFrictionConstraint.m_friction * totalImpulse; + if (rollingFrictionMagnitude > rollingFrictionConstraint.m_friction) + rollingFrictionMagnitude = rollingFrictionConstraint.m_friction; + + rollingFrictionConstraint.m_lowerLimit = -rollingFrictionMagnitude; + rollingFrictionConstraint.m_upperLimit = rollingFrictionMagnitude; + + btScalar deltaf = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[rollingFrictionConstraint.m_solverBodyIdA], m_tmpSolverBodyPool[rollingFrictionConstraint.m_solverBodyIdB], rollingFrictionConstraint); + m_deltafCRF[j] = deltaf; + deltaflengthsqr += deltaf * deltaf; + } + else + { + m_deltafCRF[j] = 0; + } + } + } + } + } + + if (!m_onlyForNoneContact) + { + if (iteration == 0) + { + for (int j = 0; j < m_tmpSolverNonContactConstraintPool.size(); j++) m_pNC[j] = m_deltafNC[j]; + for (int j = 0; j < m_tmpSolverContactConstraintPool.size(); j++) m_pC[j] = m_deltafC[j]; + for (int j = 0; j < m_tmpSolverContactFrictionConstraintPool.size(); j++) m_pCF[j] = m_deltafCF[j]; + for (int j = 0; j < m_tmpSolverContactRollingFrictionConstraintPool.size(); j++) m_pCRF[j] = m_deltafCRF[j]; + } + else + { + // deltaflengthsqrprev can be 0 only if the solver solved the problem exactly in the previous iteration. In this case we should have quit, but mainly for debug reason with this 'hack' it is now allowed to continue the calculation + btScalar beta = m_deltafLengthSqrPrev > 0 ? deltaflengthsqr / m_deltafLengthSqrPrev : 2; + if (beta > 1) + { + for (int j = 0; j < m_tmpSolverNonContactConstraintPool.size(); j++) m_pNC[j] = 0; + for (int j = 0; j < m_tmpSolverContactConstraintPool.size(); j++) m_pC[j] = 0; + for (int j = 0; j < m_tmpSolverContactFrictionConstraintPool.size(); j++) m_pCF[j] = 0; + for (int j = 0; j < m_tmpSolverContactRollingFrictionConstraintPool.size(); j++) m_pCRF[j] = 0; + } + else + { + for (int j = 0; j < m_tmpSolverNonContactConstraintPool.size(); j++) + { + btSolverConstraint& constraint = m_tmpSolverNonContactConstraintPool[m_orderNonContactConstraintPool[j]]; + if (iteration < constraint.m_overrideNumSolverIterations) + { + btScalar additionaldeltaimpulse = beta * m_pNC[j]; + constraint.m_appliedImpulse = btScalar(constraint.m_appliedImpulse) + additionaldeltaimpulse; + m_pNC[j] = beta * m_pNC[j] + m_deltafNC[j]; + btSolverBody& body1 = m_tmpSolverBodyPool[constraint.m_solverBodyIdA]; + btSolverBody& body2 = m_tmpSolverBodyPool[constraint.m_solverBodyIdB]; + const btSolverConstraint& c = constraint; + body1.internalApplyImpulse(c.m_contactNormal1 * body1.internalGetInvMass(), c.m_angularComponentA, additionaldeltaimpulse); + body2.internalApplyImpulse(c.m_contactNormal2 * body2.internalGetInvMass(), c.m_angularComponentB, additionaldeltaimpulse); + } + } + for (int j = 0; j < m_tmpSolverContactConstraintPool.size(); j++) + { + btSolverConstraint& constraint = m_tmpSolverContactConstraintPool[m_orderTmpConstraintPool[j]]; + if (iteration < infoGlobal.m_numIterations) + { + btScalar additionaldeltaimpulse = beta * m_pC[j]; + constraint.m_appliedImpulse = btScalar(constraint.m_appliedImpulse) + additionaldeltaimpulse; + m_pC[j] = beta * m_pC[j] + m_deltafC[j]; + btSolverBody& body1 = m_tmpSolverBodyPool[constraint.m_solverBodyIdA]; + btSolverBody& body2 = m_tmpSolverBodyPool[constraint.m_solverBodyIdB]; + const btSolverConstraint& c = constraint; + body1.internalApplyImpulse(c.m_contactNormal1 * body1.internalGetInvMass(), c.m_angularComponentA, additionaldeltaimpulse); + body2.internalApplyImpulse(c.m_contactNormal2 * body2.internalGetInvMass(), c.m_angularComponentB, additionaldeltaimpulse); + } + } + for (int j = 0; j < m_tmpSolverContactFrictionConstraintPool.size(); j++) + { + btSolverConstraint& constraint = m_tmpSolverContactFrictionConstraintPool[m_orderFrictionConstraintPool[j]]; + if (iteration < infoGlobal.m_numIterations) + { + btScalar additionaldeltaimpulse = beta * m_pCF[j]; + constraint.m_appliedImpulse = btScalar(constraint.m_appliedImpulse) + additionaldeltaimpulse; + m_pCF[j] = beta * m_pCF[j] + m_deltafCF[j]; + btSolverBody& body1 = m_tmpSolverBodyPool[constraint.m_solverBodyIdA]; + btSolverBody& body2 = m_tmpSolverBodyPool[constraint.m_solverBodyIdB]; + const btSolverConstraint& c = constraint; + body1.internalApplyImpulse(c.m_contactNormal1 * body1.internalGetInvMass(), c.m_angularComponentA, additionaldeltaimpulse); + body2.internalApplyImpulse(c.m_contactNormal2 * body2.internalGetInvMass(), c.m_angularComponentB, additionaldeltaimpulse); + } + } + { + for (int j = 0; j < m_tmpSolverContactRollingFrictionConstraintPool.size(); j++) + { + btSolverConstraint& constraint = m_tmpSolverContactRollingFrictionConstraintPool[j]; + if (iteration < infoGlobal.m_numIterations) + { + btScalar additionaldeltaimpulse = beta * m_pCRF[j]; + constraint.m_appliedImpulse = btScalar(constraint.m_appliedImpulse) + additionaldeltaimpulse; + m_pCRF[j] = beta * m_pCRF[j] + m_deltafCRF[j]; + btSolverBody& body1 = m_tmpSolverBodyPool[constraint.m_solverBodyIdA]; + btSolverBody& body2 = m_tmpSolverBodyPool[constraint.m_solverBodyIdB]; + const btSolverConstraint& c = constraint; + body1.internalApplyImpulse(c.m_contactNormal1 * body1.internalGetInvMass(), c.m_angularComponentA, additionaldeltaimpulse); + body2.internalApplyImpulse(c.m_contactNormal2 * body2.internalGetInvMass(), c.m_angularComponentB, additionaldeltaimpulse); + } + } + } + } + } + m_deltafLengthSqrPrev = deltaflengthsqr; + } + + return deltaflengthsqr; +} + +btScalar btNNCGConstraintSolver::solveGroupCacheFriendlyFinish(btCollisionObject** bodies, int numBodies, const btContactSolverInfo& infoGlobal) +{ + m_pNC.resizeNoInitialize(0); + m_pC.resizeNoInitialize(0); + m_pCF.resizeNoInitialize(0); + m_pCRF.resizeNoInitialize(0); + + m_deltafNC.resizeNoInitialize(0); + m_deltafC.resizeNoInitialize(0); + m_deltafCF.resizeNoInitialize(0); + m_deltafCRF.resizeNoInitialize(0); + + return btSequentialImpulseConstraintSolver::solveGroupCacheFriendlyFinish(bodies, numBodies, infoGlobal); +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp.i new file mode 100644 index 00000000..16b44df4 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h new file mode 100644 index 00000000..a01f34c9 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h @@ -0,0 +1,57 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_NNCG_CONSTRAINT_SOLVER_H +#define BT_NNCG_CONSTRAINT_SOLVER_H + +#include "btSequentialImpulseConstraintSolver.h" + +ATTRIBUTE_ALIGNED16(class) +btNNCGConstraintSolver : public btSequentialImpulseConstraintSolver +{ +protected: + btScalar m_deltafLengthSqrPrev; + + btAlignedObjectArray m_pNC; // p for None Contact constraints + btAlignedObjectArray m_pC; // p for Contact constraints + btAlignedObjectArray m_pCF; // p for ContactFriction constraints + btAlignedObjectArray m_pCRF; // p for ContactRollingFriction constraints + + //These are recalculated in every iterations. We just keep these to prevent reallocation in each iteration. + btAlignedObjectArray m_deltafNC; // deltaf for NoneContact constraints + btAlignedObjectArray m_deltafC; // deltaf for Contact constraints + btAlignedObjectArray m_deltafCF; // deltaf for ContactFriction constraints + btAlignedObjectArray m_deltafCRF; // deltaf for ContactRollingFriction constraints + +protected: + virtual btScalar solveGroupCacheFriendlyFinish(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal); + virtual btScalar solveSingleIteration(int iteration, btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer); + + virtual btScalar solveGroupCacheFriendlySetup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btNNCGConstraintSolver() : btSequentialImpulseConstraintSolver(), m_onlyForNoneContact(false) {} + + virtual btConstraintSolverType getSolverType() const + { + return BT_NNCG_SOLVER; + } + + bool m_onlyForNoneContact; +}; + +#endif //BT_NNCG_CONSTRAINT_SOLVER_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h.i new file mode 100644 index 00000000..8343952c --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp new file mode 100644 index 00000000..49a46edc --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp @@ -0,0 +1,205 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btPoint2PointConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include + +btPoint2PointConstraint::btPoint2PointConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& pivotInA, const btVector3& pivotInB) + : btTypedConstraint(POINT2POINT_CONSTRAINT_TYPE, rbA, rbB), m_pivotInA(pivotInA), m_pivotInB(pivotInB), m_flags(0), m_useSolveConstraintObsolete(false) +{ +} + +btPoint2PointConstraint::btPoint2PointConstraint(btRigidBody& rbA, const btVector3& pivotInA) + : btTypedConstraint(POINT2POINT_CONSTRAINT_TYPE, rbA), m_pivotInA(pivotInA), m_pivotInB(rbA.getCenterOfMassTransform()(pivotInA)), m_flags(0), m_useSolveConstraintObsolete(false) +{ +} + +void btPoint2PointConstraint::buildJacobian() +{ + ///we need it for both methods + { + m_appliedImpulse = btScalar(0.); + + btVector3 normal(0, 0, 0); + + for (int i = 0; i < 3; i++) + { + normal[i] = 1; + new (&m_jac[i]) btJacobianEntry( + m_rbA.getCenterOfMassTransform().getBasis().transpose(), + m_rbB.getCenterOfMassTransform().getBasis().transpose(), + m_rbA.getCenterOfMassTransform() * m_pivotInA - m_rbA.getCenterOfMassPosition(), + m_rbB.getCenterOfMassTransform() * m_pivotInB - m_rbB.getCenterOfMassPosition(), + normal, + m_rbA.getInvInertiaDiagLocal(), + m_rbA.getInvMass(), + m_rbB.getInvInertiaDiagLocal(), + m_rbB.getInvMass()); + normal[i] = 0; + } + } +} + +void btPoint2PointConstraint::getInfo1(btConstraintInfo1* info) +{ + getInfo1NonVirtual(info); +} + +void btPoint2PointConstraint::getInfo1NonVirtual(btConstraintInfo1* info) +{ + if (m_useSolveConstraintObsolete) + { + info->m_numConstraintRows = 0; + info->nub = 0; + } + else + { + info->m_numConstraintRows = 3; + info->nub = 3; + } +} + +void btPoint2PointConstraint::getInfo2(btConstraintInfo2* info) +{ + getInfo2NonVirtual(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); +} + +void btPoint2PointConstraint::getInfo2NonVirtual(btConstraintInfo2* info, const btTransform& body0_trans, const btTransform& body1_trans) +{ + btAssert(!m_useSolveConstraintObsolete); + + //retrieve matrices + + // anchor points in global coordinates with respect to body PORs. + + // set jacobian + info->m_J1linearAxis[0] = 1; + info->m_J1linearAxis[info->rowskip + 1] = 1; + info->m_J1linearAxis[2 * info->rowskip + 2] = 1; + + btVector3 a1 = body0_trans.getBasis() * getPivotInA(); + { + btVector3* angular0 = (btVector3*)(info->m_J1angularAxis); + btVector3* angular1 = (btVector3*)(info->m_J1angularAxis + info->rowskip); + btVector3* angular2 = (btVector3*)(info->m_J1angularAxis + 2 * info->rowskip); + btVector3 a1neg = -a1; + a1neg.getSkewSymmetricMatrix(angular0, angular1, angular2); + } + + info->m_J2linearAxis[0] = -1; + info->m_J2linearAxis[info->rowskip + 1] = -1; + info->m_J2linearAxis[2 * info->rowskip + 2] = -1; + + btVector3 a2 = body1_trans.getBasis() * getPivotInB(); + + { + // btVector3 a2n = -a2; + btVector3* angular0 = (btVector3*)(info->m_J2angularAxis); + btVector3* angular1 = (btVector3*)(info->m_J2angularAxis + info->rowskip); + btVector3* angular2 = (btVector3*)(info->m_J2angularAxis + 2 * info->rowskip); + a2.getSkewSymmetricMatrix(angular0, angular1, angular2); + } + + // set right hand side + btScalar currERP = (m_flags & BT_P2P_FLAGS_ERP) ? m_erp : info->erp; + btScalar k = info->fps * currERP; + int j; + for (j = 0; j < 3; j++) + { + info->m_constraintError[j * info->rowskip] = k * (a2[j] + body1_trans.getOrigin()[j] - a1[j] - body0_trans.getOrigin()[j]); + //printf("info->m_constraintError[%d]=%f\n",j,info->m_constraintError[j]); + } + if (m_flags & BT_P2P_FLAGS_CFM) + { + for (j = 0; j < 3; j++) + { + info->cfm[j * info->rowskip] = m_cfm; + } + } + + btScalar impulseClamp = m_setting.m_impulseClamp; // + for (j = 0; j < 3; j++) + { + if (m_setting.m_impulseClamp > 0) + { + info->m_lowerLimit[j * info->rowskip] = -impulseClamp; + info->m_upperLimit[j * info->rowskip] = impulseClamp; + } + } + info->m_damping = m_setting.m_damping; +} + +void btPoint2PointConstraint::updateRHS(btScalar timeStep) +{ + (void)timeStep; +} + +///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). +///If no axis is provided, it uses the default axis for this constraint. +void btPoint2PointConstraint::setParam(int num, btScalar value, int axis) +{ + if (axis != -1) + { + btAssertConstrParams(0); + } + else + { + switch (num) + { + case BT_CONSTRAINT_ERP: + case BT_CONSTRAINT_STOP_ERP: + m_erp = value; + m_flags |= BT_P2P_FLAGS_ERP; + break; + case BT_CONSTRAINT_CFM: + case BT_CONSTRAINT_STOP_CFM: + m_cfm = value; + m_flags |= BT_P2P_FLAGS_CFM; + break; + default: + btAssertConstrParams(0); + } + } +} + +///return the local value of parameter +btScalar btPoint2PointConstraint::getParam(int num, int axis) const +{ + btScalar retVal(SIMD_INFINITY); + if (axis != -1) + { + btAssertConstrParams(0); + } + else + { + switch (num) + { + case BT_CONSTRAINT_ERP: + case BT_CONSTRAINT_STOP_ERP: + btAssertConstrParams(m_flags & BT_P2P_FLAGS_ERP); + retVal = m_erp; + break; + case BT_CONSTRAINT_CFM: + case BT_CONSTRAINT_STOP_CFM: + btAssertConstrParams(m_flags & BT_P2P_FLAGS_CFM); + retVal = m_cfm; + break; + default: + btAssertConstrParams(0); + } + } + return retVal; +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp.i new file mode 100644 index 00000000..797d106a --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h new file mode 100644 index 00000000..c0b94e9c --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h @@ -0,0 +1,173 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_POINT2POINTCONSTRAINT_H +#define BT_POINT2POINTCONSTRAINT_H + +#include "LinearMath/btVector3.h" +#include "btJacobianEntry.h" +#include "btTypedConstraint.h" + +class btRigidBody; + +#ifdef BT_USE_DOUBLE_PRECISION +#define btPoint2PointConstraintData2 btPoint2PointConstraintDoubleData2 +#define btPoint2PointConstraintDataName "btPoint2PointConstraintDoubleData2" +#else +#define btPoint2PointConstraintData2 btPoint2PointConstraintFloatData +#define btPoint2PointConstraintDataName "btPoint2PointConstraintFloatData" +#endif //BT_USE_DOUBLE_PRECISION + +struct btConstraintSetting +{ + btConstraintSetting() : m_tau(btScalar(0.3)), + m_damping(btScalar(1.)), + m_impulseClamp(btScalar(0.)) + { + } + btScalar m_tau; + btScalar m_damping; + btScalar m_impulseClamp; +}; + +enum btPoint2PointFlags +{ + BT_P2P_FLAGS_ERP = 1, + BT_P2P_FLAGS_CFM = 2 +}; + +/// point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space +ATTRIBUTE_ALIGNED16(class) +btPoint2PointConstraint : public btTypedConstraint +{ +#ifdef IN_PARALLELL_SOLVER +public: +#endif + btJacobianEntry m_jac[3]; //3 orthogonal linear constraints + + btVector3 m_pivotInA; + btVector3 m_pivotInB; + + int m_flags; + btScalar m_erp; + btScalar m_cfm; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + ///for backwards compatibility during the transition to 'getInfo/getInfo2' + bool m_useSolveConstraintObsolete; + + btConstraintSetting m_setting; + + btPoint2PointConstraint(btRigidBody & rbA, btRigidBody & rbB, const btVector3& pivotInA, const btVector3& pivotInB); + + btPoint2PointConstraint(btRigidBody & rbA, const btVector3& pivotInA); + + virtual void buildJacobian(); + + virtual void getInfo1(btConstraintInfo1 * info); + + void getInfo1NonVirtual(btConstraintInfo1 * info); + + virtual void getInfo2(btConstraintInfo2 * info); + + void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& body0_trans, const btTransform& body1_trans); + + void updateRHS(btScalar timeStep); + + void setPivotA(const btVector3& pivotA) + { + m_pivotInA = pivotA; + } + + void setPivotB(const btVector3& pivotB) + { + m_pivotInB = pivotB; + } + + const btVector3& getPivotInA() const + { + return m_pivotInA; + } + + const btVector3& getPivotInB() const + { + return m_pivotInB; + } + + ///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + ///If no axis is provided, it uses the default axis for this constraint. + virtual void setParam(int num, btScalar value, int axis = -1); + ///return the local value of parameter + virtual btScalar getParam(int num, int axis = -1) const; + + virtual int getFlags() const + { + return m_flags; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btPoint2PointConstraintFloatData +{ + btTypedConstraintData m_typeConstraintData; + btVector3FloatData m_pivotInA; + btVector3FloatData m_pivotInB; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btPoint2PointConstraintDoubleData2 +{ + btTypedConstraintDoubleData m_typeConstraintData; + btVector3DoubleData m_pivotInA; + btVector3DoubleData m_pivotInB; +}; + +#ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +///this structure is not used, except for loading pre-2.82 .bullet files +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btPoint2PointConstraintDoubleData +{ + btTypedConstraintData m_typeConstraintData; + btVector3DoubleData m_pivotInA; + btVector3DoubleData m_pivotInB; +}; +#endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION + +SIMD_FORCE_INLINE int btPoint2PointConstraint::calculateSerializeBufferSize() const +{ + return sizeof(btPoint2PointConstraintData2); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btPoint2PointConstraint::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btPoint2PointConstraintData2* p2pData = (btPoint2PointConstraintData2*)dataBuffer; + + btTypedConstraint::serialize(&p2pData->m_typeConstraintData, serializer); + m_pivotInA.serialize(p2pData->m_pivotInA); + m_pivotInB.serialize(p2pData->m_pivotInB); + + return btPoint2PointConstraintDataName; +} + +#endif //BT_POINT2POINTCONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h.i new file mode 100644 index 00000000..9270dbf6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp new file mode 100644 index 00000000..0e6ad6b6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp @@ -0,0 +1,1875 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +//#define COMPUTE_IMPULSE_DENOM 1 +#ifdef BT_DEBUG +# define BT_ADDITIONAL_DEBUG +#endif + +//It is not necessary (redundant) to refresh contact manifolds, this refresh has been moved to the collision algorithms. + +#include "btSequentialImpulseConstraintSolver.h" +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" + +#include "LinearMath/btIDebugDraw.h" +#include "LinearMath/btCpuFeatureUtility.h" + +//#include "btJacobianEntry.h" +#include "LinearMath/btMinMax.h" +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +#include +#include "LinearMath/btStackAlloc.h" +#include "LinearMath/btQuickprof.h" +//#include "btSolverBody.h" +//#include "btSolverConstraint.h" +#include "LinearMath/btAlignedObjectArray.h" +#include //for memset + +int gNumSplitImpulseRecoveries = 0; + +#include "BulletDynamics/Dynamics/btRigidBody.h" + +//#define VERBOSE_RESIDUAL_PRINTF 1 +///This is the scalar reference implementation of solving a single constraint row, the innerloop of the Projected Gauss Seidel/Sequential Impulse constraint solver +///Below are optional SSE2 and SSE4/FMA3 versions. We assume most hardware has SSE2. For SSE4/FMA3 we perform a CPU feature check. +static btScalar gResolveSingleConstraintRowGeneric_scalar_reference(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ + btScalar deltaImpulse = c.m_rhs - btScalar(c.m_appliedImpulse) * c.m_cfm; + const btScalar deltaVel1Dotn = c.m_contactNormal1.dot(bodyA.internalGetDeltaLinearVelocity()) + c.m_relpos1CrossNormal.dot(bodyA.internalGetDeltaAngularVelocity()); + const btScalar deltaVel2Dotn = c.m_contactNormal2.dot(bodyB.internalGetDeltaLinearVelocity()) + c.m_relpos2CrossNormal.dot(bodyB.internalGetDeltaAngularVelocity()); + + // const btScalar delta_rel_vel = deltaVel1Dotn-deltaVel2Dotn; + deltaImpulse -= deltaVel1Dotn * c.m_jacDiagABInv; + deltaImpulse -= deltaVel2Dotn * c.m_jacDiagABInv; + + const btScalar sum = btScalar(c.m_appliedImpulse) + deltaImpulse; + if (sum < c.m_lowerLimit) + { + deltaImpulse = c.m_lowerLimit - c.m_appliedImpulse; + c.m_appliedImpulse = c.m_lowerLimit; + } + else if (sum > c.m_upperLimit) + { + deltaImpulse = c.m_upperLimit - c.m_appliedImpulse; + c.m_appliedImpulse = c.m_upperLimit; + } + else + { + c.m_appliedImpulse = sum; + } + + bodyA.internalApplyImpulse(c.m_contactNormal1 * bodyA.internalGetInvMass(), c.m_angularComponentA, deltaImpulse); + bodyB.internalApplyImpulse(c.m_contactNormal2 * bodyB.internalGetInvMass(), c.m_angularComponentB, deltaImpulse); + + return deltaImpulse * (1. / c.m_jacDiagABInv); +} + +static btScalar gResolveSingleConstraintRowLowerLimit_scalar_reference(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ + btScalar deltaImpulse = c.m_rhs - btScalar(c.m_appliedImpulse) * c.m_cfm; + const btScalar deltaVel1Dotn = c.m_contactNormal1.dot(bodyA.internalGetDeltaLinearVelocity()) + c.m_relpos1CrossNormal.dot(bodyA.internalGetDeltaAngularVelocity()); + const btScalar deltaVel2Dotn = c.m_contactNormal2.dot(bodyB.internalGetDeltaLinearVelocity()) + c.m_relpos2CrossNormal.dot(bodyB.internalGetDeltaAngularVelocity()); + + deltaImpulse -= deltaVel1Dotn * c.m_jacDiagABInv; + deltaImpulse -= deltaVel2Dotn * c.m_jacDiagABInv; + const btScalar sum = btScalar(c.m_appliedImpulse) + deltaImpulse; + if (sum < c.m_lowerLimit) + { + deltaImpulse = c.m_lowerLimit - c.m_appliedImpulse; + c.m_appliedImpulse = c.m_lowerLimit; + } + else + { + c.m_appliedImpulse = sum; + } + bodyA.internalApplyImpulse(c.m_contactNormal1 * bodyA.internalGetInvMass(), c.m_angularComponentA, deltaImpulse); + bodyB.internalApplyImpulse(c.m_contactNormal2 * bodyB.internalGetInvMass(), c.m_angularComponentB, deltaImpulse); + + return deltaImpulse * (1. / c.m_jacDiagABInv); +} + +#ifdef USE_SIMD +#include + +#define btVecSplat(x, e) _mm_shuffle_ps(x, x, _MM_SHUFFLE(e, e, e, e)) +static inline __m128 btSimdDot3(__m128 vec0, __m128 vec1) +{ + __m128 result = _mm_mul_ps(vec0, vec1); + return _mm_add_ps(btVecSplat(result, 0), _mm_add_ps(btVecSplat(result, 1), btVecSplat(result, 2))); +} + +#if defined(BT_ALLOW_SSE4) +#include + +#define USE_FMA 1 +#define USE_FMA3_INSTEAD_FMA4 1 +#define USE_SSE4_DOT 1 + +#define SSE4_DP(a, b) _mm_dp_ps(a, b, 0x7f) +#define SSE4_DP_FP(a, b) _mm_cvtss_f32(_mm_dp_ps(a, b, 0x7f)) + +#if USE_SSE4_DOT +#define DOT_PRODUCT(a, b) SSE4_DP(a, b) +#else +#define DOT_PRODUCT(a, b) btSimdDot3(a, b) +#endif + +#if USE_FMA +#if USE_FMA3_INSTEAD_FMA4 +// a*b + c +#define FMADD(a, b, c) _mm_fmadd_ps(a, b, c) +// -(a*b) + c +#define FMNADD(a, b, c) _mm_fnmadd_ps(a, b, c) +#else // USE_FMA3 +// a*b + c +#define FMADD(a, b, c) _mm_macc_ps(a, b, c) +// -(a*b) + c +#define FMNADD(a, b, c) _mm_nmacc_ps(a, b, c) +#endif +#else // USE_FMA +// c + a*b +#define FMADD(a, b, c) _mm_add_ps(c, _mm_mul_ps(a, b)) +// c - a*b +#define FMNADD(a, b, c) _mm_sub_ps(c, _mm_mul_ps(a, b)) +#endif +#endif + +// Project Gauss Seidel or the equivalent Sequential Impulse +static btScalar gResolveSingleConstraintRowGeneric_sse2(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ + __m128 cpAppliedImp = _mm_set1_ps(c.m_appliedImpulse); + __m128 lowerLimit1 = _mm_set1_ps(c.m_lowerLimit); + __m128 upperLimit1 = _mm_set1_ps(c.m_upperLimit); + btSimdScalar deltaImpulse = _mm_sub_ps(_mm_set1_ps(c.m_rhs), _mm_mul_ps(_mm_set1_ps(c.m_appliedImpulse), _mm_set1_ps(c.m_cfm))); + __m128 deltaVel1Dotn = _mm_add_ps(btSimdDot3(c.m_contactNormal1.mVec128, bodyA.internalGetDeltaLinearVelocity().mVec128), btSimdDot3(c.m_relpos1CrossNormal.mVec128, bodyA.internalGetDeltaAngularVelocity().mVec128)); + __m128 deltaVel2Dotn = _mm_add_ps(btSimdDot3(c.m_contactNormal2.mVec128, bodyB.internalGetDeltaLinearVelocity().mVec128), btSimdDot3(c.m_relpos2CrossNormal.mVec128, bodyB.internalGetDeltaAngularVelocity().mVec128)); + deltaImpulse = _mm_sub_ps(deltaImpulse, _mm_mul_ps(deltaVel1Dotn, _mm_set1_ps(c.m_jacDiagABInv))); + deltaImpulse = _mm_sub_ps(deltaImpulse, _mm_mul_ps(deltaVel2Dotn, _mm_set1_ps(c.m_jacDiagABInv))); + btSimdScalar sum = _mm_add_ps(cpAppliedImp, deltaImpulse); + btSimdScalar resultLowerLess, resultUpperLess; + resultLowerLess = _mm_cmplt_ps(sum, lowerLimit1); + resultUpperLess = _mm_cmplt_ps(sum, upperLimit1); + __m128 lowMinApplied = _mm_sub_ps(lowerLimit1, cpAppliedImp); + deltaImpulse = _mm_or_ps(_mm_and_ps(resultLowerLess, lowMinApplied), _mm_andnot_ps(resultLowerLess, deltaImpulse)); + c.m_appliedImpulse = _mm_or_ps(_mm_and_ps(resultLowerLess, lowerLimit1), _mm_andnot_ps(resultLowerLess, sum)); + __m128 upperMinApplied = _mm_sub_ps(upperLimit1, cpAppliedImp); + deltaImpulse = _mm_or_ps(_mm_and_ps(resultUpperLess, deltaImpulse), _mm_andnot_ps(resultUpperLess, upperMinApplied)); + c.m_appliedImpulse = _mm_or_ps(_mm_and_ps(resultUpperLess, c.m_appliedImpulse), _mm_andnot_ps(resultUpperLess, upperLimit1)); + __m128 linearComponentA = _mm_mul_ps(c.m_contactNormal1.mVec128, bodyA.internalGetInvMass().mVec128); + __m128 linearComponentB = _mm_mul_ps((c.m_contactNormal2).mVec128, bodyB.internalGetInvMass().mVec128); + __m128 impulseMagnitude = deltaImpulse; + bodyA.internalGetDeltaLinearVelocity().mVec128 = _mm_add_ps(bodyA.internalGetDeltaLinearVelocity().mVec128, _mm_mul_ps(linearComponentA, impulseMagnitude)); + bodyA.internalGetDeltaAngularVelocity().mVec128 = _mm_add_ps(bodyA.internalGetDeltaAngularVelocity().mVec128, _mm_mul_ps(c.m_angularComponentA.mVec128, impulseMagnitude)); + bodyB.internalGetDeltaLinearVelocity().mVec128 = _mm_add_ps(bodyB.internalGetDeltaLinearVelocity().mVec128, _mm_mul_ps(linearComponentB, impulseMagnitude)); + bodyB.internalGetDeltaAngularVelocity().mVec128 = _mm_add_ps(bodyB.internalGetDeltaAngularVelocity().mVec128, _mm_mul_ps(c.m_angularComponentB.mVec128, impulseMagnitude)); + return deltaImpulse.m_floats[0] / c.m_jacDiagABInv; +} + +// Enhanced version of gResolveSingleConstraintRowGeneric_sse2 with SSE4.1 and FMA3 +static btScalar gResolveSingleConstraintRowGeneric_sse4_1_fma3(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ +#if defined(BT_ALLOW_SSE4) + __m128 tmp = _mm_set_ps1(c.m_jacDiagABInv); + __m128 deltaImpulse = _mm_set_ps1(c.m_rhs - btScalar(c.m_appliedImpulse) * c.m_cfm); + const __m128 lowerLimit = _mm_set_ps1(c.m_lowerLimit); + const __m128 upperLimit = _mm_set_ps1(c.m_upperLimit); + const __m128 deltaVel1Dotn = _mm_add_ps(DOT_PRODUCT(c.m_contactNormal1.mVec128, bodyA.internalGetDeltaLinearVelocity().mVec128), DOT_PRODUCT(c.m_relpos1CrossNormal.mVec128, bodyA.internalGetDeltaAngularVelocity().mVec128)); + const __m128 deltaVel2Dotn = _mm_add_ps(DOT_PRODUCT(c.m_contactNormal2.mVec128, bodyB.internalGetDeltaLinearVelocity().mVec128), DOT_PRODUCT(c.m_relpos2CrossNormal.mVec128, bodyB.internalGetDeltaAngularVelocity().mVec128)); + deltaImpulse = FMNADD(deltaVel1Dotn, tmp, deltaImpulse); + deltaImpulse = FMNADD(deltaVel2Dotn, tmp, deltaImpulse); + tmp = _mm_add_ps(c.m_appliedImpulse, deltaImpulse); // sum + const __m128 maskLower = _mm_cmpgt_ps(tmp, lowerLimit); + const __m128 maskUpper = _mm_cmpgt_ps(upperLimit, tmp); + deltaImpulse = _mm_blendv_ps(_mm_sub_ps(lowerLimit, c.m_appliedImpulse), _mm_blendv_ps(_mm_sub_ps(upperLimit, c.m_appliedImpulse), deltaImpulse, maskUpper), maskLower); + c.m_appliedImpulse = _mm_blendv_ps(lowerLimit, _mm_blendv_ps(upperLimit, tmp, maskUpper), maskLower); + bodyA.internalGetDeltaLinearVelocity().mVec128 = FMADD(_mm_mul_ps(c.m_contactNormal1.mVec128, bodyA.internalGetInvMass().mVec128), deltaImpulse, bodyA.internalGetDeltaLinearVelocity().mVec128); + bodyA.internalGetDeltaAngularVelocity().mVec128 = FMADD(c.m_angularComponentA.mVec128, deltaImpulse, bodyA.internalGetDeltaAngularVelocity().mVec128); + bodyB.internalGetDeltaLinearVelocity().mVec128 = FMADD(_mm_mul_ps(c.m_contactNormal2.mVec128, bodyB.internalGetInvMass().mVec128), deltaImpulse, bodyB.internalGetDeltaLinearVelocity().mVec128); + bodyB.internalGetDeltaAngularVelocity().mVec128 = FMADD(c.m_angularComponentB.mVec128, deltaImpulse, bodyB.internalGetDeltaAngularVelocity().mVec128); + btSimdScalar deltaImp = deltaImpulse; + return deltaImp.m_floats[0] * (1. / c.m_jacDiagABInv); +#else + return gResolveSingleConstraintRowGeneric_sse2(bodyA, bodyB, c); +#endif +} + +static btScalar gResolveSingleConstraintRowLowerLimit_sse2(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ + __m128 cpAppliedImp = _mm_set1_ps(c.m_appliedImpulse); + __m128 lowerLimit1 = _mm_set1_ps(c.m_lowerLimit); + __m128 upperLimit1 = _mm_set1_ps(c.m_upperLimit); + btSimdScalar deltaImpulse = _mm_sub_ps(_mm_set1_ps(c.m_rhs), _mm_mul_ps(_mm_set1_ps(c.m_appliedImpulse), _mm_set1_ps(c.m_cfm))); + __m128 deltaVel1Dotn = _mm_add_ps(btSimdDot3(c.m_contactNormal1.mVec128, bodyA.internalGetDeltaLinearVelocity().mVec128), btSimdDot3(c.m_relpos1CrossNormal.mVec128, bodyA.internalGetDeltaAngularVelocity().mVec128)); + __m128 deltaVel2Dotn = _mm_add_ps(btSimdDot3(c.m_contactNormal2.mVec128, bodyB.internalGetDeltaLinearVelocity().mVec128), btSimdDot3(c.m_relpos2CrossNormal.mVec128, bodyB.internalGetDeltaAngularVelocity().mVec128)); + deltaImpulse = _mm_sub_ps(deltaImpulse, _mm_mul_ps(deltaVel1Dotn, _mm_set1_ps(c.m_jacDiagABInv))); + deltaImpulse = _mm_sub_ps(deltaImpulse, _mm_mul_ps(deltaVel2Dotn, _mm_set1_ps(c.m_jacDiagABInv))); + btSimdScalar sum = _mm_add_ps(cpAppliedImp, deltaImpulse); + btSimdScalar resultLowerLess, resultUpperLess; + resultLowerLess = _mm_cmplt_ps(sum, lowerLimit1); + resultUpperLess = _mm_cmplt_ps(sum, upperLimit1); + __m128 lowMinApplied = _mm_sub_ps(lowerLimit1, cpAppliedImp); + deltaImpulse = _mm_or_ps(_mm_and_ps(resultLowerLess, lowMinApplied), _mm_andnot_ps(resultLowerLess, deltaImpulse)); + c.m_appliedImpulse = _mm_or_ps(_mm_and_ps(resultLowerLess, lowerLimit1), _mm_andnot_ps(resultLowerLess, sum)); + __m128 linearComponentA = _mm_mul_ps(c.m_contactNormal1.mVec128, bodyA.internalGetInvMass().mVec128); + __m128 linearComponentB = _mm_mul_ps(c.m_contactNormal2.mVec128, bodyB.internalGetInvMass().mVec128); + __m128 impulseMagnitude = deltaImpulse; + bodyA.internalGetDeltaLinearVelocity().mVec128 = _mm_add_ps(bodyA.internalGetDeltaLinearVelocity().mVec128, _mm_mul_ps(linearComponentA, impulseMagnitude)); + bodyA.internalGetDeltaAngularVelocity().mVec128 = _mm_add_ps(bodyA.internalGetDeltaAngularVelocity().mVec128, _mm_mul_ps(c.m_angularComponentA.mVec128, impulseMagnitude)); + bodyB.internalGetDeltaLinearVelocity().mVec128 = _mm_add_ps(bodyB.internalGetDeltaLinearVelocity().mVec128, _mm_mul_ps(linearComponentB, impulseMagnitude)); + bodyB.internalGetDeltaAngularVelocity().mVec128 = _mm_add_ps(bodyB.internalGetDeltaAngularVelocity().mVec128, _mm_mul_ps(c.m_angularComponentB.mVec128, impulseMagnitude)); + return deltaImpulse.m_floats[0] / c.m_jacDiagABInv; +} + +// Enhanced version of gResolveSingleConstraintRowGeneric_sse2 with SSE4.1 and FMA3 +static btScalar gResolveSingleConstraintRowLowerLimit_sse4_1_fma3(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ +#ifdef BT_ALLOW_SSE4 + __m128 tmp = _mm_set_ps1(c.m_jacDiagABInv); + __m128 deltaImpulse = _mm_set_ps1(c.m_rhs - btScalar(c.m_appliedImpulse) * c.m_cfm); + const __m128 lowerLimit = _mm_set_ps1(c.m_lowerLimit); + const __m128 deltaVel1Dotn = _mm_add_ps(DOT_PRODUCT(c.m_contactNormal1.mVec128, bodyA.internalGetDeltaLinearVelocity().mVec128), DOT_PRODUCT(c.m_relpos1CrossNormal.mVec128, bodyA.internalGetDeltaAngularVelocity().mVec128)); + const __m128 deltaVel2Dotn = _mm_add_ps(DOT_PRODUCT(c.m_contactNormal2.mVec128, bodyB.internalGetDeltaLinearVelocity().mVec128), DOT_PRODUCT(c.m_relpos2CrossNormal.mVec128, bodyB.internalGetDeltaAngularVelocity().mVec128)); + deltaImpulse = FMNADD(deltaVel1Dotn, tmp, deltaImpulse); + deltaImpulse = FMNADD(deltaVel2Dotn, tmp, deltaImpulse); + tmp = _mm_add_ps(c.m_appliedImpulse, deltaImpulse); + const __m128 mask = _mm_cmpgt_ps(tmp, lowerLimit); + deltaImpulse = _mm_blendv_ps(_mm_sub_ps(lowerLimit, c.m_appliedImpulse), deltaImpulse, mask); + c.m_appliedImpulse = _mm_blendv_ps(lowerLimit, tmp, mask); + bodyA.internalGetDeltaLinearVelocity().mVec128 = FMADD(_mm_mul_ps(c.m_contactNormal1.mVec128, bodyA.internalGetInvMass().mVec128), deltaImpulse, bodyA.internalGetDeltaLinearVelocity().mVec128); + bodyA.internalGetDeltaAngularVelocity().mVec128 = FMADD(c.m_angularComponentA.mVec128, deltaImpulse, bodyA.internalGetDeltaAngularVelocity().mVec128); + bodyB.internalGetDeltaLinearVelocity().mVec128 = FMADD(_mm_mul_ps(c.m_contactNormal2.mVec128, bodyB.internalGetInvMass().mVec128), deltaImpulse, bodyB.internalGetDeltaLinearVelocity().mVec128); + bodyB.internalGetDeltaAngularVelocity().mVec128 = FMADD(c.m_angularComponentB.mVec128, deltaImpulse, bodyB.internalGetDeltaAngularVelocity().mVec128); + btSimdScalar deltaImp = deltaImpulse; + return deltaImp.m_floats[0] * (1. / c.m_jacDiagABInv); +#else + return gResolveSingleConstraintRowLowerLimit_sse2(bodyA, bodyB, c); +#endif //BT_ALLOW_SSE4 +} + +#endif //USE_SIMD + +btScalar btSequentialImpulseConstraintSolver::resolveSingleConstraintRowGenericSIMD(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ + return m_resolveSingleConstraintRowGeneric(bodyA, bodyB, c); +} + +// Project Gauss Seidel or the equivalent Sequential Impulse +btScalar btSequentialImpulseConstraintSolver::resolveSingleConstraintRowGeneric(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ + return m_resolveSingleConstraintRowGeneric(bodyA, bodyB, c); +} + +btScalar btSequentialImpulseConstraintSolver::resolveSingleConstraintRowLowerLimitSIMD(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ + return m_resolveSingleConstraintRowLowerLimit(bodyA, bodyB, c); +} + +btScalar btSequentialImpulseConstraintSolver::resolveSingleConstraintRowLowerLimit(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ + return m_resolveSingleConstraintRowLowerLimit(bodyA, bodyB, c); +} + +static btScalar gResolveSplitPenetrationImpulse_scalar_reference( + btSolverBody& bodyA, + btSolverBody& bodyB, + const btSolverConstraint& c) +{ + btScalar deltaImpulse = 0.f; + + if (c.m_rhsPenetration) + { + gNumSplitImpulseRecoveries++; + deltaImpulse = c.m_rhsPenetration - btScalar(c.m_appliedPushImpulse) * c.m_cfm; + const btScalar deltaVel1Dotn = c.m_contactNormal1.dot(bodyA.internalGetPushVelocity()) + c.m_relpos1CrossNormal.dot(bodyA.internalGetTurnVelocity()); + const btScalar deltaVel2Dotn = c.m_contactNormal2.dot(bodyB.internalGetPushVelocity()) + c.m_relpos2CrossNormal.dot(bodyB.internalGetTurnVelocity()); + + deltaImpulse -= deltaVel1Dotn * c.m_jacDiagABInv; + deltaImpulse -= deltaVel2Dotn * c.m_jacDiagABInv; + const btScalar sum = btScalar(c.m_appliedPushImpulse) + deltaImpulse; + if (sum < c.m_lowerLimit) + { + deltaImpulse = c.m_lowerLimit - c.m_appliedPushImpulse; + c.m_appliedPushImpulse = c.m_lowerLimit; + } + else + { + c.m_appliedPushImpulse = sum; + } + bodyA.internalApplyPushImpulse(c.m_contactNormal1 * bodyA.internalGetInvMass(), c.m_angularComponentA, deltaImpulse); + bodyB.internalApplyPushImpulse(c.m_contactNormal2 * bodyB.internalGetInvMass(), c.m_angularComponentB, deltaImpulse); + } + return deltaImpulse * (1. / c.m_jacDiagABInv); +} + +static btScalar gResolveSplitPenetrationImpulse_sse2(btSolverBody& bodyA, btSolverBody& bodyB, const btSolverConstraint& c) +{ +#ifdef USE_SIMD + if (!c.m_rhsPenetration) + return 0.f; + + gNumSplitImpulseRecoveries++; + + __m128 cpAppliedImp = _mm_set1_ps(c.m_appliedPushImpulse); + __m128 lowerLimit1 = _mm_set1_ps(c.m_lowerLimit); + __m128 upperLimit1 = _mm_set1_ps(c.m_upperLimit); + __m128 deltaImpulse = _mm_sub_ps(_mm_set1_ps(c.m_rhsPenetration), _mm_mul_ps(_mm_set1_ps(c.m_appliedPushImpulse), _mm_set1_ps(c.m_cfm))); + __m128 deltaVel1Dotn = _mm_add_ps(btSimdDot3(c.m_contactNormal1.mVec128, bodyA.internalGetPushVelocity().mVec128), btSimdDot3(c.m_relpos1CrossNormal.mVec128, bodyA.internalGetTurnVelocity().mVec128)); + __m128 deltaVel2Dotn = _mm_add_ps(btSimdDot3(c.m_contactNormal2.mVec128, bodyB.internalGetPushVelocity().mVec128), btSimdDot3(c.m_relpos2CrossNormal.mVec128, bodyB.internalGetTurnVelocity().mVec128)); + deltaImpulse = _mm_sub_ps(deltaImpulse, _mm_mul_ps(deltaVel1Dotn, _mm_set1_ps(c.m_jacDiagABInv))); + deltaImpulse = _mm_sub_ps(deltaImpulse, _mm_mul_ps(deltaVel2Dotn, _mm_set1_ps(c.m_jacDiagABInv))); + btSimdScalar sum = _mm_add_ps(cpAppliedImp, deltaImpulse); + btSimdScalar resultLowerLess, resultUpperLess; + resultLowerLess = _mm_cmplt_ps(sum, lowerLimit1); + resultUpperLess = _mm_cmplt_ps(sum, upperLimit1); + __m128 lowMinApplied = _mm_sub_ps(lowerLimit1, cpAppliedImp); + deltaImpulse = _mm_or_ps(_mm_and_ps(resultLowerLess, lowMinApplied), _mm_andnot_ps(resultLowerLess, deltaImpulse)); + c.m_appliedPushImpulse = _mm_or_ps(_mm_and_ps(resultLowerLess, lowerLimit1), _mm_andnot_ps(resultLowerLess, sum)); + __m128 linearComponentA = _mm_mul_ps(c.m_contactNormal1.mVec128, bodyA.internalGetInvMass().mVec128); + __m128 linearComponentB = _mm_mul_ps(c.m_contactNormal2.mVec128, bodyB.internalGetInvMass().mVec128); + __m128 impulseMagnitude = deltaImpulse; + bodyA.internalGetPushVelocity().mVec128 = _mm_add_ps(bodyA.internalGetPushVelocity().mVec128, _mm_mul_ps(linearComponentA, impulseMagnitude)); + bodyA.internalGetTurnVelocity().mVec128 = _mm_add_ps(bodyA.internalGetTurnVelocity().mVec128, _mm_mul_ps(c.m_angularComponentA.mVec128, impulseMagnitude)); + bodyB.internalGetPushVelocity().mVec128 = _mm_add_ps(bodyB.internalGetPushVelocity().mVec128, _mm_mul_ps(linearComponentB, impulseMagnitude)); + bodyB.internalGetTurnVelocity().mVec128 = _mm_add_ps(bodyB.internalGetTurnVelocity().mVec128, _mm_mul_ps(c.m_angularComponentB.mVec128, impulseMagnitude)); + btSimdScalar deltaImp = deltaImpulse; + return deltaImp.m_floats[0] * (1. / c.m_jacDiagABInv); +#else + return gResolveSplitPenetrationImpulse_scalar_reference(bodyA, bodyB, c); +#endif +} + +btSequentialImpulseConstraintSolver::btSequentialImpulseConstraintSolver() +{ + m_btSeed2 = 0; + m_cachedSolverMode = 0; + setupSolverFunctions(false); +} + +void btSequentialImpulseConstraintSolver::setupSolverFunctions(bool useSimd) +{ + m_resolveSingleConstraintRowGeneric = gResolveSingleConstraintRowGeneric_scalar_reference; + m_resolveSingleConstraintRowLowerLimit = gResolveSingleConstraintRowLowerLimit_scalar_reference; + m_resolveSplitPenetrationImpulse = gResolveSplitPenetrationImpulse_scalar_reference; + + if (useSimd) + { +#ifdef USE_SIMD + m_resolveSingleConstraintRowGeneric = gResolveSingleConstraintRowGeneric_sse2; + m_resolveSingleConstraintRowLowerLimit = gResolveSingleConstraintRowLowerLimit_sse2; + m_resolveSplitPenetrationImpulse = gResolveSplitPenetrationImpulse_sse2; + +#ifdef BT_ALLOW_SSE4 + int cpuFeatures = btCpuFeatureUtility::getCpuFeatures(); + if ((cpuFeatures & btCpuFeatureUtility::CPU_FEATURE_FMA3) && (cpuFeatures & btCpuFeatureUtility::CPU_FEATURE_SSE4_1)) + { + m_resolveSingleConstraintRowGeneric = gResolveSingleConstraintRowGeneric_sse4_1_fma3; + m_resolveSingleConstraintRowLowerLimit = gResolveSingleConstraintRowLowerLimit_sse4_1_fma3; + } +#endif //BT_ALLOW_SSE4 +#endif //USE_SIMD + } +} + +btSequentialImpulseConstraintSolver::~btSequentialImpulseConstraintSolver() +{ +} + +btSingleConstraintRowSolver btSequentialImpulseConstraintSolver::getScalarConstraintRowSolverGeneric() +{ + return gResolveSingleConstraintRowGeneric_scalar_reference; +} + +btSingleConstraintRowSolver btSequentialImpulseConstraintSolver::getScalarConstraintRowSolverLowerLimit() +{ + return gResolveSingleConstraintRowLowerLimit_scalar_reference; +} + +#ifdef USE_SIMD +btSingleConstraintRowSolver btSequentialImpulseConstraintSolver::getSSE2ConstraintRowSolverGeneric() +{ + return gResolveSingleConstraintRowGeneric_sse2; +} +btSingleConstraintRowSolver btSequentialImpulseConstraintSolver::getSSE2ConstraintRowSolverLowerLimit() +{ + return gResolveSingleConstraintRowLowerLimit_sse2; +} +#ifdef BT_ALLOW_SSE4 +btSingleConstraintRowSolver btSequentialImpulseConstraintSolver::getSSE4_1ConstraintRowSolverGeneric() +{ + return gResolveSingleConstraintRowGeneric_sse4_1_fma3; +} +btSingleConstraintRowSolver btSequentialImpulseConstraintSolver::getSSE4_1ConstraintRowSolverLowerLimit() +{ + return gResolveSingleConstraintRowLowerLimit_sse4_1_fma3; +} +#endif //BT_ALLOW_SSE4 +#endif //USE_SIMD + +unsigned long btSequentialImpulseConstraintSolver::btRand2() +{ + m_btSeed2 = (1664525L * m_btSeed2 + 1013904223L) & 0xffffffff; + return m_btSeed2; +} + +//See ODE: adam's all-int straightforward(?) dRandInt (0..n-1) +int btSequentialImpulseConstraintSolver::btRandInt2(int n) +{ + // seems good; xor-fold and modulus + const unsigned long un = static_cast(n); + unsigned long r = btRand2(); + + // note: probably more aggressive than it needs to be -- might be + // able to get away without one or two of the innermost branches. + if (un <= 0x00010000UL) + { + r ^= (r >> 16); + if (un <= 0x00000100UL) + { + r ^= (r >> 8); + if (un <= 0x00000010UL) + { + r ^= (r >> 4); + if (un <= 0x00000004UL) + { + r ^= (r >> 2); + if (un <= 0x00000002UL) + { + r ^= (r >> 1); + } + } + } + } + } + + return (int)(r % un); +} + +void btSequentialImpulseConstraintSolver::initSolverBody(btSolverBody* solverBody, btCollisionObject* collisionObject, btScalar timeStep) +{ + btRigidBody* rb = collisionObject ? btRigidBody::upcast(collisionObject) : 0; + + solverBody->internalGetDeltaLinearVelocity().setValue(0.f, 0.f, 0.f); + solverBody->internalGetDeltaAngularVelocity().setValue(0.f, 0.f, 0.f); + solverBody->internalGetPushVelocity().setValue(0.f, 0.f, 0.f); + solverBody->internalGetTurnVelocity().setValue(0.f, 0.f, 0.f); + + if (rb) + { + solverBody->m_worldTransform = rb->getWorldTransform(); + solverBody->internalSetInvMass(btVector3(rb->getInvMass(), rb->getInvMass(), rb->getInvMass()) * rb->getLinearFactor()); + solverBody->m_originalBody = rb; + solverBody->m_angularFactor = rb->getAngularFactor(); + solverBody->m_linearFactor = rb->getLinearFactor(); + solverBody->m_linearVelocity = rb->getLinearVelocity(); + solverBody->m_angularVelocity = rb->getAngularVelocity(); + solverBody->m_externalForceImpulse = rb->getTotalForce() * rb->getInvMass() * timeStep; + solverBody->m_externalTorqueImpulse = rb->getTotalTorque() * rb->getInvInertiaTensorWorld() * timeStep; + } + else + { + solverBody->m_worldTransform.setIdentity(); + solverBody->internalSetInvMass(btVector3(0, 0, 0)); + solverBody->m_originalBody = 0; + solverBody->m_angularFactor.setValue(1, 1, 1); + solverBody->m_linearFactor.setValue(1, 1, 1); + solverBody->m_linearVelocity.setValue(0, 0, 0); + solverBody->m_angularVelocity.setValue(0, 0, 0); + solverBody->m_externalForceImpulse.setValue(0, 0, 0); + solverBody->m_externalTorqueImpulse.setValue(0, 0, 0); + } + } + +btScalar btSequentialImpulseConstraintSolver::restitutionCurve(btScalar rel_vel, btScalar restitution, btScalar velocityThreshold) +{ + //printf("rel_vel =%f\n", rel_vel); + if (btFabs(rel_vel) < velocityThreshold) + return 0.; + + btScalar rest = restitution * -rel_vel; + return rest; +} + +void btSequentialImpulseConstraintSolver::applyAnisotropicFriction(btCollisionObject* colObj, btVector3& frictionDirection, int frictionMode) +{ + if (colObj && colObj->hasAnisotropicFriction(frictionMode)) + { + // transform to local coordinates + btVector3 loc_lateral = frictionDirection * colObj->getWorldTransform().getBasis(); + const btVector3& friction_scaling = colObj->getAnisotropicFriction(); + //apply anisotropic friction + loc_lateral *= friction_scaling; + // ... and transform it back to global coordinates + frictionDirection = colObj->getWorldTransform().getBasis() * loc_lateral; + } +} + +void btSequentialImpulseConstraintSolver::setupFrictionConstraint(btSolverConstraint& solverConstraint, const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB, btManifoldPoint& cp, const btVector3& rel_pos1, const btVector3& rel_pos2, btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, const btContactSolverInfo& infoGlobal, btScalar desiredVelocity, btScalar cfmSlip) +{ + btSolverBody& solverBodyA = m_tmpSolverBodyPool[solverBodyIdA]; + btSolverBody& solverBodyB = m_tmpSolverBodyPool[solverBodyIdB]; + + btRigidBody* body0 = m_tmpSolverBodyPool[solverBodyIdA].m_originalBody; + btRigidBody* bodyA = m_tmpSolverBodyPool[solverBodyIdB].m_originalBody; + + solverConstraint.m_solverBodyIdA = solverBodyIdA; + solverConstraint.m_solverBodyIdB = solverBodyIdB; + + solverConstraint.m_friction = cp.m_combinedFriction; + solverConstraint.m_originalContactPoint = 0; + + solverConstraint.m_appliedImpulse = 0.f; + solverConstraint.m_appliedPushImpulse = 0.f; + + if (body0) + { + solverConstraint.m_contactNormal1 = normalAxis; + btVector3 ftorqueAxis1 = rel_pos1.cross(solverConstraint.m_contactNormal1); + solverConstraint.m_relpos1CrossNormal = ftorqueAxis1; + solverConstraint.m_angularComponentA = body0->getInvInertiaTensorWorld() * ftorqueAxis1 * body0->getAngularFactor(); + } + else + { + solverConstraint.m_contactNormal1.setZero(); + solverConstraint.m_relpos1CrossNormal.setZero(); + solverConstraint.m_angularComponentA.setZero(); + } + + if (bodyA) + { + solverConstraint.m_contactNormal2 = -normalAxis; + btVector3 ftorqueAxis1 = rel_pos2.cross(solverConstraint.m_contactNormal2); + solverConstraint.m_relpos2CrossNormal = ftorqueAxis1; + solverConstraint.m_angularComponentB = bodyA->getInvInertiaTensorWorld() * ftorqueAxis1 * bodyA->getAngularFactor(); + } + else + { + solverConstraint.m_contactNormal2.setZero(); + solverConstraint.m_relpos2CrossNormal.setZero(); + solverConstraint.m_angularComponentB.setZero(); + } + + { + btVector3 vec; + btScalar denom0 = 0.f; + btScalar denom1 = 0.f; + if (body0) + { + vec = (solverConstraint.m_angularComponentA).cross(rel_pos1); + denom0 = body0->getInvMass() + normalAxis.dot(vec); + } + if (bodyA) + { + vec = (-solverConstraint.m_angularComponentB).cross(rel_pos2); + denom1 = bodyA->getInvMass() + normalAxis.dot(vec); + } + btScalar denom = relaxation / (denom0 + denom1); + solverConstraint.m_jacDiagABInv = denom; + } + + { + btScalar rel_vel; + btScalar vel1Dotn = solverConstraint.m_contactNormal1.dot(body0 ? solverBodyA.m_linearVelocity + solverBodyA.m_externalForceImpulse : btVector3(0, 0, 0)) + solverConstraint.m_relpos1CrossNormal.dot(body0 ? solverBodyA.m_angularVelocity : btVector3(0, 0, 0)); + btScalar vel2Dotn = solverConstraint.m_contactNormal2.dot(bodyA ? solverBodyB.m_linearVelocity + solverBodyB.m_externalForceImpulse : btVector3(0, 0, 0)) + solverConstraint.m_relpos2CrossNormal.dot(bodyA ? solverBodyB.m_angularVelocity : btVector3(0, 0, 0)); + + rel_vel = vel1Dotn + vel2Dotn; + + // btScalar positionalError = 0.f; + + btScalar velocityError = desiredVelocity - rel_vel; + btScalar velocityImpulse = velocityError * solverConstraint.m_jacDiagABInv; + + btScalar penetrationImpulse = btScalar(0); + + if (cp.m_contactPointFlags & BT_CONTACT_FLAG_FRICTION_ANCHOR) + { + btScalar distance = (cp.getPositionWorldOnA() - cp.getPositionWorldOnB()).dot(normalAxis); + btScalar positionalError = -distance * infoGlobal.m_frictionERP / infoGlobal.m_timeStep; + penetrationImpulse = positionalError * solverConstraint.m_jacDiagABInv; + } + + solverConstraint.m_rhs = penetrationImpulse + velocityImpulse; + solverConstraint.m_rhsPenetration = 0.f; + solverConstraint.m_cfm = cfmSlip; + solverConstraint.m_lowerLimit = -solverConstraint.m_friction; + solverConstraint.m_upperLimit = solverConstraint.m_friction; + } +} + +btSolverConstraint& btSequentialImpulseConstraintSolver::addFrictionConstraint(const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB, int frictionIndex, btManifoldPoint& cp, const btVector3& rel_pos1, const btVector3& rel_pos2, btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, const btContactSolverInfo& infoGlobal, btScalar desiredVelocity, btScalar cfmSlip) +{ + btSolverConstraint& solverConstraint = m_tmpSolverContactFrictionConstraintPool.expandNonInitializing(); + solverConstraint.m_frictionIndex = frictionIndex; + setupFrictionConstraint(solverConstraint, normalAxis, solverBodyIdA, solverBodyIdB, cp, rel_pos1, rel_pos2, + colObj0, colObj1, relaxation, infoGlobal, desiredVelocity, cfmSlip); + return solverConstraint; +} + +void btSequentialImpulseConstraintSolver::setupTorsionalFrictionConstraint(btSolverConstraint& solverConstraint, const btVector3& normalAxis1, int solverBodyIdA, int solverBodyIdB, + btManifoldPoint& cp, btScalar combinedTorsionalFriction, const btVector3& rel_pos1, const btVector3& rel_pos2, + btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, + btScalar desiredVelocity, btScalar cfmSlip) + +{ + btVector3 normalAxis(0, 0, 0); + + solverConstraint.m_contactNormal1 = normalAxis; + solverConstraint.m_contactNormal2 = -normalAxis; + btSolverBody& solverBodyA = m_tmpSolverBodyPool[solverBodyIdA]; + btSolverBody& solverBodyB = m_tmpSolverBodyPool[solverBodyIdB]; + + btRigidBody* body0 = m_tmpSolverBodyPool[solverBodyIdA].m_originalBody; + btRigidBody* bodyA = m_tmpSolverBodyPool[solverBodyIdB].m_originalBody; + + solverConstraint.m_solverBodyIdA = solverBodyIdA; + solverConstraint.m_solverBodyIdB = solverBodyIdB; + + solverConstraint.m_friction = combinedTorsionalFriction; + solverConstraint.m_originalContactPoint = 0; + + solverConstraint.m_appliedImpulse = 0.f; + solverConstraint.m_appliedPushImpulse = 0.f; + + { + btVector3 ftorqueAxis1 = -normalAxis1; + solverConstraint.m_relpos1CrossNormal = ftorqueAxis1; + solverConstraint.m_angularComponentA = body0 ? body0->getInvInertiaTensorWorld() * ftorqueAxis1 * body0->getAngularFactor() : btVector3(0, 0, 0); + } + { + btVector3 ftorqueAxis1 = normalAxis1; + solverConstraint.m_relpos2CrossNormal = ftorqueAxis1; + solverConstraint.m_angularComponentB = bodyA ? bodyA->getInvInertiaTensorWorld() * ftorqueAxis1 * bodyA->getAngularFactor() : btVector3(0, 0, 0); + } + + { + btVector3 iMJaA = body0 ? body0->getInvInertiaTensorWorld() * solverConstraint.m_relpos1CrossNormal : btVector3(0, 0, 0); + btVector3 iMJaB = bodyA ? bodyA->getInvInertiaTensorWorld() * solverConstraint.m_relpos2CrossNormal : btVector3(0, 0, 0); + btScalar sum = 0; + sum += iMJaA.dot(solverConstraint.m_relpos1CrossNormal); + sum += iMJaB.dot(solverConstraint.m_relpos2CrossNormal); + solverConstraint.m_jacDiagABInv = btScalar(1.) / sum; + } + + { + btScalar rel_vel; + btScalar vel1Dotn = solverConstraint.m_contactNormal1.dot(body0 ? solverBodyA.m_linearVelocity + solverBodyA.m_externalForceImpulse : btVector3(0, 0, 0)) + solverConstraint.m_relpos1CrossNormal.dot(body0 ? solverBodyA.m_angularVelocity : btVector3(0, 0, 0)); + btScalar vel2Dotn = solverConstraint.m_contactNormal2.dot(bodyA ? solverBodyB.m_linearVelocity + solverBodyB.m_externalForceImpulse : btVector3(0, 0, 0)) + solverConstraint.m_relpos2CrossNormal.dot(bodyA ? solverBodyB.m_angularVelocity : btVector3(0, 0, 0)); + + rel_vel = vel1Dotn + vel2Dotn; + + // btScalar positionalError = 0.f; + + btSimdScalar velocityError = desiredVelocity - rel_vel; + btSimdScalar velocityImpulse = velocityError * btSimdScalar(solverConstraint.m_jacDiagABInv); + solverConstraint.m_rhs = velocityImpulse; + solverConstraint.m_cfm = cfmSlip; + solverConstraint.m_lowerLimit = -solverConstraint.m_friction; + solverConstraint.m_upperLimit = solverConstraint.m_friction; + } +} + +btSolverConstraint& btSequentialImpulseConstraintSolver::addTorsionalFrictionConstraint(const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB, int frictionIndex, btManifoldPoint& cp, btScalar combinedTorsionalFriction, const btVector3& rel_pos1, const btVector3& rel_pos2, btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, btScalar desiredVelocity, btScalar cfmSlip) +{ + btSolverConstraint& solverConstraint = m_tmpSolverContactRollingFrictionConstraintPool.expandNonInitializing(); + solverConstraint.m_frictionIndex = frictionIndex; + setupTorsionalFrictionConstraint(solverConstraint, normalAxis, solverBodyIdA, solverBodyIdB, cp, combinedTorsionalFriction, rel_pos1, rel_pos2, + colObj0, colObj1, relaxation, desiredVelocity, cfmSlip); + return solverConstraint; +} + +int btSequentialImpulseConstraintSolver::getOrInitSolverBody(btCollisionObject& body, btScalar timeStep) +{ +#if BT_THREADSAFE + int solverBodyId = -1; + const bool isRigidBodyType = btRigidBody::upcast(&body) != NULL; + const bool isStaticOrKinematic = body.isStaticOrKinematicObject(); + const bool isKinematic = body.isKinematicObject(); + if (isRigidBodyType && !isStaticOrKinematic) + { + // dynamic body + // Dynamic bodies can only be in one island, so it's safe to write to the companionId + solverBodyId = body.getCompanionId(); + if (solverBodyId < 0) + { + solverBodyId = m_tmpSolverBodyPool.size(); + btSolverBody& solverBody = m_tmpSolverBodyPool.expand(); + initSolverBody(&solverBody, &body, timeStep); + body.setCompanionId(solverBodyId); + } + } + else if (isRigidBodyType && isKinematic) + { + // + // NOTE: must test for kinematic before static because some kinematic objects also + // identify as "static" + // + // Kinematic bodies can be in multiple islands at once, so it is a + // race condition to write to them, so we use an alternate method + // to record the solverBodyId + int uniqueId = body.getWorldArrayIndex(); + const int INVALID_SOLVER_BODY_ID = -1; + if (uniqueId >= m_kinematicBodyUniqueIdToSolverBodyTable.size()) + { + m_kinematicBodyUniqueIdToSolverBodyTable.resize(uniqueId + 1, INVALID_SOLVER_BODY_ID); + } + solverBodyId = m_kinematicBodyUniqueIdToSolverBodyTable[uniqueId]; + // if no table entry yet, + if (solverBodyId == INVALID_SOLVER_BODY_ID) + { + // create a table entry for this body + solverBodyId = m_tmpSolverBodyPool.size(); + btSolverBody& solverBody = m_tmpSolverBodyPool.expand(); + initSolverBody(&solverBody, &body, timeStep); + m_kinematicBodyUniqueIdToSolverBodyTable[uniqueId] = solverBodyId; + } + } + else + { + bool isMultiBodyType = (body.getInternalType() & btCollisionObject::CO_FEATHERSTONE_LINK); + // Incorrectly set collision object flags can degrade performance in various ways. + if (!isMultiBodyType) + { + btAssert(body.isStaticOrKinematicObject()); + } + //it could be a multibody link collider + // all fixed bodies (inf mass) get mapped to a single solver id + if (m_fixedBodyId < 0) + { + m_fixedBodyId = m_tmpSolverBodyPool.size(); + btSolverBody& fixedBody = m_tmpSolverBodyPool.expand(); + initSolverBody(&fixedBody, 0, timeStep); + } + solverBodyId = m_fixedBodyId; + } + btAssert(solverBodyId >= 0 && solverBodyId < m_tmpSolverBodyPool.size()); + return solverBodyId; +#else // BT_THREADSAFE + + int solverBodyIdA = -1; + + if (body.getCompanionId() >= 0) + { + //body has already been converted + solverBodyIdA = body.getCompanionId(); + btAssert(solverBodyIdA < m_tmpSolverBodyPool.size()); + } + else + { + btRigidBody* rb = btRigidBody::upcast(&body); + //convert both active and kinematic objects (for their velocity) + if (rb && (rb->getInvMass() || rb->isKinematicObject())) + { + solverBodyIdA = m_tmpSolverBodyPool.size(); + btSolverBody& solverBody = m_tmpSolverBodyPool.expand(); + initSolverBody(&solverBody, &body, timeStep); + body.setCompanionId(solverBodyIdA); + } + else + { + if (m_fixedBodyId < 0) + { + m_fixedBodyId = m_tmpSolverBodyPool.size(); + btSolverBody& fixedBody = m_tmpSolverBodyPool.expand(); + initSolverBody(&fixedBody, 0, timeStep); + } + return m_fixedBodyId; + // return 0;//assume first one is a fixed solver body + } + } + + return solverBodyIdA; +#endif // BT_THREADSAFE +} +#include + +void btSequentialImpulseConstraintSolver::setupContactConstraint(btSolverConstraint& solverConstraint, + int solverBodyIdA, int solverBodyIdB, + btManifoldPoint& cp, const btContactSolverInfo& infoGlobal, + btScalar& relaxation, + const btVector3& rel_pos1, const btVector3& rel_pos2) +{ + // const btVector3& pos1 = cp.getPositionWorldOnA(); + // const btVector3& pos2 = cp.getPositionWorldOnB(); + + btSolverBody* bodyA = &m_tmpSolverBodyPool[solverBodyIdA]; + btSolverBody* bodyB = &m_tmpSolverBodyPool[solverBodyIdB]; + + btRigidBody* rb0 = bodyA->m_originalBody; + btRigidBody* rb1 = bodyB->m_originalBody; + + // btVector3 rel_pos1 = pos1 - colObj0->getWorldTransform().getOrigin(); + // btVector3 rel_pos2 = pos2 - colObj1->getWorldTransform().getOrigin(); + //rel_pos1 = pos1 - bodyA->getWorldTransform().getOrigin(); + //rel_pos2 = pos2 - bodyB->getWorldTransform().getOrigin(); + + relaxation = infoGlobal.m_sor; + btScalar invTimeStep = btScalar(1) / infoGlobal.m_timeStep; + + //cfm = 1 / ( dt * kp + kd ) + //erp = dt * kp / ( dt * kp + kd ) + + btScalar cfm = infoGlobal.m_globalCfm; + btScalar erp = infoGlobal.m_erp2; + + if ((cp.m_contactPointFlags & BT_CONTACT_FLAG_HAS_CONTACT_CFM) || (cp.m_contactPointFlags & BT_CONTACT_FLAG_HAS_CONTACT_ERP)) + { + if (cp.m_contactPointFlags & BT_CONTACT_FLAG_HAS_CONTACT_CFM) + cfm = cp.m_contactCFM; + if (cp.m_contactPointFlags & BT_CONTACT_FLAG_HAS_CONTACT_ERP) + erp = cp.m_contactERP; + } + else + { + if (cp.m_contactPointFlags & BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING) + { + btScalar denom = (infoGlobal.m_timeStep * cp.m_combinedContactStiffness1 + cp.m_combinedContactDamping1); + if (denom < SIMD_EPSILON) + { + denom = SIMD_EPSILON; + } + cfm = btScalar(1) / denom; + erp = (infoGlobal.m_timeStep * cp.m_combinedContactStiffness1) / denom; + } + } + + cfm *= invTimeStep; + + btVector3 torqueAxis0 = rel_pos1.cross(cp.m_normalWorldOnB); + solverConstraint.m_angularComponentA = rb0 ? rb0->getInvInertiaTensorWorld() * torqueAxis0 * rb0->getAngularFactor() : btVector3(0, 0, 0); + btVector3 torqueAxis1 = rel_pos2.cross(cp.m_normalWorldOnB); + solverConstraint.m_angularComponentB = rb1 ? rb1->getInvInertiaTensorWorld() * -torqueAxis1 * rb1->getAngularFactor() : btVector3(0, 0, 0); + + { +#ifdef COMPUTE_IMPULSE_DENOM + btScalar denom0 = rb0->computeImpulseDenominator(pos1, cp.m_normalWorldOnB); + btScalar denom1 = rb1->computeImpulseDenominator(pos2, cp.m_normalWorldOnB); +#else + btVector3 vec; + btScalar denom0 = 0.f; + btScalar denom1 = 0.f; + if (rb0) + { + vec = (solverConstraint.m_angularComponentA).cross(rel_pos1); + denom0 = rb0->getInvMass() + cp.m_normalWorldOnB.dot(vec); + } + if (rb1) + { + vec = (-solverConstraint.m_angularComponentB).cross(rel_pos2); + denom1 = rb1->getInvMass() + cp.m_normalWorldOnB.dot(vec); + } +#endif //COMPUTE_IMPULSE_DENOM + + btScalar denom = relaxation / (denom0 + denom1 + cfm); + solverConstraint.m_jacDiagABInv = denom; + } + + if (rb0) + { + solverConstraint.m_contactNormal1 = cp.m_normalWorldOnB; + solverConstraint.m_relpos1CrossNormal = torqueAxis0; + } + else + { + solverConstraint.m_contactNormal1.setZero(); + solverConstraint.m_relpos1CrossNormal.setZero(); + } + if (rb1) + { + solverConstraint.m_contactNormal2 = -cp.m_normalWorldOnB; + solverConstraint.m_relpos2CrossNormal = -torqueAxis1; + } + else + { + solverConstraint.m_contactNormal2.setZero(); + solverConstraint.m_relpos2CrossNormal.setZero(); + } + + btScalar restitution = 0.f; + btScalar penetration = cp.getDistance() + infoGlobal.m_linearSlop; + + { + btVector3 vel1, vel2; + + vel1 = rb0 ? rb0->getVelocityInLocalPoint(rel_pos1) : btVector3(0, 0, 0); + vel2 = rb1 ? rb1->getVelocityInLocalPoint(rel_pos2) : btVector3(0, 0, 0); + + // btVector3 vel2 = rb1 ? rb1->getVelocityInLocalPoint(rel_pos2) : btVector3(0,0,0); + btVector3 vel = vel1 - vel2; + btScalar rel_vel = cp.m_normalWorldOnB.dot(vel); + + solverConstraint.m_friction = cp.m_combinedFriction; + + restitution = restitutionCurve(rel_vel, cp.m_combinedRestitution, infoGlobal.m_restitutionVelocityThreshold); + if (restitution <= btScalar(0.)) + { + restitution = 0.f; + }; + } + + ///warm starting (or zero if disabled) + if (infoGlobal.m_solverMode & SOLVER_USE_WARMSTARTING) + { + solverConstraint.m_appliedImpulse = cp.m_appliedImpulse * infoGlobal.m_warmstartingFactor; + if (rb0) + bodyA->internalApplyImpulse(solverConstraint.m_contactNormal1 * bodyA->internalGetInvMass(), solverConstraint.m_angularComponentA, solverConstraint.m_appliedImpulse); + if (rb1) + bodyB->internalApplyImpulse(-solverConstraint.m_contactNormal2 * bodyB->internalGetInvMass(), -solverConstraint.m_angularComponentB, -(btScalar)solverConstraint.m_appliedImpulse); + } + else + { + solverConstraint.m_appliedImpulse = 0.f; + } + + solverConstraint.m_appliedPushImpulse = 0.f; + + { + btVector3 externalForceImpulseA = bodyA->m_originalBody ? bodyA->m_externalForceImpulse : btVector3(0, 0, 0); + btVector3 externalTorqueImpulseA = bodyA->m_originalBody ? bodyA->m_externalTorqueImpulse : btVector3(0, 0, 0); + btVector3 externalForceImpulseB = bodyB->m_originalBody ? bodyB->m_externalForceImpulse : btVector3(0, 0, 0); + btVector3 externalTorqueImpulseB = bodyB->m_originalBody ? bodyB->m_externalTorqueImpulse : btVector3(0, 0, 0); + + btScalar vel1Dotn = solverConstraint.m_contactNormal1.dot(bodyA->m_linearVelocity + externalForceImpulseA) + solverConstraint.m_relpos1CrossNormal.dot(bodyA->m_angularVelocity + externalTorqueImpulseA); + btScalar vel2Dotn = solverConstraint.m_contactNormal2.dot(bodyB->m_linearVelocity + externalForceImpulseB) + solverConstraint.m_relpos2CrossNormal.dot(bodyB->m_angularVelocity + externalTorqueImpulseB); + btScalar rel_vel = vel1Dotn + vel2Dotn; + + btScalar positionalError = 0.f; + btScalar velocityError = restitution - rel_vel; // * damping; + + if (penetration > 0) + { + positionalError = 0; + + velocityError -= penetration * invTimeStep; + } + else + { + positionalError = -penetration * erp * invTimeStep; + } + + btScalar penetrationImpulse = positionalError * solverConstraint.m_jacDiagABInv; + btScalar velocityImpulse = velocityError * solverConstraint.m_jacDiagABInv; + + if (!infoGlobal.m_splitImpulse || (penetration > infoGlobal.m_splitImpulsePenetrationThreshold)) + { + //combine position and velocity into rhs + solverConstraint.m_rhs = penetrationImpulse + velocityImpulse; //-solverConstraint.m_contactNormal1.dot(bodyA->m_externalForce*bodyA->m_invMass-bodyB->m_externalForce/bodyB->m_invMass)*solverConstraint.m_jacDiagABInv; + solverConstraint.m_rhsPenetration = 0.f; + } + else + { + //split position and velocity into rhs and m_rhsPenetration + solverConstraint.m_rhs = velocityImpulse; + solverConstraint.m_rhsPenetration = penetrationImpulse; + } + solverConstraint.m_cfm = cfm * solverConstraint.m_jacDiagABInv; + solverConstraint.m_lowerLimit = 0; + solverConstraint.m_upperLimit = 1e10f; + } +} + +void btSequentialImpulseConstraintSolver::setFrictionConstraintImpulse(btSolverConstraint& solverConstraint, + int solverBodyIdA, int solverBodyIdB, + btManifoldPoint& cp, const btContactSolverInfo& infoGlobal) +{ + { + btSolverConstraint& frictionConstraint1 = m_tmpSolverContactFrictionConstraintPool[solverConstraint.m_frictionIndex]; + + frictionConstraint1.m_appliedImpulse = 0.f; + } + + if ((infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS)) + { + btSolverConstraint& frictionConstraint2 = m_tmpSolverContactFrictionConstraintPool[solverConstraint.m_frictionIndex + 1]; + + frictionConstraint2.m_appliedImpulse = 0.f; + } +} + +void btSequentialImpulseConstraintSolver::convertContact(btPersistentManifold* manifold, const btContactSolverInfo& infoGlobal) +{ + btCollisionObject *colObj0 = 0, *colObj1 = 0; + + colObj0 = (btCollisionObject*)manifold->getBody0(); + colObj1 = (btCollisionObject*)manifold->getBody1(); + + int solverBodyIdA = getOrInitSolverBody(*colObj0, infoGlobal.m_timeStep); + int solverBodyIdB = getOrInitSolverBody(*colObj1, infoGlobal.m_timeStep); + + // btRigidBody* bodyA = btRigidBody::upcast(colObj0); + // btRigidBody* bodyB = btRigidBody::upcast(colObj1); + + btSolverBody* solverBodyA = &m_tmpSolverBodyPool[solverBodyIdA]; + btSolverBody* solverBodyB = &m_tmpSolverBodyPool[solverBodyIdB]; + + ///avoid collision response between two static objects + if (!solverBodyA || (solverBodyA->m_invMass.fuzzyZero() && (!solverBodyB || solverBodyB->m_invMass.fuzzyZero()))) + return; + + int rollingFriction = 1; + for (int j = 0; j < manifold->getNumContacts(); j++) + { + btManifoldPoint& cp = manifold->getContactPoint(j); + + if (cp.getDistance() <= manifold->getContactProcessingThreshold()) + { + btVector3 rel_pos1; + btVector3 rel_pos2; + btScalar relaxation; + + int frictionIndex = m_tmpSolverContactConstraintPool.size(); + btSolverConstraint& solverConstraint = m_tmpSolverContactConstraintPool.expandNonInitializing(); + solverConstraint.m_solverBodyIdA = solverBodyIdA; + solverConstraint.m_solverBodyIdB = solverBodyIdB; + + solverConstraint.m_originalContactPoint = &cp; + + const btVector3& pos1 = cp.getPositionWorldOnA(); + const btVector3& pos2 = cp.getPositionWorldOnB(); + + rel_pos1 = pos1 - colObj0->getWorldTransform().getOrigin(); + rel_pos2 = pos2 - colObj1->getWorldTransform().getOrigin(); + + btVector3 vel1; + btVector3 vel2; + + solverBodyA->getVelocityInLocalPointNoDelta(rel_pos1, vel1); + solverBodyB->getVelocityInLocalPointNoDelta(rel_pos2, vel2); + + btVector3 vel = vel1 - vel2; + btScalar rel_vel = cp.m_normalWorldOnB.dot(vel); + + setupContactConstraint(solverConstraint, solverBodyIdA, solverBodyIdB, cp, infoGlobal, relaxation, rel_pos1, rel_pos2); + + /////setup the friction constraints + + solverConstraint.m_frictionIndex = m_tmpSolverContactFrictionConstraintPool.size(); + + if ((cp.m_combinedRollingFriction > 0.f) && (rollingFriction > 0)) + { + { + addTorsionalFrictionConstraint(cp.m_normalWorldOnB, solverBodyIdA, solverBodyIdB, frictionIndex, cp, cp.m_combinedSpinningFriction, rel_pos1, rel_pos2, colObj0, colObj1, relaxation); + btVector3 axis0, axis1; + btPlaneSpace1(cp.m_normalWorldOnB, axis0, axis1); + axis0.normalize(); + axis1.normalize(); + + applyAnisotropicFriction(colObj0, axis0, btCollisionObject::CF_ANISOTROPIC_ROLLING_FRICTION); + applyAnisotropicFriction(colObj1, axis0, btCollisionObject::CF_ANISOTROPIC_ROLLING_FRICTION); + applyAnisotropicFriction(colObj0, axis1, btCollisionObject::CF_ANISOTROPIC_ROLLING_FRICTION); + applyAnisotropicFriction(colObj1, axis1, btCollisionObject::CF_ANISOTROPIC_ROLLING_FRICTION); + if (axis0.length() > 0.001) + addTorsionalFrictionConstraint(axis0, solverBodyIdA, solverBodyIdB, frictionIndex, cp, + cp.m_combinedRollingFriction, rel_pos1, rel_pos2, colObj0, colObj1, relaxation); + if (axis1.length() > 0.001) + addTorsionalFrictionConstraint(axis1, solverBodyIdA, solverBodyIdB, frictionIndex, cp, + cp.m_combinedRollingFriction, rel_pos1, rel_pos2, colObj0, colObj1, relaxation); + } + } + + ///Bullet has several options to set the friction directions + ///By default, each contact has only a single friction direction that is recomputed automatically very frame + ///based on the relative linear velocity. + ///If the relative velocity it zero, it will automatically compute a friction direction. + + ///You can also enable two friction directions, using the SOLVER_USE_2_FRICTION_DIRECTIONS. + ///In that case, the second friction direction will be orthogonal to both contact normal and first friction direction. + /// + ///If you choose SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION, then the friction will be independent from the relative projected velocity. + /// + ///The user can manually override the friction directions for certain contacts using a contact callback, + ///and use contactPoint.m_contactPointFlags |= BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED + ///In that case, you can set the target relative motion in each friction direction (cp.m_contactMotion1 and cp.m_contactMotion2) + ///this will give a conveyor belt effect + /// + + if (!(infoGlobal.m_solverMode & SOLVER_ENABLE_FRICTION_DIRECTION_CACHING) || !(cp.m_contactPointFlags & BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED)) + { + cp.m_lateralFrictionDir1 = vel - cp.m_normalWorldOnB * rel_vel; + btScalar lat_rel_vel = cp.m_lateralFrictionDir1.length2(); + if (!(infoGlobal.m_solverMode & SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION) && lat_rel_vel > SIMD_EPSILON) + { + cp.m_lateralFrictionDir1 *= 1.f / btSqrt(lat_rel_vel); + applyAnisotropicFriction(colObj0, cp.m_lateralFrictionDir1, btCollisionObject::CF_ANISOTROPIC_FRICTION); + applyAnisotropicFriction(colObj1, cp.m_lateralFrictionDir1, btCollisionObject::CF_ANISOTROPIC_FRICTION); + addFrictionConstraint(cp.m_lateralFrictionDir1, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal); + + if ((infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS)) + { + cp.m_lateralFrictionDir2 = cp.m_lateralFrictionDir1.cross(cp.m_normalWorldOnB); + cp.m_lateralFrictionDir2.normalize(); //?? + applyAnisotropicFriction(colObj0, cp.m_lateralFrictionDir2, btCollisionObject::CF_ANISOTROPIC_FRICTION); + applyAnisotropicFriction(colObj1, cp.m_lateralFrictionDir2, btCollisionObject::CF_ANISOTROPIC_FRICTION); + addFrictionConstraint(cp.m_lateralFrictionDir2, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal); + } + } + else + { + btPlaneSpace1(cp.m_normalWorldOnB, cp.m_lateralFrictionDir1, cp.m_lateralFrictionDir2); + + applyAnisotropicFriction(colObj0, cp.m_lateralFrictionDir1, btCollisionObject::CF_ANISOTROPIC_FRICTION); + applyAnisotropicFriction(colObj1, cp.m_lateralFrictionDir1, btCollisionObject::CF_ANISOTROPIC_FRICTION); + addFrictionConstraint(cp.m_lateralFrictionDir1, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal); + + if ((infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS)) + { + applyAnisotropicFriction(colObj0, cp.m_lateralFrictionDir2, btCollisionObject::CF_ANISOTROPIC_FRICTION); + applyAnisotropicFriction(colObj1, cp.m_lateralFrictionDir2, btCollisionObject::CF_ANISOTROPIC_FRICTION); + addFrictionConstraint(cp.m_lateralFrictionDir2, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal); + } + + if ((infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS) && (infoGlobal.m_solverMode & SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION)) + { + cp.m_contactPointFlags |= BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED; + } + } + } + else + { + addFrictionConstraint(cp.m_lateralFrictionDir1, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal, cp.m_contactMotion1, cp.m_frictionCFM); + + if ((infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS)) + addFrictionConstraint(cp.m_lateralFrictionDir2, solverBodyIdA, solverBodyIdB, frictionIndex, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal, cp.m_contactMotion2, cp.m_frictionCFM); + } + setFrictionConstraintImpulse(solverConstraint, solverBodyIdA, solverBodyIdB, cp, infoGlobal); + } + } + } + +void btSequentialImpulseConstraintSolver::convertContacts(btPersistentManifold** manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal) +{ + int i; + btPersistentManifold* manifold = 0; + // btCollisionObject* colObj0=0,*colObj1=0; + + for (i = 0; i < numManifolds; i++) + { + manifold = manifoldPtr[i]; + convertContact(manifold, infoGlobal); + } +} + +void btSequentialImpulseConstraintSolver::convertJoint(btSolverConstraint* currentConstraintRow, + btTypedConstraint* constraint, + const btTypedConstraint::btConstraintInfo1& info1, + int solverBodyIdA, + int solverBodyIdB, + const btContactSolverInfo& infoGlobal) +{ + const btRigidBody& rbA = constraint->getRigidBodyA(); + const btRigidBody& rbB = constraint->getRigidBodyB(); + + const btSolverBody* bodyAPtr = &m_tmpSolverBodyPool[solverBodyIdA]; + const btSolverBody* bodyBPtr = &m_tmpSolverBodyPool[solverBodyIdB]; + + int overrideNumSolverIterations = constraint->getOverrideNumSolverIterations() > 0 ? constraint->getOverrideNumSolverIterations() : infoGlobal.m_numIterations; + if (overrideNumSolverIterations > m_maxOverrideNumSolverIterations) + m_maxOverrideNumSolverIterations = overrideNumSolverIterations; + + for (int j = 0; j < info1.m_numConstraintRows; j++) + { + memset(¤tConstraintRow[j], 0, sizeof(btSolverConstraint)); + currentConstraintRow[j].m_lowerLimit = -SIMD_INFINITY; + currentConstraintRow[j].m_upperLimit = SIMD_INFINITY; + currentConstraintRow[j].m_appliedImpulse = 0.f; + currentConstraintRow[j].m_appliedPushImpulse = 0.f; + currentConstraintRow[j].m_solverBodyIdA = solverBodyIdA; + currentConstraintRow[j].m_solverBodyIdB = solverBodyIdB; + currentConstraintRow[j].m_overrideNumSolverIterations = overrideNumSolverIterations; + } + + // these vectors are already cleared in initSolverBody, no need to redundantly clear again + btAssert(bodyAPtr->getDeltaLinearVelocity().isZero()); + btAssert(bodyAPtr->getDeltaAngularVelocity().isZero()); + btAssert(bodyAPtr->getPushVelocity().isZero()); + btAssert(bodyAPtr->getTurnVelocity().isZero()); + btAssert(bodyBPtr->getDeltaLinearVelocity().isZero()); + btAssert(bodyBPtr->getDeltaAngularVelocity().isZero()); + btAssert(bodyBPtr->getPushVelocity().isZero()); + btAssert(bodyBPtr->getTurnVelocity().isZero()); + //bodyAPtr->internalGetDeltaLinearVelocity().setValue(0.f,0.f,0.f); + //bodyAPtr->internalGetDeltaAngularVelocity().setValue(0.f,0.f,0.f); + //bodyAPtr->internalGetPushVelocity().setValue(0.f,0.f,0.f); + //bodyAPtr->internalGetTurnVelocity().setValue(0.f,0.f,0.f); + //bodyBPtr->internalGetDeltaLinearVelocity().setValue(0.f,0.f,0.f); + //bodyBPtr->internalGetDeltaAngularVelocity().setValue(0.f,0.f,0.f); + //bodyBPtr->internalGetPushVelocity().setValue(0.f,0.f,0.f); + //bodyBPtr->internalGetTurnVelocity().setValue(0.f,0.f,0.f); + + btTypedConstraint::btConstraintInfo2 info2; + info2.fps = 1.f / infoGlobal.m_timeStep; + info2.erp = infoGlobal.m_erp; + info2.m_J1linearAxis = currentConstraintRow->m_contactNormal1; + info2.m_J1angularAxis = currentConstraintRow->m_relpos1CrossNormal; + info2.m_J2linearAxis = currentConstraintRow->m_contactNormal2; + info2.m_J2angularAxis = currentConstraintRow->m_relpos2CrossNormal; + info2.rowskip = sizeof(btSolverConstraint) / sizeof(btScalar); //check this + ///the size of btSolverConstraint needs be a multiple of btScalar + btAssert(info2.rowskip * sizeof(btScalar) == sizeof(btSolverConstraint)); + info2.m_constraintError = ¤tConstraintRow->m_rhs; + currentConstraintRow->m_cfm = infoGlobal.m_globalCfm; + info2.m_damping = infoGlobal.m_damping; + info2.cfm = ¤tConstraintRow->m_cfm; + info2.m_lowerLimit = ¤tConstraintRow->m_lowerLimit; + info2.m_upperLimit = ¤tConstraintRow->m_upperLimit; + info2.m_numIterations = infoGlobal.m_numIterations; + constraint->getInfo2(&info2); + + ///finalize the constraint setup + for (int j = 0; j < info1.m_numConstraintRows; j++) + { + btSolverConstraint& solverConstraint = currentConstraintRow[j]; + + if (solverConstraint.m_upperLimit >= constraint->getBreakingImpulseThreshold()) + { + solverConstraint.m_upperLimit = constraint->getBreakingImpulseThreshold(); + } + + if (solverConstraint.m_lowerLimit <= -constraint->getBreakingImpulseThreshold()) + { + solverConstraint.m_lowerLimit = -constraint->getBreakingImpulseThreshold(); + } + + solverConstraint.m_originalContactPoint = constraint; + + { + const btVector3& ftorqueAxis1 = solverConstraint.m_relpos1CrossNormal; + solverConstraint.m_angularComponentA = constraint->getRigidBodyA().getInvInertiaTensorWorld() * ftorqueAxis1 * constraint->getRigidBodyA().getAngularFactor(); + } + { + const btVector3& ftorqueAxis2 = solverConstraint.m_relpos2CrossNormal; + solverConstraint.m_angularComponentB = constraint->getRigidBodyB().getInvInertiaTensorWorld() * ftorqueAxis2 * constraint->getRigidBodyB().getAngularFactor(); + } + + { + btVector3 iMJlA = solverConstraint.m_contactNormal1 * rbA.getInvMass(); + btVector3 iMJaA = rbA.getInvInertiaTensorWorld() * solverConstraint.m_relpos1CrossNormal; + btVector3 iMJlB = solverConstraint.m_contactNormal2 * rbB.getInvMass(); //sign of normal? + btVector3 iMJaB = rbB.getInvInertiaTensorWorld() * solverConstraint.m_relpos2CrossNormal; + + btScalar sum = iMJlA.dot(solverConstraint.m_contactNormal1); + sum += iMJaA.dot(solverConstraint.m_relpos1CrossNormal); + sum += iMJlB.dot(solverConstraint.m_contactNormal2); + sum += iMJaB.dot(solverConstraint.m_relpos2CrossNormal); + btScalar fsum = btFabs(sum); + btAssert(fsum > SIMD_EPSILON); + btScalar sorRelaxation = 1.f; //todo: get from globalInfo? + solverConstraint.m_jacDiagABInv = fsum > SIMD_EPSILON ? sorRelaxation / sum : 0.f; + } + + { + btScalar rel_vel; + btVector3 externalForceImpulseA = bodyAPtr->m_originalBody ? bodyAPtr->m_externalForceImpulse : btVector3(0, 0, 0); + btVector3 externalTorqueImpulseA = bodyAPtr->m_originalBody ? bodyAPtr->m_externalTorqueImpulse : btVector3(0, 0, 0); + + btVector3 externalForceImpulseB = bodyBPtr->m_originalBody ? bodyBPtr->m_externalForceImpulse : btVector3(0, 0, 0); + btVector3 externalTorqueImpulseB = bodyBPtr->m_originalBody ? bodyBPtr->m_externalTorqueImpulse : btVector3(0, 0, 0); + + btScalar vel1Dotn = solverConstraint.m_contactNormal1.dot(rbA.getLinearVelocity() + externalForceImpulseA) + solverConstraint.m_relpos1CrossNormal.dot(rbA.getAngularVelocity() + externalTorqueImpulseA); + + btScalar vel2Dotn = solverConstraint.m_contactNormal2.dot(rbB.getLinearVelocity() + externalForceImpulseB) + solverConstraint.m_relpos2CrossNormal.dot(rbB.getAngularVelocity() + externalTorqueImpulseB); + + rel_vel = vel1Dotn + vel2Dotn; + btScalar restitution = 0.f; + btScalar positionalError = solverConstraint.m_rhs; //already filled in by getConstraintInfo2 + btScalar velocityError = restitution - rel_vel * info2.m_damping; + btScalar penetrationImpulse = positionalError * solverConstraint.m_jacDiagABInv; + btScalar velocityImpulse = velocityError * solverConstraint.m_jacDiagABInv; + solverConstraint.m_rhs = penetrationImpulse + velocityImpulse; + solverConstraint.m_appliedImpulse = 0.f; + } + } +} + +void btSequentialImpulseConstraintSolver::convertJoints(btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal) +{ +//\1("convertJoints"); + for (int j = 0; j < numConstraints; j++) + { + btTypedConstraint* constraint = constraints[j]; + constraint->buildJacobian(); + constraint->internalSetAppliedImpulse(0.0f); + } + + int totalNumRows = 0; + + m_tmpConstraintSizesPool.resizeNoInitialize(numConstraints); + //calculate the total number of contraint rows + for (int i = 0; i < numConstraints; i++) + { + btTypedConstraint::btConstraintInfo1& info1 = m_tmpConstraintSizesPool[i]; + btJointFeedback* fb = constraints[i]->getJointFeedback(); + if (fb) + { + fb->m_appliedForceBodyA.setZero(); + fb->m_appliedTorqueBodyA.setZero(); + fb->m_appliedForceBodyB.setZero(); + fb->m_appliedTorqueBodyB.setZero(); + } + + if (constraints[i]->isEnabled()) + { + constraints[i]->getInfo1(&info1); + } + else + { + info1.m_numConstraintRows = 0; + info1.nub = 0; + } + totalNumRows += info1.m_numConstraintRows; + } + m_tmpSolverNonContactConstraintPool.resizeNoInitialize(totalNumRows); + + ///setup the btSolverConstraints + int currentRow = 0; + + for (int i = 0; i < numConstraints; i++) + { + const btTypedConstraint::btConstraintInfo1& info1 = m_tmpConstraintSizesPool[i]; + + if (info1.m_numConstraintRows) + { + btAssert(currentRow < totalNumRows); + + btSolverConstraint* currentConstraintRow = &m_tmpSolverNonContactConstraintPool[currentRow]; + btTypedConstraint* constraint = constraints[i]; + btRigidBody& rbA = constraint->getRigidBodyA(); + btRigidBody& rbB = constraint->getRigidBodyB(); + + int solverBodyIdA = getOrInitSolverBody(rbA, infoGlobal.m_timeStep); + int solverBodyIdB = getOrInitSolverBody(rbB, infoGlobal.m_timeStep); + + convertJoint(currentConstraintRow, constraint, info1, solverBodyIdA, solverBodyIdB, infoGlobal); + } + currentRow += info1.m_numConstraintRows; + } +} + +void btSequentialImpulseConstraintSolver::convertBodies(btCollisionObject** bodies, int numBodies, const btContactSolverInfo& infoGlobal) +{ +//\1("convertBodies"); + for (int i = 0; i < numBodies; i++) + { + bodies[i]->setCompanionId(-1); + } +#if BT_THREADSAFE + m_kinematicBodyUniqueIdToSolverBodyTable.resize(0); +#endif // BT_THREADSAFE + + m_tmpSolverBodyPool.reserve(numBodies + 1); + m_tmpSolverBodyPool.resize(0); + + //btSolverBody& fixedBody = m_tmpSolverBodyPool.expand(); + //initSolverBody(&fixedBody,0); + + for (int i = 0; i < numBodies; i++) + { + int bodyId = getOrInitSolverBody(*bodies[i], infoGlobal.m_timeStep); + + btRigidBody* body = btRigidBody::upcast(bodies[i]); + if (body && body->getInvMass()) + { + btSolverBody& solverBody = m_tmpSolverBodyPool[bodyId]; + btVector3 gyroForce(0, 0, 0); + if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT) + { + gyroForce = body->computeGyroscopicForceExplicit(infoGlobal.m_maxGyroscopicForce); + solverBody.m_externalTorqueImpulse -= gyroForce * body->getInvInertiaTensorWorld() * infoGlobal.m_timeStep; + } + if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD) + { + gyroForce = body->computeGyroscopicImpulseImplicit_World(infoGlobal.m_timeStep); + solverBody.m_externalTorqueImpulse += gyroForce; + } + if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY) + { + gyroForce = body->computeGyroscopicImpulseImplicit_Body(infoGlobal.m_timeStep); + solverBody.m_externalTorqueImpulse += gyroForce; + } + } + } +} + +btScalar btSequentialImpulseConstraintSolver::solveGroupCacheFriendlySetup(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) +{ + m_fixedBodyId = -1; +//\1("solveGroupCacheFriendlySetup"); + (void)debugDrawer; + + // if solver mode has changed, + if (infoGlobal.m_solverMode != m_cachedSolverMode) + { + // update solver functions to use SIMD or non-SIMD + bool useSimd = !!(infoGlobal.m_solverMode & SOLVER_SIMD); + setupSolverFunctions(useSimd); + m_cachedSolverMode = infoGlobal.m_solverMode; + } + m_maxOverrideNumSolverIterations = 0; + +#ifdef BT_ADDITIONAL_DEBUG + //make sure that dynamic bodies exist for all (enabled) constraints + for (int i = 0; i < numConstraints; i++) + { + btTypedConstraint* constraint = constraints[i]; + if (constraint->isEnabled()) + { + if (!constraint->getRigidBodyA().isStaticOrKinematicObject()) + { + bool found = false; + for (int b = 0; b < numBodies; b++) + { + if (&constraint->getRigidBodyA() == bodies[b]) + { + found = true; + break; + } + } + btAssert(found); + } + if (!constraint->getRigidBodyB().isStaticOrKinematicObject()) + { + bool found = false; + for (int b = 0; b < numBodies; b++) + { + if (&constraint->getRigidBodyB() == bodies[b]) + { + found = true; + break; + } + } + btAssert(found); + } + } + } + //make sure that dynamic bodies exist for all contact manifolds + for (int i = 0; i < numManifolds; i++) + { + if (!manifoldPtr[i]->getBody0()->isStaticOrKinematicObject()) + { + bool found = false; + for (int b = 0; b < numBodies; b++) + { + if (manifoldPtr[i]->getBody0() == bodies[b]) + { + found = true; + break; + } + } + btAssert(found); + } + if (!manifoldPtr[i]->getBody1()->isStaticOrKinematicObject()) + { + bool found = false; + for (int b = 0; b < numBodies; b++) + { + if (manifoldPtr[i]->getBody1() == bodies[b]) + { + found = true; + break; + } + } + btAssert(found); + } + } +#endif //BT_ADDITIONAL_DEBUG + + //convert all bodies + convertBodies(bodies, numBodies, infoGlobal); + + convertJoints(constraints, numConstraints, infoGlobal); + + convertContacts(manifoldPtr, numManifolds, infoGlobal); + + // btContactSolverInfo info = infoGlobal; + + int numNonContactPool = m_tmpSolverNonContactConstraintPool.size(); + int numConstraintPool = m_tmpSolverContactConstraintPool.size(); + int numFrictionPool = m_tmpSolverContactFrictionConstraintPool.size(); + + ///@todo: use stack allocator for such temporarily memory, same for solver bodies/constraints + m_orderNonContactConstraintPool.resizeNoInitialize(numNonContactPool); + if ((infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS)) + m_orderTmpConstraintPool.resizeNoInitialize(numConstraintPool * 2); + else + m_orderTmpConstraintPool.resizeNoInitialize(numConstraintPool); + + m_orderFrictionConstraintPool.resizeNoInitialize(numFrictionPool); + { + int i; + for (i = 0; i < numNonContactPool; i++) + { + m_orderNonContactConstraintPool[i] = i; + } + for (i = 0; i < numConstraintPool; i++) + { + m_orderTmpConstraintPool[i] = i; + } + for (i = 0; i < numFrictionPool; i++) + { + m_orderFrictionConstraintPool[i] = i; + } + } + + return 0.f; +} + +btScalar btSequentialImpulseConstraintSolver::solveSingleIteration(int iteration, btCollisionObject** /*bodies */, int /*numBodies*/, btPersistentManifold** /*manifoldPtr*/, int /*numManifolds*/, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* /*debugDrawer*/) +{ +//\1("solveSingleIteration"); + btScalar leastSquaresResidual = 0.f; + + int numNonContactPool = m_tmpSolverNonContactConstraintPool.size(); + int numConstraintPool = m_tmpSolverContactConstraintPool.size(); + int numFrictionPool = m_tmpSolverContactFrictionConstraintPool.size(); + + if (infoGlobal.m_solverMode & SOLVER_RANDMIZE_ORDER) + { + if (1) // uncomment this for a bit less random ((iteration & 7) == 0) + { + for (int j = 0; j < numNonContactPool; ++j) + { + int tmp = m_orderNonContactConstraintPool[j]; + int swapi = btRandInt2(j + 1); + m_orderNonContactConstraintPool[j] = m_orderNonContactConstraintPool[swapi]; + m_orderNonContactConstraintPool[swapi] = tmp; + } + + //contact/friction constraints are not solved more than + if (iteration < infoGlobal.m_numIterations) + { + for (int j = 0; j < numConstraintPool; ++j) + { + int tmp = m_orderTmpConstraintPool[j]; + int swapi = btRandInt2(j + 1); + m_orderTmpConstraintPool[j] = m_orderTmpConstraintPool[swapi]; + m_orderTmpConstraintPool[swapi] = tmp; + } + + for (int j = 0; j < numFrictionPool; ++j) + { + int tmp = m_orderFrictionConstraintPool[j]; + int swapi = btRandInt2(j + 1); + m_orderFrictionConstraintPool[j] = m_orderFrictionConstraintPool[swapi]; + m_orderFrictionConstraintPool[swapi] = tmp; + } + } + } + } + + ///solve all joint constraints + for (int j = 0; j < m_tmpSolverNonContactConstraintPool.size(); j++) + { + btSolverConstraint& constraint = m_tmpSolverNonContactConstraintPool[m_orderNonContactConstraintPool[j]]; + if (iteration < constraint.m_overrideNumSolverIterations) + { + btScalar residual = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[constraint.m_solverBodyIdA], m_tmpSolverBodyPool[constraint.m_solverBodyIdB], constraint); + leastSquaresResidual = btMax(leastSquaresResidual, residual * residual); + } + } + + if (iteration < infoGlobal.m_numIterations) + { + for (int j = 0; j < numConstraints; j++) + { + if (constraints[j]->isEnabled()) + { + int bodyAid = getOrInitSolverBody(constraints[j]->getRigidBodyA(), infoGlobal.m_timeStep); + int bodyBid = getOrInitSolverBody(constraints[j]->getRigidBodyB(), infoGlobal.m_timeStep); + btSolverBody& bodyA = m_tmpSolverBodyPool[bodyAid]; + btSolverBody& bodyB = m_tmpSolverBodyPool[bodyBid]; + constraints[j]->solveConstraintObsolete(bodyA, bodyB, infoGlobal.m_timeStep); + } + } + + ///solve all contact constraints + if (infoGlobal.m_solverMode & SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS) + { + int numPoolConstraints = m_tmpSolverContactConstraintPool.size(); + int multiplier = (infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS) ? 2 : 1; + + for (int c = 0; c < numPoolConstraints; c++) + { + btScalar totalImpulse = 0; + + { + const btSolverConstraint& solveManifold = m_tmpSolverContactConstraintPool[m_orderTmpConstraintPool[c]]; + btScalar residual = resolveSingleConstraintRowLowerLimit(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + leastSquaresResidual = btMax(leastSquaresResidual, residual * residual); + + totalImpulse = solveManifold.m_appliedImpulse; + } + bool applyFriction = true; + if (applyFriction) + { + { + btSolverConstraint& solveManifold = m_tmpSolverContactFrictionConstraintPool[m_orderFrictionConstraintPool[c * multiplier]]; + + if (totalImpulse > btScalar(0)) + { + solveManifold.m_lowerLimit = -(solveManifold.m_friction * totalImpulse); + solveManifold.m_upperLimit = solveManifold.m_friction * totalImpulse; + + btScalar residual = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + leastSquaresResidual = btMax(leastSquaresResidual, residual * residual); + } + } + + if (infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS) + { + btSolverConstraint& solveManifold = m_tmpSolverContactFrictionConstraintPool[m_orderFrictionConstraintPool[c * multiplier + 1]]; + + if (totalImpulse > btScalar(0)) + { + solveManifold.m_lowerLimit = -(solveManifold.m_friction * totalImpulse); + solveManifold.m_upperLimit = solveManifold.m_friction * totalImpulse; + + btScalar residual = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + leastSquaresResidual = btMax(leastSquaresResidual, residual * residual); + } + } + } + } + } + else //SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS + { + //solve the friction constraints after all contact constraints, don't interleave them + int numPoolConstraints = m_tmpSolverContactConstraintPool.size(); + int j; + + for (j = 0; j < numPoolConstraints; j++) + { + const btSolverConstraint& solveManifold = m_tmpSolverContactConstraintPool[m_orderTmpConstraintPool[j]]; + btScalar residual = resolveSingleConstraintRowLowerLimit(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + leastSquaresResidual = btMax(leastSquaresResidual, residual * residual); + } + + ///solve all friction constraints + + int numFrictionPoolConstraints = m_tmpSolverContactFrictionConstraintPool.size(); + for (j = 0; j < numFrictionPoolConstraints; j++) + { + btSolverConstraint& solveManifold = m_tmpSolverContactFrictionConstraintPool[m_orderFrictionConstraintPool[j]]; + btScalar totalImpulse = m_tmpSolverContactConstraintPool[solveManifold.m_frictionIndex].m_appliedImpulse; + + if (totalImpulse > btScalar(0)) + { + solveManifold.m_lowerLimit = -(solveManifold.m_friction * totalImpulse); + solveManifold.m_upperLimit = solveManifold.m_friction * totalImpulse; + + btScalar residual = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + leastSquaresResidual = btMax(leastSquaresResidual, residual * residual); + } + } + } + + int numRollingFrictionPoolConstraints = m_tmpSolverContactRollingFrictionConstraintPool.size(); + for (int j = 0; j < numRollingFrictionPoolConstraints; j++) + { + btSolverConstraint& rollingFrictionConstraint = m_tmpSolverContactRollingFrictionConstraintPool[j]; + btScalar totalImpulse = m_tmpSolverContactConstraintPool[rollingFrictionConstraint.m_frictionIndex].m_appliedImpulse; + if (totalImpulse > btScalar(0)) + { + btScalar rollingFrictionMagnitude = rollingFrictionConstraint.m_friction * totalImpulse; + if (rollingFrictionMagnitude > rollingFrictionConstraint.m_friction) + rollingFrictionMagnitude = rollingFrictionConstraint.m_friction; + + rollingFrictionConstraint.m_lowerLimit = -rollingFrictionMagnitude; + rollingFrictionConstraint.m_upperLimit = rollingFrictionMagnitude; + + btScalar residual = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[rollingFrictionConstraint.m_solverBodyIdA], m_tmpSolverBodyPool[rollingFrictionConstraint.m_solverBodyIdB], rollingFrictionConstraint); + leastSquaresResidual = btMax(leastSquaresResidual, residual * residual); + } + } + } + return leastSquaresResidual; +} + +void btSequentialImpulseConstraintSolver::solveGroupCacheFriendlySplitImpulseIterations(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) +{ +//\1("solveGroupCacheFriendlySplitImpulseIterations"); + int iteration; + if (infoGlobal.m_splitImpulse) + { + { + for (iteration = 0; iteration < infoGlobal.m_numIterations; iteration++) + { + btScalar leastSquaresResidual = 0.f; + { + int numPoolConstraints = m_tmpSolverContactConstraintPool.size(); + int j; + for (j = 0; j < numPoolConstraints; j++) + { + const btSolverConstraint& solveManifold = m_tmpSolverContactConstraintPool[m_orderTmpConstraintPool[j]]; + + btScalar residual = resolveSplitPenetrationImpulse(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + leastSquaresResidual = btMax(leastSquaresResidual, residual * residual); + } + } + if (leastSquaresResidual <= infoGlobal.m_leastSquaresResidualThreshold || iteration >= (infoGlobal.m_numIterations - 1)) + { +#ifdef VERBOSE_RESIDUAL_PRINTF + printf("residual = %f at iteration #%d\n", leastSquaresResidual, iteration); +#endif + break; + } + } + } + } +} + +btScalar btSequentialImpulseConstraintSolver::solveGroupCacheFriendlyIterations(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) +{ +//\1("solveGroupCacheFriendlyIterations"); + + { + ///this is a special step to resolve penetrations (just for contacts) + solveGroupCacheFriendlySplitImpulseIterations(bodies, numBodies, manifoldPtr, numManifolds, constraints, numConstraints, infoGlobal, debugDrawer); + + int maxIterations = m_maxOverrideNumSolverIterations > infoGlobal.m_numIterations ? m_maxOverrideNumSolverIterations : infoGlobal.m_numIterations; + + for (int iteration = 0; iteration < maxIterations; iteration++) + //for ( int iteration = maxIterations-1 ; iteration >= 0;iteration--) + { + m_leastSquaresResidual = solveSingleIteration(iteration, bodies, numBodies, manifoldPtr, numManifolds, constraints, numConstraints, infoGlobal, debugDrawer); + + if (m_leastSquaresResidual <= infoGlobal.m_leastSquaresResidualThreshold || (iteration >= (maxIterations - 1))) + { +#ifdef VERBOSE_RESIDUAL_PRINTF + printf("residual = %f at iteration #%d\n", m_leastSquaresResidual, iteration); +#endif + m_analyticsData.m_numSolverCalls++; + m_analyticsData.m_numIterationsUsed = iteration+1; + m_analyticsData.m_islandId = -2; + if (numBodies>0) + m_analyticsData.m_islandId = bodies[0]->getCompanionId(); + m_analyticsData.m_numBodies = numBodies; + m_analyticsData.m_numContactManifolds = numManifolds; + m_analyticsData.m_remainingLeastSquaresResidual = m_leastSquaresResidual; + break; + } + } + } + return 0.f; +} + +void btSequentialImpulseConstraintSolver::writeBackContacts(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal) +{ + for (int j = iBegin; j < iEnd; j++) + { + const btSolverConstraint& solveManifold = m_tmpSolverContactConstraintPool[j]; + btManifoldPoint* pt = (btManifoldPoint*)solveManifold.m_originalContactPoint; + btAssert(pt); + pt->m_appliedImpulse = solveManifold.m_appliedImpulse; + // float f = m_tmpSolverContactFrictionConstraintPool[solveManifold.m_frictionIndex].m_appliedImpulse; + // printf("pt->m_appliedImpulseLateral1 = %f\n", f); + pt->m_appliedImpulseLateral1 = m_tmpSolverContactFrictionConstraintPool[solveManifold.m_frictionIndex].m_appliedImpulse; + //printf("pt->m_appliedImpulseLateral1 = %f\n", pt->m_appliedImpulseLateral1); + if ((infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS)) + { + pt->m_appliedImpulseLateral2 = m_tmpSolverContactFrictionConstraintPool[solveManifold.m_frictionIndex + 1].m_appliedImpulse; + } + //do a callback here? + } +} + +void btSequentialImpulseConstraintSolver::writeBackJoints(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal) +{ + for (int j = iBegin; j < iEnd; j++) + { + const btSolverConstraint& solverConstr = m_tmpSolverNonContactConstraintPool[j]; + btTypedConstraint* constr = (btTypedConstraint*)solverConstr.m_originalContactPoint; + btJointFeedback* fb = constr->getJointFeedback(); + if (fb) + { + fb->m_appliedForceBodyA += solverConstr.m_contactNormal1 * solverConstr.m_appliedImpulse * constr->getRigidBodyA().getLinearFactor() / infoGlobal.m_timeStep; + fb->m_appliedForceBodyB += solverConstr.m_contactNormal2 * solverConstr.m_appliedImpulse * constr->getRigidBodyB().getLinearFactor() / infoGlobal.m_timeStep; + fb->m_appliedTorqueBodyA += solverConstr.m_relpos1CrossNormal * constr->getRigidBodyA().getAngularFactor() * solverConstr.m_appliedImpulse / infoGlobal.m_timeStep; + fb->m_appliedTorqueBodyB += solverConstr.m_relpos2CrossNormal * constr->getRigidBodyB().getAngularFactor() * solverConstr.m_appliedImpulse / infoGlobal.m_timeStep; /*RGM ???? */ + } + + constr->internalSetAppliedImpulse(solverConstr.m_appliedImpulse); + if (btFabs(solverConstr.m_appliedImpulse) >= constr->getBreakingImpulseThreshold()) + { + constr->setEnabled(false); + } + } +} + +void btSequentialImpulseConstraintSolver::writeBackBodies(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal) +{ + for (int i = iBegin; i < iEnd; i++) + { + btRigidBody* body = m_tmpSolverBodyPool[i].m_originalBody; + if (body) + { + if (infoGlobal.m_splitImpulse) + m_tmpSolverBodyPool[i].writebackVelocityAndTransform(infoGlobal.m_timeStep, infoGlobal.m_splitImpulseTurnErp); + else + m_tmpSolverBodyPool[i].writebackVelocity(); + + m_tmpSolverBodyPool[i].m_originalBody->setLinearVelocity( + m_tmpSolverBodyPool[i].m_linearVelocity + + m_tmpSolverBodyPool[i].m_externalForceImpulse); + + m_tmpSolverBodyPool[i].m_originalBody->setAngularVelocity( + m_tmpSolverBodyPool[i].m_angularVelocity + + m_tmpSolverBodyPool[i].m_externalTorqueImpulse); + + if (infoGlobal.m_splitImpulse) + m_tmpSolverBodyPool[i].m_originalBody->setWorldTransform(m_tmpSolverBodyPool[i].m_worldTransform); + + m_tmpSolverBodyPool[i].m_originalBody->setCompanionId(-1); + } + } +} + +btScalar btSequentialImpulseConstraintSolver::solveGroupCacheFriendlyFinish(btCollisionObject** bodies, int numBodies, const btContactSolverInfo& infoGlobal) +{ +//\1("solveGroupCacheFriendlyFinish"); + + if (infoGlobal.m_solverMode & SOLVER_USE_WARMSTARTING) + { + writeBackContacts(0, m_tmpSolverContactConstraintPool.size(), infoGlobal); + } + + writeBackJoints(0, m_tmpSolverNonContactConstraintPool.size(), infoGlobal); + writeBackBodies(0, m_tmpSolverBodyPool.size(), infoGlobal); + + m_tmpSolverContactConstraintPool.resizeNoInitialize(0); + m_tmpSolverNonContactConstraintPool.resizeNoInitialize(0); + m_tmpSolverContactFrictionConstraintPool.resizeNoInitialize(0); + m_tmpSolverContactRollingFrictionConstraintPool.resizeNoInitialize(0); + + m_tmpSolverBodyPool.resizeNoInitialize(0); + return 0.f; +} + +/// btSequentialImpulseConstraintSolver Sequentially applies impulses +btScalar btSequentialImpulseConstraintSolver::solveGroup(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer, btDispatcher* /*dispatcher*/) +{ +//\1("solveGroup"); + //you need to provide at least some bodies + + solveGroupCacheFriendlySetup(bodies, numBodies, manifoldPtr, numManifolds, constraints, numConstraints, infoGlobal, debugDrawer); + + solveGroupCacheFriendlyIterations(bodies, numBodies, manifoldPtr, numManifolds, constraints, numConstraints, infoGlobal, debugDrawer); + + solveGroupCacheFriendlyFinish(bodies, numBodies, infoGlobal); + + return 0.f; +} + +void btSequentialImpulseConstraintSolver::reset() +{ + m_btSeed2 = 0; +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp.i new file mode 100644 index 00000000..9f3ae13f --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp ---------------- + +// %include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h new file mode 100644 index 00000000..d9b3dbcd --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h @@ -0,0 +1,215 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H +#define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H + +class btIDebugDraw; +class btPersistentManifold; +class btDispatcher; +class btCollisionObject; +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" +#include "BulletDynamics/ConstraintSolver/btSolverBody.h" +#include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" +#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" +#include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" + +typedef btScalar (*btSingleConstraintRowSolver)(btSolverBody&, btSolverBody&, const btSolverConstraint&); + +struct btSolverAnalyticsData +{ + btSolverAnalyticsData() + { + m_numSolverCalls = 0; + m_numIterationsUsed = -1; + m_remainingLeastSquaresResidual = -1; + m_islandId = -2; + } + int m_islandId; + int m_numBodies; + int m_numContactManifolds; + int m_numSolverCalls; + int m_numIterationsUsed; + double m_remainingLeastSquaresResidual; +}; + +///The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (iterative LCP) method. +ATTRIBUTE_ALIGNED16(class) +btSequentialImpulseConstraintSolver : public btConstraintSolver +{ + + +protected: + btAlignedObjectArray m_tmpSolverBodyPool; + btConstraintArray m_tmpSolverContactConstraintPool; + btConstraintArray m_tmpSolverNonContactConstraintPool; + btConstraintArray m_tmpSolverContactFrictionConstraintPool; + btConstraintArray m_tmpSolverContactRollingFrictionConstraintPool; + + btAlignedObjectArray m_orderTmpConstraintPool; + btAlignedObjectArray m_orderNonContactConstraintPool; + btAlignedObjectArray m_orderFrictionConstraintPool; + btAlignedObjectArray m_tmpConstraintSizesPool; + int m_maxOverrideNumSolverIterations; + int m_fixedBodyId; + // When running solvers on multiple threads, a race condition exists for Kinematic objects that + // participate in more than one solver. + // The getOrInitSolverBody() function writes the companionId of each body (storing the index of the solver body + // for the current solver). For normal dynamic bodies it isn't an issue because they can only be in one island + // (and therefore one thread) at a time. But kinematic bodies can be in multiple islands at once. + // To avoid this race condition, this solver does not write the companionId, instead it stores the solver body + // index in this solver-local table, indexed by the uniqueId of the body. + btAlignedObjectArray m_kinematicBodyUniqueIdToSolverBodyTable; // only used for multithreading + + btSingleConstraintRowSolver m_resolveSingleConstraintRowGeneric; + btSingleConstraintRowSolver m_resolveSingleConstraintRowLowerLimit; + btSingleConstraintRowSolver m_resolveSplitPenetrationImpulse; + int m_cachedSolverMode; // used to check if SOLVER_SIMD flag has been changed + void setupSolverFunctions(bool useSimd); + + btScalar m_leastSquaresResidual; + + void setupFrictionConstraint(btSolverConstraint & solverConstraint, const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB, + btManifoldPoint& cp, const btVector3& rel_pos1, const btVector3& rel_pos2, + btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, + const btContactSolverInfo& infoGlobal, + btScalar desiredVelocity = 0., btScalar cfmSlip = 0.); + + void setupTorsionalFrictionConstraint(btSolverConstraint & solverConstraint, const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB, + btManifoldPoint& cp, btScalar combinedTorsionalFriction, const btVector3& rel_pos1, const btVector3& rel_pos2, + btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, + btScalar desiredVelocity = 0., btScalar cfmSlip = 0.); + + btSolverConstraint& addFrictionConstraint(const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB, int frictionIndex, btManifoldPoint& cp, const btVector3& rel_pos1, const btVector3& rel_pos2, btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, const btContactSolverInfo& infoGlobal, btScalar desiredVelocity = 0., btScalar cfmSlip = 0.); + btSolverConstraint& addTorsionalFrictionConstraint(const btVector3& normalAxis, int solverBodyIdA, int solverBodyIdB, int frictionIndex, btManifoldPoint& cp, btScalar torsionalFriction, const btVector3& rel_pos1, const btVector3& rel_pos2, btCollisionObject* colObj0, btCollisionObject* colObj1, btScalar relaxation, btScalar desiredVelocity = 0, btScalar cfmSlip = 0.f); + + void setupContactConstraint(btSolverConstraint & solverConstraint, int solverBodyIdA, int solverBodyIdB, btManifoldPoint& cp, + const btContactSolverInfo& infoGlobal, btScalar& relaxation, const btVector3& rel_pos1, const btVector3& rel_pos2); + + static void applyAnisotropicFriction(btCollisionObject * colObj, btVector3 & frictionDirection, int frictionMode); + + void setFrictionConstraintImpulse(btSolverConstraint & solverConstraint, int solverBodyIdA, int solverBodyIdB, + btManifoldPoint& cp, const btContactSolverInfo& infoGlobal); + + ///m_btSeed2 is used for re-arranging the constraint rows. improves convergence/quality of friction + unsigned long m_btSeed2; + + btScalar restitutionCurve(btScalar rel_vel, btScalar restitution, btScalar velocityThreshold); + + virtual void convertContacts(btPersistentManifold * *manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal); + + void convertContact(btPersistentManifold * manifold, const btContactSolverInfo& infoGlobal); + + virtual void convertJoints(btTypedConstraint * *constraints, int numConstraints, const btContactSolverInfo& infoGlobal); + void convertJoint(btSolverConstraint * currentConstraintRow, btTypedConstraint * constraint, const btTypedConstraint::btConstraintInfo1& info1, int solverBodyIdA, int solverBodyIdB, const btContactSolverInfo& infoGlobal); + + virtual void convertBodies(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal); + + btScalar resolveSplitPenetrationSIMD(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint) + { + return m_resolveSplitPenetrationImpulse(bodyA, bodyB, contactConstraint); + } + + btScalar resolveSplitPenetrationImpulseCacheFriendly(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint) + { + return m_resolveSplitPenetrationImpulse(bodyA, bodyB, contactConstraint); + } + + //internal method + int getOrInitSolverBody(btCollisionObject & body, btScalar timeStep); + void initSolverBody(btSolverBody * solverBody, btCollisionObject * collisionObject, btScalar timeStep); + + btScalar resolveSingleConstraintRowGeneric(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint); + btScalar resolveSingleConstraintRowGenericSIMD(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint); + btScalar resolveSingleConstraintRowLowerLimit(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint); + btScalar resolveSingleConstraintRowLowerLimitSIMD(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint); + btScalar resolveSplitPenetrationImpulse(btSolverBody & bodyA, btSolverBody & bodyB, const btSolverConstraint& contactConstraint) + { + return m_resolveSplitPenetrationImpulse(bodyA, bodyB, contactConstraint); + } + +protected: + void writeBackContacts(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal); + void writeBackJoints(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal); + void writeBackBodies(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal); + virtual void solveGroupCacheFriendlySplitImpulseIterations(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer); + virtual btScalar solveGroupCacheFriendlyFinish(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal); + virtual btScalar solveSingleIteration(int iteration, btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer); + + virtual btScalar solveGroupCacheFriendlySetup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer); + virtual btScalar solveGroupCacheFriendlyIterations(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btSequentialImpulseConstraintSolver(); + virtual ~btSequentialImpulseConstraintSolver(); + + virtual btScalar solveGroup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifold, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& info, btIDebugDraw* debugDrawer, btDispatcher* dispatcher); + + ///clear internal cached data and reset random seed + virtual void reset(); + + unsigned long btRand2(); + + int btRandInt2(int n); + + void setRandSeed(unsigned long seed) + { + m_btSeed2 = seed; + } + unsigned long getRandSeed() const + { + return m_btSeed2; + } + + virtual btConstraintSolverType getSolverType() const + { + return BT_SEQUENTIAL_IMPULSE_SOLVER; + } + + btSingleConstraintRowSolver getActiveConstraintRowSolverGeneric() + { + return m_resolveSingleConstraintRowGeneric; + } + void setConstraintRowSolverGeneric(btSingleConstraintRowSolver rowSolver) + { + m_resolveSingleConstraintRowGeneric = rowSolver; + } + btSingleConstraintRowSolver getActiveConstraintRowSolverLowerLimit() + { + return m_resolveSingleConstraintRowLowerLimit; + } + void setConstraintRowSolverLowerLimit(btSingleConstraintRowSolver rowSolver) + { + m_resolveSingleConstraintRowLowerLimit = rowSolver; + } + + + + ///Various implementations of solving a single constraint row using a generic equality constraint, using scalar reference, SSE2 or SSE4 + btSingleConstraintRowSolver getScalarConstraintRowSolverGeneric(); + // btSingleConstraintRowSolver getSSE2ConstraintRowSolverGeneric(); + // btSingleConstraintRowSolver getSSE4_1ConstraintRowSolverGeneric(); + + ///Various implementations of solving a single constraint row using an inequality (lower limit) constraint, using scalar reference, SSE2 or SSE4 + btSingleConstraintRowSolver getScalarConstraintRowSolverLowerLimit(); + // btSingleConstraintRowSolver getSSE2ConstraintRowSolverLowerLimit(); + // btSingleConstraintRowSolver getSSE4_1ConstraintRowSolverLowerLimit(); + btSolverAnalyticsData m_analyticsData; +}; + +#endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h.i new file mode 100644 index 00000000..19d3d20d --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp new file mode 100644 index 00000000..ebd2e3ce --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp @@ -0,0 +1,1554 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btSequentialImpulseConstraintSolverMt.h" + +#include "LinearMath/btQuickprof.h" + +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" + +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" + +bool btSequentialImpulseConstraintSolverMt::s_allowNestedParallelForLoops = false; // some task schedulers don't like nested loops +int btSequentialImpulseConstraintSolverMt::s_minimumContactManifoldsForBatching = 250; +int btSequentialImpulseConstraintSolverMt::s_minBatchSize = 50; +int btSequentialImpulseConstraintSolverMt::s_maxBatchSize = 100; +btBatchedConstraints::BatchingMethod btSequentialImpulseConstraintSolverMt::s_contactBatchingMethod = btBatchedConstraints::BATCHING_METHOD_SPATIAL_GRID_2D; +btBatchedConstraints::BatchingMethod btSequentialImpulseConstraintSolverMt::s_jointBatchingMethod = btBatchedConstraints::BATCHING_METHOD_SPATIAL_GRID_2D; + +btSequentialImpulseConstraintSolverMt::btSequentialImpulseConstraintSolverMt() +{ + m_numFrictionDirections = 1; + m_useBatching = false; + m_useObsoleteJointConstraints = false; +} + +btSequentialImpulseConstraintSolverMt::~btSequentialImpulseConstraintSolverMt() +{ +} + +void btSequentialImpulseConstraintSolverMt::setupBatchedContactConstraints() +{ +//\1("setupBatchedContactConstraints"); + m_batchedContactConstraints.setup(&m_tmpSolverContactConstraintPool, + m_tmpSolverBodyPool, + s_contactBatchingMethod, + s_minBatchSize, + s_maxBatchSize, + &m_scratchMemory); +} + +void btSequentialImpulseConstraintSolverMt::setupBatchedJointConstraints() +{ +//\1("setupBatchedJointConstraints"); + m_batchedJointConstraints.setup(&m_tmpSolverNonContactConstraintPool, + m_tmpSolverBodyPool, + s_jointBatchingMethod, + s_minBatchSize, + s_maxBatchSize, + &m_scratchMemory); +} + +void btSequentialImpulseConstraintSolverMt::internalSetupContactConstraints(int iContactConstraint, const btContactSolverInfo& infoGlobal) +{ + btSolverConstraint& contactConstraint = m_tmpSolverContactConstraintPool[iContactConstraint]; + + btVector3 rel_pos1; + btVector3 rel_pos2; + btScalar relaxation; + + int solverBodyIdA = contactConstraint.m_solverBodyIdA; + int solverBodyIdB = contactConstraint.m_solverBodyIdB; + + btSolverBody* solverBodyA = &m_tmpSolverBodyPool[solverBodyIdA]; + btSolverBody* solverBodyB = &m_tmpSolverBodyPool[solverBodyIdB]; + + btRigidBody* colObj0 = solverBodyA->m_originalBody; + btRigidBody* colObj1 = solverBodyB->m_originalBody; + + btManifoldPoint& cp = *static_cast(contactConstraint.m_originalContactPoint); + + const btVector3& pos1 = cp.getPositionWorldOnA(); + const btVector3& pos2 = cp.getPositionWorldOnB(); + + rel_pos1 = pos1 - solverBodyA->getWorldTransform().getOrigin(); + rel_pos2 = pos2 - solverBodyB->getWorldTransform().getOrigin(); + + btVector3 vel1; + btVector3 vel2; + + solverBodyA->getVelocityInLocalPointNoDelta(rel_pos1, vel1); + solverBodyB->getVelocityInLocalPointNoDelta(rel_pos2, vel2); + + btVector3 vel = vel1 - vel2; + btScalar rel_vel = cp.m_normalWorldOnB.dot(vel); + + setupContactConstraint(contactConstraint, solverBodyIdA, solverBodyIdB, cp, infoGlobal, relaxation, rel_pos1, rel_pos2); + + // setup rolling friction constraints + int rollingFrictionIndex = m_rollingFrictionIndexTable[iContactConstraint]; + if (rollingFrictionIndex >= 0) + { + btSolverConstraint& spinningFrictionConstraint = m_tmpSolverContactRollingFrictionConstraintPool[rollingFrictionIndex]; + btAssert(spinningFrictionConstraint.m_frictionIndex == iContactConstraint); + setupTorsionalFrictionConstraint(spinningFrictionConstraint, + cp.m_normalWorldOnB, + solverBodyIdA, + solverBodyIdB, + cp, + cp.m_combinedSpinningFriction, + rel_pos1, + rel_pos2, + colObj0, + colObj1, + relaxation, + 0.0f, + 0.0f); + btVector3 axis[2]; + btPlaneSpace1(cp.m_normalWorldOnB, axis[0], axis[1]); + axis[0].normalize(); + axis[1].normalize(); + + applyAnisotropicFriction(colObj0, axis[0], btCollisionObject::CF_ANISOTROPIC_ROLLING_FRICTION); + applyAnisotropicFriction(colObj1, axis[0], btCollisionObject::CF_ANISOTROPIC_ROLLING_FRICTION); + applyAnisotropicFriction(colObj0, axis[1], btCollisionObject::CF_ANISOTROPIC_ROLLING_FRICTION); + applyAnisotropicFriction(colObj1, axis[1], btCollisionObject::CF_ANISOTROPIC_ROLLING_FRICTION); + // put the largest axis first + if (axis[1].length2() > axis[0].length2()) + { + btSwap(axis[0], axis[1]); + } + const btScalar kRollingFrictionThreshold = 0.001f; + for (int i = 0; i < 2; ++i) + { + int iRollingFric = rollingFrictionIndex + 1 + i; + btSolverConstraint& rollingFrictionConstraint = m_tmpSolverContactRollingFrictionConstraintPool[iRollingFric]; + btAssert(rollingFrictionConstraint.m_frictionIndex == iContactConstraint); + btVector3 dir = axis[i]; + if (dir.length() > kRollingFrictionThreshold) + { + setupTorsionalFrictionConstraint(rollingFrictionConstraint, + dir, + solverBodyIdA, + solverBodyIdB, + cp, + cp.m_combinedRollingFriction, + rel_pos1, + rel_pos2, + colObj0, + colObj1, + relaxation, + 0.0f, + 0.0f); + } + else + { + rollingFrictionConstraint.m_frictionIndex = -1; // disable constraint + } + } + } + + // setup friction constraints + // setupFrictionConstraint(solverConstraint, normalAxis, solverBodyIdA, solverBodyIdB, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal, desiredVelocity, cfmSlip); + { + ///Bullet has several options to set the friction directions + ///By default, each contact has only a single friction direction that is recomputed automatically very frame + ///based on the relative linear velocity. + ///If the relative velocity it zero, it will automatically compute a friction direction. + + ///You can also enable two friction directions, using the SOLVER_USE_2_FRICTION_DIRECTIONS. + ///In that case, the second friction direction will be orthogonal to both contact normal and first friction direction. + /// + ///If you choose SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION, then the friction will be independent from the relative projected velocity. + /// + ///The user can manually override the friction directions for certain contacts using a contact callback, + ///and set the cp.m_lateralFrictionInitialized to true + ///In that case, you can set the target relative motion in each friction direction (cp.m_contactMotion1 and cp.m_contactMotion2) + ///this will give a conveyor belt effect + /// + btSolverConstraint* frictionConstraint1 = &m_tmpSolverContactFrictionConstraintPool[contactConstraint.m_frictionIndex]; + btAssert(frictionConstraint1->m_frictionIndex == iContactConstraint); + + btSolverConstraint* frictionConstraint2 = NULL; + if (infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS) + { + frictionConstraint2 = &m_tmpSolverContactFrictionConstraintPool[contactConstraint.m_frictionIndex + 1]; + btAssert(frictionConstraint2->m_frictionIndex == iContactConstraint); + } + + if (!(infoGlobal.m_solverMode & SOLVER_ENABLE_FRICTION_DIRECTION_CACHING) || !(cp.m_contactPointFlags & BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED)) + { + cp.m_lateralFrictionDir1 = vel - cp.m_normalWorldOnB * rel_vel; + btScalar lat_rel_vel = cp.m_lateralFrictionDir1.length2(); + if (!(infoGlobal.m_solverMode & SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION) && lat_rel_vel > SIMD_EPSILON) + { + cp.m_lateralFrictionDir1 *= 1.f / btSqrt(lat_rel_vel); + applyAnisotropicFriction(colObj0, cp.m_lateralFrictionDir1, btCollisionObject::CF_ANISOTROPIC_FRICTION); + applyAnisotropicFriction(colObj1, cp.m_lateralFrictionDir1, btCollisionObject::CF_ANISOTROPIC_FRICTION); + setupFrictionConstraint(*frictionConstraint1, cp.m_lateralFrictionDir1, solverBodyIdA, solverBodyIdB, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal); + + if (frictionConstraint2) + { + cp.m_lateralFrictionDir2 = cp.m_lateralFrictionDir1.cross(cp.m_normalWorldOnB); + cp.m_lateralFrictionDir2.normalize(); //?? + applyAnisotropicFriction(colObj0, cp.m_lateralFrictionDir2, btCollisionObject::CF_ANISOTROPIC_FRICTION); + applyAnisotropicFriction(colObj1, cp.m_lateralFrictionDir2, btCollisionObject::CF_ANISOTROPIC_FRICTION); + setupFrictionConstraint(*frictionConstraint2, cp.m_lateralFrictionDir2, solverBodyIdA, solverBodyIdB, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal); + } + } + else + { + btPlaneSpace1(cp.m_normalWorldOnB, cp.m_lateralFrictionDir1, cp.m_lateralFrictionDir2); + + applyAnisotropicFriction(colObj0, cp.m_lateralFrictionDir1, btCollisionObject::CF_ANISOTROPIC_FRICTION); + applyAnisotropicFriction(colObj1, cp.m_lateralFrictionDir1, btCollisionObject::CF_ANISOTROPIC_FRICTION); + setupFrictionConstraint(*frictionConstraint1, cp.m_lateralFrictionDir1, solverBodyIdA, solverBodyIdB, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal); + + if (frictionConstraint2) + { + applyAnisotropicFriction(colObj0, cp.m_lateralFrictionDir2, btCollisionObject::CF_ANISOTROPIC_FRICTION); + applyAnisotropicFriction(colObj1, cp.m_lateralFrictionDir2, btCollisionObject::CF_ANISOTROPIC_FRICTION); + setupFrictionConstraint(*frictionConstraint2, cp.m_lateralFrictionDir2, solverBodyIdA, solverBodyIdB, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal); + } + + if ((infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS) && (infoGlobal.m_solverMode & SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION)) + { + cp.m_contactPointFlags |= BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED; + } + } + } + else + { + setupFrictionConstraint(*frictionConstraint1, cp.m_lateralFrictionDir1, solverBodyIdA, solverBodyIdB, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal, cp.m_contactMotion1, cp.m_frictionCFM); + if (frictionConstraint2) + { + setupFrictionConstraint(*frictionConstraint2, cp.m_lateralFrictionDir2, solverBodyIdA, solverBodyIdB, cp, rel_pos1, rel_pos2, colObj0, colObj1, relaxation, infoGlobal, cp.m_contactMotion2, cp.m_frictionCFM); + } + } + } + + setFrictionConstraintImpulse(contactConstraint, solverBodyIdA, solverBodyIdB, cp, infoGlobal); +} + +struct SetupContactConstraintsLoop : public btIParallelForBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btBatchedConstraints* m_bc; + const btContactSolverInfo* m_infoGlobal; + + SetupContactConstraintsLoop(btSequentialImpulseConstraintSolverMt* solver, const btBatchedConstraints* bc, const btContactSolverInfo& infoGlobal) + { + m_solver = solver; + m_bc = bc; + m_infoGlobal = &infoGlobal; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { +//\1("SetupContactConstraintsLoop"); + for (int iBatch = iBegin; iBatch < iEnd; ++iBatch) + { + const btBatchedConstraints::Range& batch = m_bc->m_batches[iBatch]; + for (int i = batch.begin; i < batch.end; ++i) + { + int iContact = m_bc->m_constraintIndices[i]; + m_solver->internalSetupContactConstraints(iContact, *m_infoGlobal); + } + } + } +}; + +void btSequentialImpulseConstraintSolverMt::setupAllContactConstraints(const btContactSolverInfo& infoGlobal) +{ +//\1("setupAllContactConstraints"); + if (m_useBatching) + { + const btBatchedConstraints& batchedCons = m_batchedContactConstraints; + SetupContactConstraintsLoop loop(this, &batchedCons, infoGlobal); + for (int iiPhase = 0; iiPhase < batchedCons.m_phases.size(); ++iiPhase) + { + int iPhase = batchedCons.m_phaseOrder[iiPhase]; + const btBatchedConstraints::Range& phase = batchedCons.m_phases[iPhase]; + int grainSize = 1; + btParallelFor(phase.begin, phase.end, grainSize, loop); + } + } + else + { + for (int i = 0; i < m_tmpSolverContactConstraintPool.size(); ++i) + { + internalSetupContactConstraints(i, infoGlobal); + } + } +} + +int btSequentialImpulseConstraintSolverMt::getOrInitSolverBodyThreadsafe(btCollisionObject& body, btScalar timeStep) +{ + // + // getOrInitSolverBody is threadsafe only for a single thread per solver (with potentially multiple solvers) + // + // getOrInitSolverBodyThreadsafe -- attempts to be fully threadsafe (however may affect determinism) + // + int solverBodyId = -1; + bool isRigidBodyType = btRigidBody::upcast(&body) != NULL; + if (isRigidBodyType && !body.isStaticOrKinematicObject()) + { + // dynamic body + // Dynamic bodies can only be in one island, so it's safe to write to the companionId + solverBodyId = body.getCompanionId(); + if (solverBodyId < 0) + { + m_bodySolverArrayMutex.lock(); + // now that we have the lock, check again + solverBodyId = body.getCompanionId(); + if (solverBodyId < 0) + { + solverBodyId = m_tmpSolverBodyPool.size(); + btSolverBody& solverBody = m_tmpSolverBodyPool.expand(); + initSolverBody(&solverBody, &body, timeStep); + body.setCompanionId(solverBodyId); + } + m_bodySolverArrayMutex.unlock(); + } + } + else if (isRigidBodyType && body.isKinematicObject()) + { + // + // NOTE: must test for kinematic before static because some kinematic objects also + // identify as "static" + // + // Kinematic bodies can be in multiple islands at once, so it is a + // race condition to write to them, so we use an alternate method + // to record the solverBodyId + int uniqueId = body.getWorldArrayIndex(); + const int INVALID_SOLVER_BODY_ID = -1; + if (m_kinematicBodyUniqueIdToSolverBodyTable.size() <= uniqueId) + { + m_kinematicBodyUniqueIdToSolverBodyTableMutex.lock(); + // now that we have the lock, check again + if (m_kinematicBodyUniqueIdToSolverBodyTable.size() <= uniqueId) + { + m_kinematicBodyUniqueIdToSolverBodyTable.resize(uniqueId + 1, INVALID_SOLVER_BODY_ID); + } + m_kinematicBodyUniqueIdToSolverBodyTableMutex.unlock(); + } + solverBodyId = m_kinematicBodyUniqueIdToSolverBodyTable[uniqueId]; + // if no table entry yet, + if (INVALID_SOLVER_BODY_ID == solverBodyId) + { + // need to acquire both locks + m_kinematicBodyUniqueIdToSolverBodyTableMutex.lock(); + m_bodySolverArrayMutex.lock(); + // now that we have the lock, check again + solverBodyId = m_kinematicBodyUniqueIdToSolverBodyTable[uniqueId]; + if (INVALID_SOLVER_BODY_ID == solverBodyId) + { + // create a table entry for this body + solverBodyId = m_tmpSolverBodyPool.size(); + btSolverBody& solverBody = m_tmpSolverBodyPool.expand(); + initSolverBody(&solverBody, &body, timeStep); + m_kinematicBodyUniqueIdToSolverBodyTable[uniqueId] = solverBodyId; + } + m_bodySolverArrayMutex.unlock(); + m_kinematicBodyUniqueIdToSolverBodyTableMutex.unlock(); + } + } + else + { + // all fixed bodies (inf mass) get mapped to a single solver id + if (m_fixedBodyId < 0) + { + m_bodySolverArrayMutex.lock(); + // now that we have the lock, check again + if (m_fixedBodyId < 0) + { + m_fixedBodyId = m_tmpSolverBodyPool.size(); + btSolverBody& fixedBody = m_tmpSolverBodyPool.expand(); + initSolverBody(&fixedBody, 0, timeStep); + } + m_bodySolverArrayMutex.unlock(); + } + solverBodyId = m_fixedBodyId; + } + btAssert(solverBodyId >= 0 && solverBodyId < m_tmpSolverBodyPool.size()); + return solverBodyId; +} + +void btSequentialImpulseConstraintSolverMt::internalCollectContactManifoldCachedInfo(btContactManifoldCachedInfo* cachedInfoArray, btPersistentManifold** manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal) +{ +//\1("internalCollectContactManifoldCachedInfo"); + for (int i = 0; i < numManifolds; ++i) + { + btContactManifoldCachedInfo* cachedInfo = &cachedInfoArray[i]; + btPersistentManifold* manifold = manifoldPtr[i]; + btCollisionObject* colObj0 = (btCollisionObject*)manifold->getBody0(); + btCollisionObject* colObj1 = (btCollisionObject*)manifold->getBody1(); + + int solverBodyIdA = getOrInitSolverBodyThreadsafe(*colObj0, infoGlobal.m_timeStep); + int solverBodyIdB = getOrInitSolverBodyThreadsafe(*colObj1, infoGlobal.m_timeStep); + + cachedInfo->solverBodyIds[0] = solverBodyIdA; + cachedInfo->solverBodyIds[1] = solverBodyIdB; + cachedInfo->numTouchingContacts = 0; + + btSolverBody* solverBodyA = &m_tmpSolverBodyPool[solverBodyIdA]; + btSolverBody* solverBodyB = &m_tmpSolverBodyPool[solverBodyIdB]; + + // A contact manifold between 2 static object should not exist! + // check the collision flags of your objects if this assert fires. + // Incorrectly set collision object flags can degrade performance in various ways. + btAssert(!m_tmpSolverBodyPool[solverBodyIdA].m_invMass.isZero() || !m_tmpSolverBodyPool[solverBodyIdB].m_invMass.isZero()); + + int iContact = 0; + for (int j = 0; j < manifold->getNumContacts(); j++) + { + btManifoldPoint& cp = manifold->getContactPoint(j); + + if (cp.getDistance() <= manifold->getContactProcessingThreshold()) + { + cachedInfo->contactPoints[iContact] = &cp; + cachedInfo->contactHasRollingFriction[iContact] = (cp.m_combinedRollingFriction > 0.f); + iContact++; + } + } + cachedInfo->numTouchingContacts = iContact; + } +} + +struct CollectContactManifoldCachedInfoLoop : public btIParallelForBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + btSequentialImpulseConstraintSolverMt::btContactManifoldCachedInfo* m_cachedInfoArray; + btPersistentManifold** m_manifoldPtr; + const btContactSolverInfo* m_infoGlobal; + + CollectContactManifoldCachedInfoLoop(btSequentialImpulseConstraintSolverMt* solver, btSequentialImpulseConstraintSolverMt::btContactManifoldCachedInfo* cachedInfoArray, btPersistentManifold** manifoldPtr, const btContactSolverInfo& infoGlobal) + { + m_solver = solver; + m_cachedInfoArray = cachedInfoArray; + m_manifoldPtr = manifoldPtr; + m_infoGlobal = &infoGlobal; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + m_solver->internalCollectContactManifoldCachedInfo(m_cachedInfoArray + iBegin, m_manifoldPtr + iBegin, iEnd - iBegin, *m_infoGlobal); + } +}; + +void btSequentialImpulseConstraintSolverMt::internalAllocContactConstraints(const btContactManifoldCachedInfo* cachedInfoArray, int numManifolds) +{ +//\1("internalAllocContactConstraints"); + // possibly parallel part + for (int iManifold = 0; iManifold < numManifolds; ++iManifold) + { + const btContactManifoldCachedInfo& cachedInfo = cachedInfoArray[iManifold]; + int contactIndex = cachedInfo.contactIndex; + int frictionIndex = contactIndex * m_numFrictionDirections; + int rollingFrictionIndex = cachedInfo.rollingFrictionIndex; + for (int i = 0; i < cachedInfo.numTouchingContacts; i++) + { + btSolverConstraint& contactConstraint = m_tmpSolverContactConstraintPool[contactIndex]; + contactConstraint.m_solverBodyIdA = cachedInfo.solverBodyIds[0]; + contactConstraint.m_solverBodyIdB = cachedInfo.solverBodyIds[1]; + contactConstraint.m_originalContactPoint = cachedInfo.contactPoints[i]; + + // allocate the friction constraints + contactConstraint.m_frictionIndex = frictionIndex; + for (int iDir = 0; iDir < m_numFrictionDirections; ++iDir) + { + btSolverConstraint& frictionConstraint = m_tmpSolverContactFrictionConstraintPool[frictionIndex]; + frictionConstraint.m_frictionIndex = contactIndex; + frictionIndex++; + } + + // allocate rolling friction constraints + if (cachedInfo.contactHasRollingFriction[i]) + { + m_rollingFrictionIndexTable[contactIndex] = rollingFrictionIndex; + // allocate 3 (although we may use only 2 sometimes) + for (int i = 0; i < 3; i++) + { + m_tmpSolverContactRollingFrictionConstraintPool[rollingFrictionIndex].m_frictionIndex = contactIndex; + rollingFrictionIndex++; + } + } + else + { + // indicate there is no rolling friction for this contact point + m_rollingFrictionIndexTable[contactIndex] = -1; + } + contactIndex++; + } + } +} + +struct AllocContactConstraintsLoop : public btIParallelForBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btSequentialImpulseConstraintSolverMt::btContactManifoldCachedInfo* m_cachedInfoArray; + + AllocContactConstraintsLoop(btSequentialImpulseConstraintSolverMt* solver, btSequentialImpulseConstraintSolverMt::btContactManifoldCachedInfo* cachedInfoArray) + { + m_solver = solver; + m_cachedInfoArray = cachedInfoArray; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + m_solver->internalAllocContactConstraints(m_cachedInfoArray + iBegin, iEnd - iBegin); + } +}; + +void btSequentialImpulseConstraintSolverMt::allocAllContactConstraints(btPersistentManifold** manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal) +{ +//\1("allocAllContactConstraints"); + btAlignedObjectArray cachedInfoArray; // = m_manifoldCachedInfoArray; + cachedInfoArray.resizeNoInitialize(numManifolds); + if (/* DISABLES CODE */ (false)) + { + // sequential + internalCollectContactManifoldCachedInfo(&cachedInfoArray[0], manifoldPtr, numManifolds, infoGlobal); + } + else + { + // may alter ordering of bodies which affects determinism + CollectContactManifoldCachedInfoLoop loop(this, &cachedInfoArray[0], manifoldPtr, infoGlobal); + int grainSize = 200; + btParallelFor(0, numManifolds, grainSize, loop); + } + + { + // serial part + int numContacts = 0; + int numRollingFrictionConstraints = 0; + for (int iManifold = 0; iManifold < numManifolds; ++iManifold) + { + btContactManifoldCachedInfo& cachedInfo = cachedInfoArray[iManifold]; + cachedInfo.contactIndex = numContacts; + cachedInfo.rollingFrictionIndex = numRollingFrictionConstraints; + numContacts += cachedInfo.numTouchingContacts; + for (int i = 0; i < cachedInfo.numTouchingContacts; ++i) + { + if (cachedInfo.contactHasRollingFriction[i]) + { + numRollingFrictionConstraints += 3; + } + } + } + { +//\1("allocPools"); + if (m_tmpSolverContactConstraintPool.capacity() < numContacts) + { + // if we need to reallocate, reserve some extra so we don't have to reallocate again next frame + int extraReserve = numContacts / 16; + m_tmpSolverContactConstraintPool.reserve(numContacts + extraReserve); + m_rollingFrictionIndexTable.reserve(numContacts + extraReserve); + m_tmpSolverContactFrictionConstraintPool.reserve((numContacts + extraReserve) * m_numFrictionDirections); + m_tmpSolverContactRollingFrictionConstraintPool.reserve(numRollingFrictionConstraints + extraReserve); + } + m_tmpSolverContactConstraintPool.resizeNoInitialize(numContacts); + m_rollingFrictionIndexTable.resizeNoInitialize(numContacts); + m_tmpSolverContactFrictionConstraintPool.resizeNoInitialize(numContacts * m_numFrictionDirections); + m_tmpSolverContactRollingFrictionConstraintPool.resizeNoInitialize(numRollingFrictionConstraints); + } + } + { + AllocContactConstraintsLoop loop(this, &cachedInfoArray[0]); + int grainSize = 200; + btParallelFor(0, numManifolds, grainSize, loop); + } +} + +void btSequentialImpulseConstraintSolverMt::convertContacts(btPersistentManifold** manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal) +{ + if (!m_useBatching) + { + btSequentialImpulseConstraintSolver::convertContacts(manifoldPtr, numManifolds, infoGlobal); + return; + } +//\1("convertContacts"); + if (numManifolds > 0) + { + if (m_fixedBodyId < 0) + { + m_fixedBodyId = m_tmpSolverBodyPool.size(); + btSolverBody& fixedBody = m_tmpSolverBodyPool.expand(); + initSolverBody(&fixedBody, 0, infoGlobal.m_timeStep); + } + allocAllContactConstraints(manifoldPtr, numManifolds, infoGlobal); + if (m_useBatching) + { + setupBatchedContactConstraints(); + } + setupAllContactConstraints(infoGlobal); + } +} + +void btSequentialImpulseConstraintSolverMt::internalInitMultipleJoints(btTypedConstraint** constraints, int iBegin, int iEnd) +{ +//\1("internalInitMultipleJoints"); + for (int i = iBegin; i < iEnd; i++) + { + btTypedConstraint* constraint = constraints[i]; + btTypedConstraint::btConstraintInfo1& info1 = m_tmpConstraintSizesPool[i]; + if (constraint->isEnabled()) + { + constraint->buildJacobian(); + constraint->internalSetAppliedImpulse(0.0f); + btJointFeedback* fb = constraint->getJointFeedback(); + if (fb) + { + fb->m_appliedForceBodyA.setZero(); + fb->m_appliedTorqueBodyA.setZero(); + fb->m_appliedForceBodyB.setZero(); + fb->m_appliedTorqueBodyB.setZero(); + } + constraint->getInfo1(&info1); + } + else + { + info1.m_numConstraintRows = 0; + info1.nub = 0; + } + } +} + +struct InitJointsLoop : public btIParallelForBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + btTypedConstraint** m_constraints; + + InitJointsLoop(btSequentialImpulseConstraintSolverMt* solver, btTypedConstraint** constraints) + { + m_solver = solver; + m_constraints = constraints; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + m_solver->internalInitMultipleJoints(m_constraints, iBegin, iEnd); + } +}; + +void btSequentialImpulseConstraintSolverMt::internalConvertMultipleJoints(const btAlignedObjectArray& jointParamsArray, btTypedConstraint** constraints, int iBegin, int iEnd, const btContactSolverInfo& infoGlobal) +{ +//\1("internalConvertMultipleJoints"); + for (int i = iBegin; i < iEnd; ++i) + { + const JointParams& jointParams = jointParamsArray[i]; + int currentRow = jointParams.m_solverConstraint; + if (currentRow != -1) + { + const btTypedConstraint::btConstraintInfo1& info1 = m_tmpConstraintSizesPool[i]; + btAssert(currentRow < m_tmpSolverNonContactConstraintPool.size()); + btAssert(info1.m_numConstraintRows > 0); + + btSolverConstraint* currentConstraintRow = &m_tmpSolverNonContactConstraintPool[currentRow]; + btTypedConstraint* constraint = constraints[i]; + + convertJoint(currentConstraintRow, constraint, info1, jointParams.m_solverBodyA, jointParams.m_solverBodyB, infoGlobal); + } + } +} + +struct ConvertJointsLoop : public btIParallelForBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btAlignedObjectArray& m_jointParamsArray; + btTypedConstraint** m_srcConstraints; + const btContactSolverInfo& m_infoGlobal; + + ConvertJointsLoop(btSequentialImpulseConstraintSolverMt* solver, + const btAlignedObjectArray& jointParamsArray, + btTypedConstraint** srcConstraints, + const btContactSolverInfo& infoGlobal) : m_jointParamsArray(jointParamsArray), + m_infoGlobal(infoGlobal) + { + m_solver = solver; + m_srcConstraints = srcConstraints; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + m_solver->internalConvertMultipleJoints(m_jointParamsArray, m_srcConstraints, iBegin, iEnd, m_infoGlobal); + } +}; + +void btSequentialImpulseConstraintSolverMt::convertJoints(btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal) +{ + if (!m_useBatching) + { + btSequentialImpulseConstraintSolver::convertJoints(constraints, numConstraints, infoGlobal); + return; + } +//\1("convertJoints"); + bool parallelJointSetup = true; + m_tmpConstraintSizesPool.resizeNoInitialize(numConstraints); + if (parallelJointSetup) + { + InitJointsLoop loop(this, constraints); + int grainSize = 40; + btParallelFor(0, numConstraints, grainSize, loop); + } + else + { + internalInitMultipleJoints(constraints, 0, numConstraints); + } + + int totalNumRows = 0; + btAlignedObjectArray jointParamsArray; + jointParamsArray.resizeNoInitialize(numConstraints); + + //calculate the total number of contraint rows + for (int i = 0; i < numConstraints; i++) + { + btTypedConstraint* constraint = constraints[i]; + + JointParams& params = jointParamsArray[i]; + const btTypedConstraint::btConstraintInfo1& info1 = m_tmpConstraintSizesPool[i]; + + if (info1.m_numConstraintRows) + { + params.m_solverConstraint = totalNumRows; + params.m_solverBodyA = getOrInitSolverBody(constraint->getRigidBodyA(), infoGlobal.m_timeStep); + params.m_solverBodyB = getOrInitSolverBody(constraint->getRigidBodyB(), infoGlobal.m_timeStep); + } + else + { + params.m_solverConstraint = -1; + } + totalNumRows += info1.m_numConstraintRows; + } + m_tmpSolverNonContactConstraintPool.resizeNoInitialize(totalNumRows); + + ///setup the btSolverConstraints + if (parallelJointSetup) + { + ConvertJointsLoop loop(this, jointParamsArray, constraints, infoGlobal); + int grainSize = 20; + btParallelFor(0, numConstraints, grainSize, loop); + } + else + { + internalConvertMultipleJoints(jointParamsArray, constraints, 0, numConstraints, infoGlobal); + } + setupBatchedJointConstraints(); +} + +void btSequentialImpulseConstraintSolverMt::internalConvertBodies(btCollisionObject** bodies, int iBegin, int iEnd, const btContactSolverInfo& infoGlobal) +{ +//\1("internalConvertBodies"); + for (int i = iBegin; i < iEnd; i++) + { + btCollisionObject* obj = bodies[i]; + obj->setCompanionId(i); + btSolverBody& solverBody = m_tmpSolverBodyPool[i]; + initSolverBody(&solverBody, obj, infoGlobal.m_timeStep); + + btRigidBody* body = btRigidBody::upcast(obj); + if (body && body->getInvMass()) + { + btVector3 gyroForce(0, 0, 0); + if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT) + { + gyroForce = body->computeGyroscopicForceExplicit(infoGlobal.m_maxGyroscopicForce); + solverBody.m_externalTorqueImpulse -= gyroForce * body->getInvInertiaTensorWorld() * infoGlobal.m_timeStep; + } + if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD) + { + gyroForce = body->computeGyroscopicImpulseImplicit_World(infoGlobal.m_timeStep); + solverBody.m_externalTorqueImpulse += gyroForce; + } + if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY) + { + gyroForce = body->computeGyroscopicImpulseImplicit_Body(infoGlobal.m_timeStep); + solverBody.m_externalTorqueImpulse += gyroForce; + } + } + } +} + +struct ConvertBodiesLoop : public btIParallelForBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + btCollisionObject** m_bodies; + int m_numBodies; + const btContactSolverInfo& m_infoGlobal; + + ConvertBodiesLoop(btSequentialImpulseConstraintSolverMt* solver, + btCollisionObject** bodies, + int numBodies, + const btContactSolverInfo& infoGlobal) : m_infoGlobal(infoGlobal) + { + m_solver = solver; + m_bodies = bodies; + m_numBodies = numBodies; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + m_solver->internalConvertBodies(m_bodies, iBegin, iEnd, m_infoGlobal); + } +}; + +void btSequentialImpulseConstraintSolverMt::convertBodies(btCollisionObject** bodies, int numBodies, const btContactSolverInfo& infoGlobal) +{ +//\1("convertBodies"); + m_kinematicBodyUniqueIdToSolverBodyTable.resize(0); + + m_tmpSolverBodyPool.resizeNoInitialize(numBodies + 1); + + m_fixedBodyId = numBodies; + { + btSolverBody& fixedBody = m_tmpSolverBodyPool[m_fixedBodyId]; + initSolverBody(&fixedBody, NULL, infoGlobal.m_timeStep); + } + + bool parallelBodySetup = true; + if (parallelBodySetup) + { + ConvertBodiesLoop loop(this, bodies, numBodies, infoGlobal); + int grainSize = 40; + btParallelFor(0, numBodies, grainSize, loop); + } + else + { + internalConvertBodies(bodies, 0, numBodies, infoGlobal); + } +} + +btScalar btSequentialImpulseConstraintSolverMt::solveGroupCacheFriendlySetup( + btCollisionObject** bodies, + int numBodies, + btPersistentManifold** manifoldPtr, + int numManifolds, + btTypedConstraint** constraints, + int numConstraints, + const btContactSolverInfo& infoGlobal, + btIDebugDraw* debugDrawer) +{ + m_numFrictionDirections = (infoGlobal.m_solverMode & SOLVER_USE_2_FRICTION_DIRECTIONS) ? 2 : 1; + m_useBatching = false; + if (numManifolds >= s_minimumContactManifoldsForBatching && + (s_allowNestedParallelForLoops || !btThreadsAreRunning())) + { + m_useBatching = true; + m_batchedContactConstraints.m_debugDrawer = debugDrawer; + m_batchedJointConstraints.m_debugDrawer = debugDrawer; + } + btSequentialImpulseConstraintSolver::solveGroupCacheFriendlySetup(bodies, + numBodies, + manifoldPtr, + numManifolds, + constraints, + numConstraints, + infoGlobal, + debugDrawer); + return 0.0f; +} + +btScalar btSequentialImpulseConstraintSolverMt::resolveMultipleContactSplitPenetrationImpulseConstraints(const btAlignedObjectArray& consIndices, int batchBegin, int batchEnd) +{ + btScalar leastSquaresResidual = 0.f; + for (int iiCons = batchBegin; iiCons < batchEnd; ++iiCons) + { + int iCons = consIndices[iiCons]; + const btSolverConstraint& solveManifold = m_tmpSolverContactConstraintPool[iCons]; + btSolverBody& bodyA = m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA]; + btSolverBody& bodyB = m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB]; + btScalar residual = resolveSplitPenetrationImpulse(bodyA, bodyB, solveManifold); + leastSquaresResidual += residual * residual; + } + return leastSquaresResidual; +} + +struct ContactSplitPenetrationImpulseSolverLoop : public btIParallelSumBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btBatchedConstraints* m_bc; + + ContactSplitPenetrationImpulseSolverLoop(btSequentialImpulseConstraintSolverMt* solver, const btBatchedConstraints* bc) + { + m_solver = solver; + m_bc = bc; + } + btScalar sumLoop(int iBegin, int iEnd) const BT_OVERRIDE + { +//\1("ContactSplitPenetrationImpulseSolverLoop"); + btScalar sum = 0; + for (int iBatch = iBegin; iBatch < iEnd; ++iBatch) + { + const btBatchedConstraints::Range& batch = m_bc->m_batches[iBatch]; + sum += m_solver->resolveMultipleContactSplitPenetrationImpulseConstraints(m_bc->m_constraintIndices, batch.begin, batch.end); + } + return sum; + } +}; + +void btSequentialImpulseConstraintSolverMt::solveGroupCacheFriendlySplitImpulseIterations(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) +{ +//\1("solveGroupCacheFriendlySplitImpulseIterations"); + if (infoGlobal.m_splitImpulse) + { + for (int iteration = 0; iteration < infoGlobal.m_numIterations; iteration++) + { + btScalar leastSquaresResidual = 0.f; + if (m_useBatching) + { + const btBatchedConstraints& batchedCons = m_batchedContactConstraints; + ContactSplitPenetrationImpulseSolverLoop loop(this, &batchedCons); + btScalar leastSquaresResidual = 0.f; + for (int iiPhase = 0; iiPhase < batchedCons.m_phases.size(); ++iiPhase) + { + int iPhase = batchedCons.m_phaseOrder[iiPhase]; + const btBatchedConstraints::Range& phase = batchedCons.m_phases[iPhase]; + int grainSize = batchedCons.m_phaseGrainSize[iPhase]; + leastSquaresResidual += btParallelSum(phase.begin, phase.end, grainSize, loop); + } + } + else + { + // non-batched + leastSquaresResidual = resolveMultipleContactSplitPenetrationImpulseConstraints(m_orderTmpConstraintPool, 0, m_tmpSolverContactConstraintPool.size()); + } + if (leastSquaresResidual <= infoGlobal.m_leastSquaresResidualThreshold || iteration >= (infoGlobal.m_numIterations - 1)) + { +#ifdef VERBOSE_RESIDUAL_PRINTF + printf("residual = %f at iteration #%d\n", leastSquaresResidual, iteration); +#endif + break; + } + } + } +} + +btScalar btSequentialImpulseConstraintSolverMt::solveSingleIteration(int iteration, btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) +{ + if (!m_useBatching) + { + return btSequentialImpulseConstraintSolver::solveSingleIteration(iteration, bodies, numBodies, manifoldPtr, numManifolds, constraints, numConstraints, infoGlobal, debugDrawer); + } +//\1("solveSingleIterationMt"); + btScalar leastSquaresResidual = 0.f; + + if (infoGlobal.m_solverMode & SOLVER_RANDMIZE_ORDER) + { + if (1) // uncomment this for a bit less random ((iteration & 7) == 0) + { + randomizeConstraintOrdering(iteration, infoGlobal.m_numIterations); + } + } + + { + ///solve all joint constraints + leastSquaresResidual += resolveAllJointConstraints(iteration); + + if (iteration < infoGlobal.m_numIterations) + { + // this loop is only used for cone-twist constraints, + // it would be nice to skip this loop if none of the constraints need it + if (m_useObsoleteJointConstraints) + { + for (int j = 0; j < numConstraints; j++) + { + if (constraints[j]->isEnabled()) + { + int bodyAid = getOrInitSolverBody(constraints[j]->getRigidBodyA(), infoGlobal.m_timeStep); + int bodyBid = getOrInitSolverBody(constraints[j]->getRigidBodyB(), infoGlobal.m_timeStep); + btSolverBody& bodyA = m_tmpSolverBodyPool[bodyAid]; + btSolverBody& bodyB = m_tmpSolverBodyPool[bodyBid]; + constraints[j]->solveConstraintObsolete(bodyA, bodyB, infoGlobal.m_timeStep); + } + } + } + + if (infoGlobal.m_solverMode & SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS) + { + // solve all contact, contact-friction, and rolling friction constraints interleaved + leastSquaresResidual += resolveAllContactConstraintsInterleaved(); + } + else //SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS + { + // don't interleave them + // solve all contact constraints + leastSquaresResidual += resolveAllContactConstraints(); + + // solve all contact friction constraints + leastSquaresResidual += resolveAllContactFrictionConstraints(); + + // solve all rolling friction constraints + leastSquaresResidual += resolveAllRollingFrictionConstraints(); + } + } + } + return leastSquaresResidual; +} + +btScalar btSequentialImpulseConstraintSolverMt::resolveMultipleJointConstraints(const btAlignedObjectArray& consIndices, int batchBegin, int batchEnd, int iteration) +{ + btScalar leastSquaresResidual = 0.f; + for (int iiCons = batchBegin; iiCons < batchEnd; ++iiCons) + { + int iCons = consIndices[iiCons]; + const btSolverConstraint& constraint = m_tmpSolverNonContactConstraintPool[iCons]; + if (iteration < constraint.m_overrideNumSolverIterations) + { + btSolverBody& bodyA = m_tmpSolverBodyPool[constraint.m_solverBodyIdA]; + btSolverBody& bodyB = m_tmpSolverBodyPool[constraint.m_solverBodyIdB]; + btScalar residual = resolveSingleConstraintRowGeneric(bodyA, bodyB, constraint); + leastSquaresResidual += residual * residual; + } + } + return leastSquaresResidual; +} + +btScalar btSequentialImpulseConstraintSolverMt::resolveMultipleContactConstraints(const btAlignedObjectArray& consIndices, int batchBegin, int batchEnd) +{ + btScalar leastSquaresResidual = 0.f; + for (int iiCons = batchBegin; iiCons < batchEnd; ++iiCons) + { + int iCons = consIndices[iiCons]; + const btSolverConstraint& solveManifold = m_tmpSolverContactConstraintPool[iCons]; + btSolverBody& bodyA = m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA]; + btSolverBody& bodyB = m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB]; + btScalar residual = resolveSingleConstraintRowLowerLimit(bodyA, bodyB, solveManifold); + leastSquaresResidual += residual * residual; + } + return leastSquaresResidual; +} + +btScalar btSequentialImpulseConstraintSolverMt::resolveMultipleContactFrictionConstraints(const btAlignedObjectArray& consIndices, int batchBegin, int batchEnd) +{ + btScalar leastSquaresResidual = 0.f; + for (int iiCons = batchBegin; iiCons < batchEnd; ++iiCons) + { + int iContact = consIndices[iiCons]; + btScalar totalImpulse = m_tmpSolverContactConstraintPool[iContact].m_appliedImpulse; + + // apply sliding friction + if (totalImpulse > 0.0f) + { + int iBegin = iContact * m_numFrictionDirections; + int iEnd = iBegin + m_numFrictionDirections; + for (int iFriction = iBegin; iFriction < iEnd; ++iFriction) + { + btSolverConstraint& solveManifold = m_tmpSolverContactFrictionConstraintPool[iFriction++]; + btAssert(solveManifold.m_frictionIndex == iContact); + + solveManifold.m_lowerLimit = -(solveManifold.m_friction * totalImpulse); + solveManifold.m_upperLimit = solveManifold.m_friction * totalImpulse; + + btSolverBody& bodyA = m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA]; + btSolverBody& bodyB = m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB]; + btScalar residual = resolveSingleConstraintRowGeneric(bodyA, bodyB, solveManifold); + leastSquaresResidual += residual * residual; + } + } + } + return leastSquaresResidual; +} + +btScalar btSequentialImpulseConstraintSolverMt::resolveMultipleContactRollingFrictionConstraints(const btAlignedObjectArray& consIndices, int batchBegin, int batchEnd) +{ + btScalar leastSquaresResidual = 0.f; + for (int iiCons = batchBegin; iiCons < batchEnd; ++iiCons) + { + int iContact = consIndices[iiCons]; + int iFirstRollingFriction = m_rollingFrictionIndexTable[iContact]; + if (iFirstRollingFriction >= 0) + { + btScalar totalImpulse = m_tmpSolverContactConstraintPool[iContact].m_appliedImpulse; + // apply rolling friction + if (totalImpulse > 0.0f) + { + int iBegin = iFirstRollingFriction; + int iEnd = iBegin + 3; + for (int iRollingFric = iBegin; iRollingFric < iEnd; ++iRollingFric) + { + btSolverConstraint& rollingFrictionConstraint = m_tmpSolverContactRollingFrictionConstraintPool[iRollingFric]; + if (rollingFrictionConstraint.m_frictionIndex != iContact) + { + break; + } + btScalar rollingFrictionMagnitude = rollingFrictionConstraint.m_friction * totalImpulse; + if (rollingFrictionMagnitude > rollingFrictionConstraint.m_friction) + { + rollingFrictionMagnitude = rollingFrictionConstraint.m_friction; + } + + rollingFrictionConstraint.m_lowerLimit = -rollingFrictionMagnitude; + rollingFrictionConstraint.m_upperLimit = rollingFrictionMagnitude; + + btScalar residual = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[rollingFrictionConstraint.m_solverBodyIdA], m_tmpSolverBodyPool[rollingFrictionConstraint.m_solverBodyIdB], rollingFrictionConstraint); + leastSquaresResidual += residual * residual; + } + } + } + } + return leastSquaresResidual; +} + +btScalar btSequentialImpulseConstraintSolverMt::resolveMultipleContactConstraintsInterleaved(const btAlignedObjectArray& contactIndices, + int batchBegin, + int batchEnd) +{ + btScalar leastSquaresResidual = 0.f; + int numPoolConstraints = m_tmpSolverContactConstraintPool.size(); + + for (int iiCons = batchBegin; iiCons < batchEnd; iiCons++) + { + btScalar totalImpulse = 0; + int iContact = contactIndices[iiCons]; + // apply penetration constraint + { + const btSolverConstraint& solveManifold = m_tmpSolverContactConstraintPool[iContact]; + btScalar residual = resolveSingleConstraintRowLowerLimit(m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA], m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB], solveManifold); + leastSquaresResidual += residual * residual; + totalImpulse = solveManifold.m_appliedImpulse; + } + + // apply sliding friction + if (totalImpulse > 0.0f) + { + int iBegin = iContact * m_numFrictionDirections; + int iEnd = iBegin + m_numFrictionDirections; + for (int iFriction = iBegin; iFriction < iEnd; ++iFriction) + { + btSolverConstraint& solveManifold = m_tmpSolverContactFrictionConstraintPool[iFriction]; + btAssert(solveManifold.m_frictionIndex == iContact); + + solveManifold.m_lowerLimit = -(solveManifold.m_friction * totalImpulse); + solveManifold.m_upperLimit = solveManifold.m_friction * totalImpulse; + + btSolverBody& bodyA = m_tmpSolverBodyPool[solveManifold.m_solverBodyIdA]; + btSolverBody& bodyB = m_tmpSolverBodyPool[solveManifold.m_solverBodyIdB]; + btScalar residual = resolveSingleConstraintRowGeneric(bodyA, bodyB, solveManifold); + leastSquaresResidual += residual * residual; + } + } + + // apply rolling friction + int iFirstRollingFriction = m_rollingFrictionIndexTable[iContact]; + if (totalImpulse > 0.0f && iFirstRollingFriction >= 0) + { + int iBegin = iFirstRollingFriction; + int iEnd = iBegin + 3; + for (int iRollingFric = iBegin; iRollingFric < iEnd; ++iRollingFric) + { + btSolverConstraint& rollingFrictionConstraint = m_tmpSolverContactRollingFrictionConstraintPool[iRollingFric]; + if (rollingFrictionConstraint.m_frictionIndex != iContact) + { + break; + } + btScalar rollingFrictionMagnitude = rollingFrictionConstraint.m_friction * totalImpulse; + if (rollingFrictionMagnitude > rollingFrictionConstraint.m_friction) + { + rollingFrictionMagnitude = rollingFrictionConstraint.m_friction; + } + + rollingFrictionConstraint.m_lowerLimit = -rollingFrictionMagnitude; + rollingFrictionConstraint.m_upperLimit = rollingFrictionMagnitude; + + btScalar residual = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[rollingFrictionConstraint.m_solverBodyIdA], m_tmpSolverBodyPool[rollingFrictionConstraint.m_solverBodyIdB], rollingFrictionConstraint); + leastSquaresResidual += residual * residual; + } + } + } + return leastSquaresResidual; +} + +void btSequentialImpulseConstraintSolverMt::randomizeBatchedConstraintOrdering(btBatchedConstraints* batchedConstraints) +{ + btBatchedConstraints& bc = *batchedConstraints; + // randomize ordering of phases + for (int ii = 1; ii < bc.m_phaseOrder.size(); ++ii) + { + int iSwap = btRandInt2(ii + 1); + bc.m_phaseOrder.swap(ii, iSwap); + } + + // for each batch, + for (int iBatch = 0; iBatch < bc.m_batches.size(); ++iBatch) + { + // randomize ordering of constraints within the batch + const btBatchedConstraints::Range& batch = bc.m_batches[iBatch]; + for (int iiCons = batch.begin; iiCons < batch.end; ++iiCons) + { + int iSwap = batch.begin + btRandInt2(iiCons - batch.begin + 1); + btAssert(iSwap >= batch.begin && iSwap < batch.end); + bc.m_constraintIndices.swap(iiCons, iSwap); + } + } +} + +void btSequentialImpulseConstraintSolverMt::randomizeConstraintOrdering(int iteration, int numIterations) +{ + // randomize ordering of joint constraints + randomizeBatchedConstraintOrdering(&m_batchedJointConstraints); + + //contact/friction constraints are not solved more than numIterations + if (iteration < numIterations) + { + randomizeBatchedConstraintOrdering(&m_batchedContactConstraints); + } +} + +struct JointSolverLoop : public btIParallelSumBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btBatchedConstraints* m_bc; + int m_iteration; + + JointSolverLoop(btSequentialImpulseConstraintSolverMt* solver, const btBatchedConstraints* bc, int iteration) + { + m_solver = solver; + m_bc = bc; + m_iteration = iteration; + } + btScalar sumLoop(int iBegin, int iEnd) const BT_OVERRIDE + { +//\1("JointSolverLoop"); + btScalar sum = 0; + for (int iBatch = iBegin; iBatch < iEnd; ++iBatch) + { + const btBatchedConstraints::Range& batch = m_bc->m_batches[iBatch]; + sum += m_solver->resolveMultipleJointConstraints(m_bc->m_constraintIndices, batch.begin, batch.end, m_iteration); + } + return sum; + } +}; + +btScalar btSequentialImpulseConstraintSolverMt::resolveAllJointConstraints(int iteration) +{ +//\1("resolveAllJointConstraints"); + const btBatchedConstraints& batchedCons = m_batchedJointConstraints; + JointSolverLoop loop(this, &batchedCons, iteration); + btScalar leastSquaresResidual = 0.f; + for (int iiPhase = 0; iiPhase < batchedCons.m_phases.size(); ++iiPhase) + { + int iPhase = batchedCons.m_phaseOrder[iiPhase]; + const btBatchedConstraints::Range& phase = batchedCons.m_phases[iPhase]; + int grainSize = 1; + leastSquaresResidual += btParallelSum(phase.begin, phase.end, grainSize, loop); + } + return leastSquaresResidual; +} + +struct ContactSolverLoop : public btIParallelSumBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btBatchedConstraints* m_bc; + + ContactSolverLoop(btSequentialImpulseConstraintSolverMt* solver, const btBatchedConstraints* bc) + { + m_solver = solver; + m_bc = bc; + } + btScalar sumLoop(int iBegin, int iEnd) const BT_OVERRIDE + { +//\1("ContactSolverLoop"); + btScalar sum = 0; + for (int iBatch = iBegin; iBatch < iEnd; ++iBatch) + { + const btBatchedConstraints::Range& batch = m_bc->m_batches[iBatch]; + sum += m_solver->resolveMultipleContactConstraints(m_bc->m_constraintIndices, batch.begin, batch.end); + } + return sum; + } +}; + +btScalar btSequentialImpulseConstraintSolverMt::resolveAllContactConstraints() +{ +//\1("resolveAllContactConstraints"); + const btBatchedConstraints& batchedCons = m_batchedContactConstraints; + ContactSolverLoop loop(this, &batchedCons); + btScalar leastSquaresResidual = 0.f; + for (int iiPhase = 0; iiPhase < batchedCons.m_phases.size(); ++iiPhase) + { + int iPhase = batchedCons.m_phaseOrder[iiPhase]; + const btBatchedConstraints::Range& phase = batchedCons.m_phases[iPhase]; + int grainSize = batchedCons.m_phaseGrainSize[iPhase]; + leastSquaresResidual += btParallelSum(phase.begin, phase.end, grainSize, loop); + } + return leastSquaresResidual; +} + +struct ContactFrictionSolverLoop : public btIParallelSumBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btBatchedConstraints* m_bc; + + ContactFrictionSolverLoop(btSequentialImpulseConstraintSolverMt* solver, const btBatchedConstraints* bc) + { + m_solver = solver; + m_bc = bc; + } + btScalar sumLoop(int iBegin, int iEnd) const BT_OVERRIDE + { +//\1("ContactFrictionSolverLoop"); + btScalar sum = 0; + for (int iBatch = iBegin; iBatch < iEnd; ++iBatch) + { + const btBatchedConstraints::Range& batch = m_bc->m_batches[iBatch]; + sum += m_solver->resolveMultipleContactFrictionConstraints(m_bc->m_constraintIndices, batch.begin, batch.end); + } + return sum; + } +}; + +btScalar btSequentialImpulseConstraintSolverMt::resolveAllContactFrictionConstraints() +{ +//\1("resolveAllContactFrictionConstraints"); + const btBatchedConstraints& batchedCons = m_batchedContactConstraints; + ContactFrictionSolverLoop loop(this, &batchedCons); + btScalar leastSquaresResidual = 0.f; + for (int iiPhase = 0; iiPhase < batchedCons.m_phases.size(); ++iiPhase) + { + int iPhase = batchedCons.m_phaseOrder[iiPhase]; + const btBatchedConstraints::Range& phase = batchedCons.m_phases[iPhase]; + int grainSize = batchedCons.m_phaseGrainSize[iPhase]; + leastSquaresResidual += btParallelSum(phase.begin, phase.end, grainSize, loop); + } + return leastSquaresResidual; +} + +struct InterleavedContactSolverLoop : public btIParallelSumBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btBatchedConstraints* m_bc; + + InterleavedContactSolverLoop(btSequentialImpulseConstraintSolverMt* solver, const btBatchedConstraints* bc) + { + m_solver = solver; + m_bc = bc; + } + btScalar sumLoop(int iBegin, int iEnd) const BT_OVERRIDE + { +//\1("InterleavedContactSolverLoop"); + btScalar sum = 0; + for (int iBatch = iBegin; iBatch < iEnd; ++iBatch) + { + const btBatchedConstraints::Range& batch = m_bc->m_batches[iBatch]; + sum += m_solver->resolveMultipleContactConstraintsInterleaved(m_bc->m_constraintIndices, batch.begin, batch.end); + } + return sum; + } +}; + +btScalar btSequentialImpulseConstraintSolverMt::resolveAllContactConstraintsInterleaved() +{ +//\1("resolveAllContactConstraintsInterleaved"); + const btBatchedConstraints& batchedCons = m_batchedContactConstraints; + InterleavedContactSolverLoop loop(this, &batchedCons); + btScalar leastSquaresResidual = 0.f; + for (int iiPhase = 0; iiPhase < batchedCons.m_phases.size(); ++iiPhase) + { + int iPhase = batchedCons.m_phaseOrder[iiPhase]; + const btBatchedConstraints::Range& phase = batchedCons.m_phases[iPhase]; + int grainSize = 1; + leastSquaresResidual += btParallelSum(phase.begin, phase.end, grainSize, loop); + } + return leastSquaresResidual; +} + +struct ContactRollingFrictionSolverLoop : public btIParallelSumBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btBatchedConstraints* m_bc; + + ContactRollingFrictionSolverLoop(btSequentialImpulseConstraintSolverMt* solver, const btBatchedConstraints* bc) + { + m_solver = solver; + m_bc = bc; + } + btScalar sumLoop(int iBegin, int iEnd) const BT_OVERRIDE + { +//\1("ContactFrictionSolverLoop"); + btScalar sum = 0; + for (int iBatch = iBegin; iBatch < iEnd; ++iBatch) + { + const btBatchedConstraints::Range& batch = m_bc->m_batches[iBatch]; + sum += m_solver->resolveMultipleContactRollingFrictionConstraints(m_bc->m_constraintIndices, batch.begin, batch.end); + } + return sum; + } +}; + +btScalar btSequentialImpulseConstraintSolverMt::resolveAllRollingFrictionConstraints() +{ +//\1("resolveAllRollingFrictionConstraints"); + btScalar leastSquaresResidual = 0.f; + // + // We do not generate batches for rolling friction constraints. We assume that + // one of two cases is true: + // + // 1. either most bodies in the simulation have rolling friction, in which case we can use the + // batches for contacts and use a lookup table to translate contact indices to rolling friction + // (ignoring any contact indices that don't map to a rolling friction constraint). As long as + // most contacts have a corresponding rolling friction constraint, this should parallelize well. + // + // -OR- + // + // 2. few bodies in the simulation have rolling friction, so it is not worth trying to use the + // batches from contacts as most of the contacts won't have corresponding rolling friction + // constraints and most threads would end up doing very little work. Most of the time would + // go to threading overhead, so we don't bother with threading. + // + int numRollingFrictionPoolConstraints = m_tmpSolverContactRollingFrictionConstraintPool.size(); + if (numRollingFrictionPoolConstraints >= m_tmpSolverContactConstraintPool.size()) + { + // use batching if there are many rolling friction constraints + const btBatchedConstraints& batchedCons = m_batchedContactConstraints; + ContactRollingFrictionSolverLoop loop(this, &batchedCons); + btScalar leastSquaresResidual = 0.f; + for (int iiPhase = 0; iiPhase < batchedCons.m_phases.size(); ++iiPhase) + { + int iPhase = batchedCons.m_phaseOrder[iiPhase]; + const btBatchedConstraints::Range& phase = batchedCons.m_phases[iPhase]; + int grainSize = 1; + leastSquaresResidual += btParallelSum(phase.begin, phase.end, grainSize, loop); + } + } + else + { + // no batching, also ignores SOLVER_RANDMIZE_ORDER + for (int j = 0; j < numRollingFrictionPoolConstraints; j++) + { + btSolverConstraint& rollingFrictionConstraint = m_tmpSolverContactRollingFrictionConstraintPool[j]; + if (rollingFrictionConstraint.m_frictionIndex >= 0) + { + btScalar totalImpulse = m_tmpSolverContactConstraintPool[rollingFrictionConstraint.m_frictionIndex].m_appliedImpulse; + if (totalImpulse > 0.0f) + { + btScalar rollingFrictionMagnitude = rollingFrictionConstraint.m_friction * totalImpulse; + if (rollingFrictionMagnitude > rollingFrictionConstraint.m_friction) + rollingFrictionMagnitude = rollingFrictionConstraint.m_friction; + + rollingFrictionConstraint.m_lowerLimit = -rollingFrictionMagnitude; + rollingFrictionConstraint.m_upperLimit = rollingFrictionMagnitude; + + btScalar residual = resolveSingleConstraintRowGeneric(m_tmpSolverBodyPool[rollingFrictionConstraint.m_solverBodyIdA], m_tmpSolverBodyPool[rollingFrictionConstraint.m_solverBodyIdB], rollingFrictionConstraint); + leastSquaresResidual += residual * residual; + } + } + } + } + return leastSquaresResidual; +} + +void btSequentialImpulseConstraintSolverMt::internalWriteBackContacts(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal) +{ +//\1("internalWriteBackContacts"); + writeBackContacts(iBegin, iEnd, infoGlobal); + //for ( int iContact = iBegin; iContact < iEnd; ++iContact) + //{ + // const btSolverConstraint& contactConstraint = m_tmpSolverContactConstraintPool[ iContact ]; + // btManifoldPoint* pt = (btManifoldPoint*) contactConstraint.m_originalContactPoint; + // btAssert( pt ); + // pt->m_appliedImpulse = contactConstraint.m_appliedImpulse; + // pt->m_appliedImpulseLateral1 = m_tmpSolverContactFrictionConstraintPool[ contactConstraint.m_frictionIndex ].m_appliedImpulse; + // if ( m_numFrictionDirections == 2 ) + // { + // pt->m_appliedImpulseLateral2 = m_tmpSolverContactFrictionConstraintPool[ contactConstraint.m_frictionIndex + 1 ].m_appliedImpulse; + // } + //} +} + +void btSequentialImpulseConstraintSolverMt::internalWriteBackJoints(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal) +{ +//\1("internalWriteBackJoints"); + writeBackJoints(iBegin, iEnd, infoGlobal); +} + +void btSequentialImpulseConstraintSolverMt::internalWriteBackBodies(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal) +{ +//\1("internalWriteBackBodies"); + writeBackBodies(iBegin, iEnd, infoGlobal); +} + +struct WriteContactPointsLoop : public btIParallelForBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btContactSolverInfo* m_infoGlobal; + + WriteContactPointsLoop(btSequentialImpulseConstraintSolverMt* solver, const btContactSolverInfo& infoGlobal) + { + m_solver = solver; + m_infoGlobal = &infoGlobal; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + m_solver->internalWriteBackContacts(iBegin, iEnd, *m_infoGlobal); + } +}; + +struct WriteJointsLoop : public btIParallelForBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btContactSolverInfo* m_infoGlobal; + + WriteJointsLoop(btSequentialImpulseConstraintSolverMt* solver, const btContactSolverInfo& infoGlobal) + { + m_solver = solver; + m_infoGlobal = &infoGlobal; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + m_solver->internalWriteBackJoints(iBegin, iEnd, *m_infoGlobal); + } +}; + +struct WriteBodiesLoop : public btIParallelForBody +{ + btSequentialImpulseConstraintSolverMt* m_solver; + const btContactSolverInfo* m_infoGlobal; + + WriteBodiesLoop(btSequentialImpulseConstraintSolverMt* solver, const btContactSolverInfo& infoGlobal) + { + m_solver = solver; + m_infoGlobal = &infoGlobal; + } + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + m_solver->internalWriteBackBodies(iBegin, iEnd, *m_infoGlobal); + } +}; + +btScalar btSequentialImpulseConstraintSolverMt::solveGroupCacheFriendlyFinish(btCollisionObject** bodies, int numBodies, const btContactSolverInfo& infoGlobal) +{ +//\1("solveGroupCacheFriendlyFinish"); + + if (infoGlobal.m_solverMode & SOLVER_USE_WARMSTARTING) + { + WriteContactPointsLoop loop(this, infoGlobal); + int grainSize = 500; + btParallelFor(0, m_tmpSolverContactConstraintPool.size(), grainSize, loop); + } + + { + WriteJointsLoop loop(this, infoGlobal); + int grainSize = 400; + btParallelFor(0, m_tmpSolverNonContactConstraintPool.size(), grainSize, loop); + } + { + WriteBodiesLoop loop(this, infoGlobal); + int grainSize = 100; + btParallelFor(0, m_tmpSolverBodyPool.size(), grainSize, loop); + } + + m_tmpSolverContactConstraintPool.resizeNoInitialize(0); + m_tmpSolverNonContactConstraintPool.resizeNoInitialize(0); + m_tmpSolverContactFrictionConstraintPool.resizeNoInitialize(0); + m_tmpSolverContactRollingFrictionConstraintPool.resizeNoInitialize(0); + + m_tmpSolverBodyPool.resizeNoInitialize(0); + return 0.f; +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp.i new file mode 100644 index 00000000..6f4256b6 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h new file mode 100644 index 00000000..73a99153 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h @@ -0,0 +1,150 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H +#define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H + +#include "btSequentialImpulseConstraintSolver.h" +#include "btBatchedConstraints.h" +#include "LinearMath/btThreads.h" + +/// +/// btSequentialImpulseConstraintSolverMt +/// +/// A multithreaded variant of the sequential impulse constraint solver. The constraints to be solved are grouped into +/// batches and phases where each batch of constraints within a given phase can be solved in parallel with the rest. +/// Ideally we want as few phases as possible, and each phase should have many batches, and all of the batches should +/// have about the same number of constraints. +/// This method works best on a large island of many constraints. +/// +/// Supports all of the features of the normal sequential impulse solver such as: +/// - split penetration impulse +/// - rolling friction +/// - interleaving constraints +/// - warmstarting +/// - 2 friction directions +/// - randomized constraint ordering +/// - early termination when leastSquaresResidualThreshold is satisfied +/// +/// When the SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS flag is enabled, unlike the normal SequentialImpulse solver, +/// the rolling friction is interleaved as well. +/// Interleaving the contact penetration constraints with friction reduces the number of parallel loops that need to be done, +/// which reduces threading overhead so it can be a performance win, however, it does seem to produce a less stable simulation, +/// at least on stacks of blocks. +/// +/// When the SOLVER_RANDMIZE_ORDER flag is enabled, the ordering of phases, and the ordering of constraints within each batch +/// is randomized, however it does not swap constraints between batches. +/// This is to avoid regenerating the batches for each solver iteration which would be quite costly in performance. +/// +/// Note that a non-zero leastSquaresResidualThreshold could possibly affect the determinism of the simulation +/// if the task scheduler's parallelSum operation is non-deterministic. The parallelSum operation can be non-deterministic +/// because floating point addition is not associative due to rounding errors. +/// The task scheduler can and should ensure that the result of any parallelSum operation is deterministic. +/// +ATTRIBUTE_ALIGNED16(class) +btSequentialImpulseConstraintSolverMt : public btSequentialImpulseConstraintSolver +{ +public: + virtual void solveGroupCacheFriendlySplitImpulseIterations(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) BT_OVERRIDE; + virtual btScalar solveSingleIteration(int iteration, btCollisionObject** bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) BT_OVERRIDE; + virtual btScalar solveGroupCacheFriendlySetup(btCollisionObject * *bodies, int numBodies, btPersistentManifold** manifoldPtr, int numManifolds, btTypedConstraint** constraints, int numConstraints, const btContactSolverInfo& infoGlobal, btIDebugDraw* debugDrawer) BT_OVERRIDE; + virtual btScalar solveGroupCacheFriendlyFinish(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal) BT_OVERRIDE; + + // temp struct used to collect info from persistent manifolds into a cache-friendly struct using multiple threads + struct btContactManifoldCachedInfo + { + static const int MAX_NUM_CONTACT_POINTS = 4; + + int numTouchingContacts; + int solverBodyIds[2]; + int contactIndex; + int rollingFrictionIndex; + bool contactHasRollingFriction[MAX_NUM_CONTACT_POINTS]; + btManifoldPoint* contactPoints[MAX_NUM_CONTACT_POINTS]; + }; + // temp struct used for setting up joint constraints in parallel + struct JointParams + { + int m_solverConstraint; + int m_solverBodyA; + int m_solverBodyB; + }; + void internalInitMultipleJoints(btTypedConstraint * *constraints, int iBegin, int iEnd); + void internalConvertMultipleJoints(const btAlignedObjectArray& jointParamsArray, btTypedConstraint** constraints, int iBegin, int iEnd, const btContactSolverInfo& infoGlobal); + + // parameters to control batching + static bool s_allowNestedParallelForLoops; // whether to allow nested parallel operations + static int s_minimumContactManifoldsForBatching; // don't even try to batch if fewer manifolds than this + static btBatchedConstraints::BatchingMethod s_contactBatchingMethod; + static btBatchedConstraints::BatchingMethod s_jointBatchingMethod; + static int s_minBatchSize; // desired number of constraints per batch + static int s_maxBatchSize; + +protected: + static const int CACHE_LINE_SIZE = 64; + + btBatchedConstraints m_batchedContactConstraints; + btBatchedConstraints m_batchedJointConstraints; + int m_numFrictionDirections; + bool m_useBatching; + bool m_useObsoleteJointConstraints; + btAlignedObjectArray m_manifoldCachedInfoArray; + btAlignedObjectArray m_rollingFrictionIndexTable; // lookup table mapping contact index to rolling friction index + btSpinMutex m_bodySolverArrayMutex; + char m_antiFalseSharingPadding[CACHE_LINE_SIZE]; // padding to keep mutexes in separate cachelines + btSpinMutex m_kinematicBodyUniqueIdToSolverBodyTableMutex; + btAlignedObjectArray m_scratchMemory; + + virtual void randomizeConstraintOrdering(int iteration, int numIterations); + virtual btScalar resolveAllJointConstraints(int iteration); + virtual btScalar resolveAllContactConstraints(); + virtual btScalar resolveAllContactFrictionConstraints(); + virtual btScalar resolveAllContactConstraintsInterleaved(); + virtual btScalar resolveAllRollingFrictionConstraints(); + + virtual void setupBatchedContactConstraints(); + virtual void setupBatchedJointConstraints(); + virtual void convertJoints(btTypedConstraint * *constraints, int numConstraints, const btContactSolverInfo& infoGlobal) BT_OVERRIDE; + virtual void convertContacts(btPersistentManifold * *manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal) BT_OVERRIDE; + virtual void convertBodies(btCollisionObject * *bodies, int numBodies, const btContactSolverInfo& infoGlobal) BT_OVERRIDE; + + int getOrInitSolverBodyThreadsafe(btCollisionObject & body, btScalar timeStep); + void allocAllContactConstraints(btPersistentManifold * *manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal); + void setupAllContactConstraints(const btContactSolverInfo& infoGlobal); + void randomizeBatchedConstraintOrdering(btBatchedConstraints * batchedConstraints); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btSequentialImpulseConstraintSolverMt(); + virtual ~btSequentialImpulseConstraintSolverMt(); + + btScalar resolveMultipleJointConstraints(const btAlignedObjectArray& consIndices, int batchBegin, int batchEnd, int iteration); + btScalar resolveMultipleContactConstraints(const btAlignedObjectArray& consIndices, int batchBegin, int batchEnd); + btScalar resolveMultipleContactSplitPenetrationImpulseConstraints(const btAlignedObjectArray& consIndices, int batchBegin, int batchEnd); + btScalar resolveMultipleContactFrictionConstraints(const btAlignedObjectArray& consIndices, int batchBegin, int batchEnd); + btScalar resolveMultipleContactRollingFrictionConstraints(const btAlignedObjectArray& consIndices, int batchBegin, int batchEnd); + btScalar resolveMultipleContactConstraintsInterleaved(const btAlignedObjectArray& contactIndices, int batchBegin, int batchEnd); + + void internalCollectContactManifoldCachedInfo(btContactManifoldCachedInfo * cachedInfoArray, btPersistentManifold * *manifoldPtr, int numManifolds, const btContactSolverInfo& infoGlobal); + void internalAllocContactConstraints(const btContactManifoldCachedInfo* cachedInfoArray, int numManifolds); + void internalSetupContactConstraints(int iContactConstraint, const btContactSolverInfo& infoGlobal); + void internalConvertBodies(btCollisionObject * *bodies, int iBegin, int iEnd, const btContactSolverInfo& infoGlobal); + void internalWriteBackContacts(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal); + void internalWriteBackJoints(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal); + void internalWriteBackBodies(int iBegin, int iEnd, const btContactSolverInfo& infoGlobal); +}; + +#endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h.i new file mode 100644 index 00000000..db427eed --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.cpp new file mode 100644 index 00000000..e42223c4 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.cpp @@ -0,0 +1,823 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +Added by Roman Ponomarev (rponom@gmail.com) +April 04, 2008 +*/ + +#include "btSliderConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btTransformUtil.h" +#include + +#define USE_OFFSET_FOR_CONSTANT_FRAME true + +void btSliderConstraint::initParams() +{ + m_lowerLinLimit = btScalar(1.0); + m_upperLinLimit = btScalar(-1.0); + m_lowerAngLimit = btScalar(0.); + m_upperAngLimit = btScalar(0.); + m_softnessDirLin = SLIDER_CONSTRAINT_DEF_SOFTNESS; + m_restitutionDirLin = SLIDER_CONSTRAINT_DEF_RESTITUTION; + m_dampingDirLin = btScalar(0.); + m_cfmDirLin = SLIDER_CONSTRAINT_DEF_CFM; + m_softnessDirAng = SLIDER_CONSTRAINT_DEF_SOFTNESS; + m_restitutionDirAng = SLIDER_CONSTRAINT_DEF_RESTITUTION; + m_dampingDirAng = btScalar(0.); + m_cfmDirAng = SLIDER_CONSTRAINT_DEF_CFM; + m_softnessOrthoLin = SLIDER_CONSTRAINT_DEF_SOFTNESS; + m_restitutionOrthoLin = SLIDER_CONSTRAINT_DEF_RESTITUTION; + m_dampingOrthoLin = SLIDER_CONSTRAINT_DEF_DAMPING; + m_cfmOrthoLin = SLIDER_CONSTRAINT_DEF_CFM; + m_softnessOrthoAng = SLIDER_CONSTRAINT_DEF_SOFTNESS; + m_restitutionOrthoAng = SLIDER_CONSTRAINT_DEF_RESTITUTION; + m_dampingOrthoAng = SLIDER_CONSTRAINT_DEF_DAMPING; + m_cfmOrthoAng = SLIDER_CONSTRAINT_DEF_CFM; + m_softnessLimLin = SLIDER_CONSTRAINT_DEF_SOFTNESS; + m_restitutionLimLin = SLIDER_CONSTRAINT_DEF_RESTITUTION; + m_dampingLimLin = SLIDER_CONSTRAINT_DEF_DAMPING; + m_cfmLimLin = SLIDER_CONSTRAINT_DEF_CFM; + m_softnessLimAng = SLIDER_CONSTRAINT_DEF_SOFTNESS; + m_restitutionLimAng = SLIDER_CONSTRAINT_DEF_RESTITUTION; + m_dampingLimAng = SLIDER_CONSTRAINT_DEF_DAMPING; + m_cfmLimAng = SLIDER_CONSTRAINT_DEF_CFM; + + m_poweredLinMotor = false; + m_targetLinMotorVelocity = btScalar(0.); + m_maxLinMotorForce = btScalar(0.); + m_accumulatedLinMotorImpulse = btScalar(0.0); + + m_poweredAngMotor = false; + m_targetAngMotorVelocity = btScalar(0.); + m_maxAngMotorForce = btScalar(0.); + m_accumulatedAngMotorImpulse = btScalar(0.0); + + m_flags = 0; + m_flags = 0; + + m_useOffsetForConstraintFrame = USE_OFFSET_FOR_CONSTANT_FRAME; + + calculateTransforms(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); +} + +btSliderConstraint::btSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA) + : btTypedConstraint(SLIDER_CONSTRAINT_TYPE, rbA, rbB), + m_useSolveConstraintObsolete(false), + m_frameInA(frameInA), + m_frameInB(frameInB), + m_useLinearReferenceFrameA(useLinearReferenceFrameA) +{ + initParams(); +} + +btSliderConstraint::btSliderConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameA) + : btTypedConstraint(SLIDER_CONSTRAINT_TYPE, getFixedBody(), rbB), + m_useSolveConstraintObsolete(false), + m_frameInB(frameInB), + m_useLinearReferenceFrameA(useLinearReferenceFrameA) +{ + ///not providing rigidbody A means implicitly using worldspace for body A + m_frameInA = rbB.getCenterOfMassTransform() * m_frameInB; + // m_frameInA.getOrigin() = m_rbA.getCenterOfMassTransform()(m_frameInA.getOrigin()); + + initParams(); +} + +void btSliderConstraint::getInfo1(btConstraintInfo1* info) +{ + if (m_useSolveConstraintObsolete) + { + info->m_numConstraintRows = 0; + info->nub = 0; + } + else + { + info->m_numConstraintRows = 4; // Fixed 2 linear + 2 angular + info->nub = 2; + //prepare constraint + calculateTransforms(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); + testAngLimits(); + testLinLimits(); + if (getSolveLinLimit() || getPoweredLinMotor()) + { + info->m_numConstraintRows++; // limit 3rd linear as well + info->nub--; + } + if (getSolveAngLimit() || getPoweredAngMotor()) + { + info->m_numConstraintRows++; // limit 3rd angular as well + info->nub--; + } + } +} + +void btSliderConstraint::getInfo1NonVirtual(btConstraintInfo1* info) +{ + info->m_numConstraintRows = 6; // Fixed 2 linear + 2 angular + 1 limit (even if not used) + info->nub = 0; +} + +void btSliderConstraint::getInfo2(btConstraintInfo2* info) +{ + getInfo2NonVirtual(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getLinearVelocity(), m_rbB.getLinearVelocity(), m_rbA.getInvMass(), m_rbB.getInvMass()); +} + +void btSliderConstraint::calculateTransforms(const btTransform& transA, const btTransform& transB) +{ + if (m_useLinearReferenceFrameA || (!m_useSolveConstraintObsolete)) + { + m_calculatedTransformA = transA * m_frameInA; + m_calculatedTransformB = transB * m_frameInB; + } + else + { + m_calculatedTransformA = transB * m_frameInB; + m_calculatedTransformB = transA * m_frameInA; + } + m_realPivotAInW = m_calculatedTransformA.getOrigin(); + m_realPivotBInW = m_calculatedTransformB.getOrigin(); + m_sliderAxis = m_calculatedTransformA.getBasis().getColumn(0); // along X + if (m_useLinearReferenceFrameA || m_useSolveConstraintObsolete) + { + m_delta = m_realPivotBInW - m_realPivotAInW; + } + else + { + m_delta = m_realPivotAInW - m_realPivotBInW; + } + m_projPivotInW = m_realPivotAInW + m_sliderAxis.dot(m_delta) * m_sliderAxis; + btVector3 normalWorld; + int i; + //linear part + for (i = 0; i < 3; i++) + { + normalWorld = m_calculatedTransformA.getBasis().getColumn(i); + m_depth[i] = m_delta.dot(normalWorld); + } +} + +void btSliderConstraint::testLinLimits(void) +{ + m_solveLinLim = false; + m_linPos = m_depth[0]; + if (m_lowerLinLimit <= m_upperLinLimit) + { + if (m_depth[0] > m_upperLinLimit) + { + m_depth[0] -= m_upperLinLimit; + m_solveLinLim = true; + } + else if (m_depth[0] < m_lowerLinLimit) + { + m_depth[0] -= m_lowerLinLimit; + m_solveLinLim = true; + } + else + { + m_depth[0] = btScalar(0.); + } + } + else + { + m_depth[0] = btScalar(0.); + } +} + +void btSliderConstraint::testAngLimits(void) +{ + m_angDepth = btScalar(0.); + m_solveAngLim = false; + if (m_lowerAngLimit <= m_upperAngLimit) + { + const btVector3 axisA0 = m_calculatedTransformA.getBasis().getColumn(1); + const btVector3 axisA1 = m_calculatedTransformA.getBasis().getColumn(2); + const btVector3 axisB0 = m_calculatedTransformB.getBasis().getColumn(1); + // btScalar rot = btAtan2Fast(axisB0.dot(axisA1), axisB0.dot(axisA0)); + btScalar rot = btAtan2(axisB0.dot(axisA1), axisB0.dot(axisA0)); + rot = btAdjustAngleToLimits(rot, m_lowerAngLimit, m_upperAngLimit); + m_angPos = rot; + if (rot < m_lowerAngLimit) + { + m_angDepth = rot - m_lowerAngLimit; + m_solveAngLim = true; + } + else if (rot > m_upperAngLimit) + { + m_angDepth = rot - m_upperAngLimit; + m_solveAngLim = true; + } + } +} + +btVector3 btSliderConstraint::getAncorInA(void) +{ + btVector3 ancorInA; + ancorInA = m_realPivotAInW + (m_lowerLinLimit + m_upperLinLimit) * btScalar(0.5) * m_sliderAxis; + ancorInA = m_rbA.getCenterOfMassTransform().inverse() * ancorInA; + return ancorInA; +} + +btVector3 btSliderConstraint::getAncorInB(void) +{ + btVector3 ancorInB; + ancorInB = m_frameInB.getOrigin(); + return ancorInB; +} + +void btSliderConstraint::getInfo2NonVirtual(btConstraintInfo2* info, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, btScalar rbAinvMass, btScalar rbBinvMass) +{ + const btTransform& trA = getCalculatedTransformA(); + const btTransform& trB = getCalculatedTransformB(); + + btAssert(!m_useSolveConstraintObsolete); + int i, s = info->rowskip; + + btScalar signFact = m_useLinearReferenceFrameA ? btScalar(1.0f) : btScalar(-1.0f); + + // difference between frames in WCS + btVector3 ofs = trB.getOrigin() - trA.getOrigin(); + // now get weight factors depending on masses + btScalar miA = rbAinvMass; + btScalar miB = rbBinvMass; + bool hasStaticBody = (miA < SIMD_EPSILON) || (miB < SIMD_EPSILON); + btScalar miS = miA + miB; + btScalar factA, factB; + if (miS > btScalar(0.f)) + { + factA = miB / miS; + } + else + { + factA = btScalar(0.5f); + } + factB = btScalar(1.0f) - factA; + btVector3 ax1, p, q; + btVector3 ax1A = trA.getBasis().getColumn(0); + btVector3 ax1B = trB.getBasis().getColumn(0); + if (m_useOffsetForConstraintFrame) + { + // get the desired direction of slider axis + // as weighted sum of X-orthos of frameA and frameB in WCS + ax1 = ax1A * factA + ax1B * factB; + ax1.normalize(); + // construct two orthos to slider axis + btPlaneSpace1(ax1, p, q); + } + else + { // old way - use frameA + ax1 = trA.getBasis().getColumn(0); + // get 2 orthos to slider axis (Y, Z) + p = trA.getBasis().getColumn(1); + q = trA.getBasis().getColumn(2); + } + // make rotations around these orthos equal + // the slider axis should be the only unconstrained + // rotational axis, the angular velocity of the two bodies perpendicular to + // the slider axis should be equal. thus the constraint equations are + // p*w1 - p*w2 = 0 + // q*w1 - q*w2 = 0 + // where p and q are unit vectors normal to the slider axis, and w1 and w2 + // are the angular velocity vectors of the two bodies. + info->m_J1angularAxis[0] = p[0]; + info->m_J1angularAxis[1] = p[1]; + info->m_J1angularAxis[2] = p[2]; + info->m_J1angularAxis[s + 0] = q[0]; + info->m_J1angularAxis[s + 1] = q[1]; + info->m_J1angularAxis[s + 2] = q[2]; + + info->m_J2angularAxis[0] = -p[0]; + info->m_J2angularAxis[1] = -p[1]; + info->m_J2angularAxis[2] = -p[2]; + info->m_J2angularAxis[s + 0] = -q[0]; + info->m_J2angularAxis[s + 1] = -q[1]; + info->m_J2angularAxis[s + 2] = -q[2]; + // compute the right hand side of the constraint equation. set relative + // body velocities along p and q to bring the slider back into alignment. + // if ax1A,ax1B are the unit length slider axes as computed from bodyA and + // bodyB, we need to rotate both bodies along the axis u = (ax1 x ax2). + // if "theta" is the angle between ax1 and ax2, we need an angular velocity + // along u to cover angle erp*theta in one step : + // |angular_velocity| = angle/time = erp*theta / stepsize + // = (erp*fps) * theta + // angular_velocity = |angular_velocity| * (ax1 x ax2) / |ax1 x ax2| + // = (erp*fps) * theta * (ax1 x ax2) / sin(theta) + // ...as ax1 and ax2 are unit length. if theta is smallish, + // theta ~= sin(theta), so + // angular_velocity = (erp*fps) * (ax1 x ax2) + // ax1 x ax2 is in the plane space of ax1, so we project the angular + // velocity to p and q to find the right hand side. + // btScalar k = info->fps * info->erp * getSoftnessOrthoAng(); + btScalar currERP = (m_flags & BT_SLIDER_FLAGS_ERP_ORTANG) ? m_softnessOrthoAng : m_softnessOrthoAng * info->erp; + btScalar k = info->fps * currERP; + + btVector3 u = ax1A.cross(ax1B); + info->m_constraintError[0] = k * u.dot(p); + info->m_constraintError[s] = k * u.dot(q); + if (m_flags & BT_SLIDER_FLAGS_CFM_ORTANG) + { + info->cfm[0] = m_cfmOrthoAng; + info->cfm[s] = m_cfmOrthoAng; + } + + int nrow = 1; // last filled row + int srow; + btScalar limit_err; + int limit; + + // next two rows. + // we want: velA + wA x relA == velB + wB x relB ... but this would + // result in three equations, so we project along two orthos to the slider axis + + btTransform bodyA_trans = transA; + btTransform bodyB_trans = transB; + nrow++; + int s2 = nrow * s; + nrow++; + int s3 = nrow * s; + btVector3 tmpA(0, 0, 0), tmpB(0, 0, 0), relA(0, 0, 0), relB(0, 0, 0), c(0, 0, 0); + if (m_useOffsetForConstraintFrame) + { + // get vector from bodyB to frameB in WCS + relB = trB.getOrigin() - bodyB_trans.getOrigin(); + // get its projection to slider axis + btVector3 projB = ax1 * relB.dot(ax1); + // get vector directed from bodyB to slider axis (and orthogonal to it) + btVector3 orthoB = relB - projB; + // same for bodyA + relA = trA.getOrigin() - bodyA_trans.getOrigin(); + btVector3 projA = ax1 * relA.dot(ax1); + btVector3 orthoA = relA - projA; + // get desired offset between frames A and B along slider axis + btScalar sliderOffs = m_linPos - m_depth[0]; + // desired vector from projection of center of bodyA to projection of center of bodyB to slider axis + btVector3 totalDist = projA + ax1 * sliderOffs - projB; + // get offset vectors relA and relB + relA = orthoA + totalDist * factA; + relB = orthoB - totalDist * factB; + // now choose average ortho to slider axis + p = orthoB * factA + orthoA * factB; + btScalar len2 = p.length2(); + if (len2 > SIMD_EPSILON) + { + p /= btSqrt(len2); + } + else + { + p = trA.getBasis().getColumn(1); + } + // make one more ortho + q = ax1.cross(p); + // fill two rows + tmpA = relA.cross(p); + tmpB = relB.cross(p); + for (i = 0; i < 3; i++) info->m_J1angularAxis[s2 + i] = tmpA[i]; + for (i = 0; i < 3; i++) info->m_J2angularAxis[s2 + i] = -tmpB[i]; + tmpA = relA.cross(q); + tmpB = relB.cross(q); + if (hasStaticBody && getSolveAngLimit()) + { // to make constraint between static and dynamic objects more rigid + // remove wA (or wB) from equation if angular limit is hit + tmpB *= factB; + tmpA *= factA; + } + for (i = 0; i < 3; i++) info->m_J1angularAxis[s3 + i] = tmpA[i]; + for (i = 0; i < 3; i++) info->m_J2angularAxis[s3 + i] = -tmpB[i]; + for (i = 0; i < 3; i++) info->m_J1linearAxis[s2 + i] = p[i]; + for (i = 0; i < 3; i++) info->m_J1linearAxis[s3 + i] = q[i]; + for (i = 0; i < 3; i++) info->m_J2linearAxis[s2 + i] = -p[i]; + for (i = 0; i < 3; i++) info->m_J2linearAxis[s3 + i] = -q[i]; + } + else + { // old way - maybe incorrect if bodies are not on the slider axis + // see discussion "Bug in slider constraint" http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?f=9&t=4024&start=0 + c = bodyB_trans.getOrigin() - bodyA_trans.getOrigin(); + btVector3 tmp = c.cross(p); + for (i = 0; i < 3; i++) info->m_J1angularAxis[s2 + i] = factA * tmp[i]; + for (i = 0; i < 3; i++) info->m_J2angularAxis[s2 + i] = factB * tmp[i]; + tmp = c.cross(q); + for (i = 0; i < 3; i++) info->m_J1angularAxis[s3 + i] = factA * tmp[i]; + for (i = 0; i < 3; i++) info->m_J2angularAxis[s3 + i] = factB * tmp[i]; + + for (i = 0; i < 3; i++) info->m_J1linearAxis[s2 + i] = p[i]; + for (i = 0; i < 3; i++) info->m_J1linearAxis[s3 + i] = q[i]; + for (i = 0; i < 3; i++) info->m_J2linearAxis[s2 + i] = -p[i]; + for (i = 0; i < 3; i++) info->m_J2linearAxis[s3 + i] = -q[i]; + } + // compute two elements of right hand side + + // k = info->fps * info->erp * getSoftnessOrthoLin(); + currERP = (m_flags & BT_SLIDER_FLAGS_ERP_ORTLIN) ? m_softnessOrthoLin : m_softnessOrthoLin * info->erp; + k = info->fps * currERP; + + btScalar rhs = k * p.dot(ofs); + info->m_constraintError[s2] = rhs; + rhs = k * q.dot(ofs); + info->m_constraintError[s3] = rhs; + if (m_flags & BT_SLIDER_FLAGS_CFM_ORTLIN) + { + info->cfm[s2] = m_cfmOrthoLin; + info->cfm[s3] = m_cfmOrthoLin; + } + + // check linear limits + limit_err = btScalar(0.0); + limit = 0; + if (getSolveLinLimit()) + { + limit_err = getLinDepth() * signFact; + limit = (limit_err > btScalar(0.0)) ? 2 : 1; + } + bool powered = getPoweredLinMotor(); + // if the slider has joint limits or motor, add in the extra row + if (limit || powered) + { + nrow++; + srow = nrow * info->rowskip; + info->m_J1linearAxis[srow + 0] = ax1[0]; + info->m_J1linearAxis[srow + 1] = ax1[1]; + info->m_J1linearAxis[srow + 2] = ax1[2]; + info->m_J2linearAxis[srow + 0] = -ax1[0]; + info->m_J2linearAxis[srow + 1] = -ax1[1]; + info->m_J2linearAxis[srow + 2] = -ax1[2]; + // linear torque decoupling step: + // + // we have to be careful that the linear constraint forces (+/- ax1) applied to the two bodies + // do not create a torque couple. in other words, the points that the + // constraint force is applied at must lie along the same ax1 axis. + // a torque couple will result in limited slider-jointed free + // bodies from gaining angular momentum. + if (m_useOffsetForConstraintFrame) + { + // this is needed only when bodyA and bodyB are both dynamic. + if (!hasStaticBody) + { + tmpA = relA.cross(ax1); + tmpB = relB.cross(ax1); + info->m_J1angularAxis[srow + 0] = tmpA[0]; + info->m_J1angularAxis[srow + 1] = tmpA[1]; + info->m_J1angularAxis[srow + 2] = tmpA[2]; + info->m_J2angularAxis[srow + 0] = -tmpB[0]; + info->m_J2angularAxis[srow + 1] = -tmpB[1]; + info->m_J2angularAxis[srow + 2] = -tmpB[2]; + } + } + else + { // The old way. May be incorrect if bodies are not on the slider axis + btVector3 ltd; // Linear Torque Decoupling vector (a torque) + ltd = c.cross(ax1); + info->m_J1angularAxis[srow + 0] = factA * ltd[0]; + info->m_J1angularAxis[srow + 1] = factA * ltd[1]; + info->m_J1angularAxis[srow + 2] = factA * ltd[2]; + info->m_J2angularAxis[srow + 0] = factB * ltd[0]; + info->m_J2angularAxis[srow + 1] = factB * ltd[1]; + info->m_J2angularAxis[srow + 2] = factB * ltd[2]; + } + // right-hand part + btScalar lostop = getLowerLinLimit(); + btScalar histop = getUpperLinLimit(); + if (limit && (lostop == histop)) + { // the joint motor is ineffective + powered = false; + } + info->m_constraintError[srow] = 0.; + info->m_lowerLimit[srow] = 0.; + info->m_upperLimit[srow] = 0.; + currERP = (m_flags & BT_SLIDER_FLAGS_ERP_LIMLIN) ? m_softnessLimLin : info->erp; + if (powered) + { + if (m_flags & BT_SLIDER_FLAGS_CFM_DIRLIN) + { + info->cfm[srow] = m_cfmDirLin; + } + btScalar tag_vel = getTargetLinMotorVelocity(); + btScalar mot_fact = getMotorFactor(m_linPos, m_lowerLinLimit, m_upperLinLimit, tag_vel, info->fps * currERP); + info->m_constraintError[srow] -= signFact * mot_fact * getTargetLinMotorVelocity(); + info->m_lowerLimit[srow] += -getMaxLinMotorForce() / info->fps; + info->m_upperLimit[srow] += getMaxLinMotorForce() / info->fps; + } + if (limit) + { + k = info->fps * currERP; + info->m_constraintError[srow] += k * limit_err; + if (m_flags & BT_SLIDER_FLAGS_CFM_LIMLIN) + { + info->cfm[srow] = m_cfmLimLin; + } + if (lostop == histop) + { // limited low and high simultaneously + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + else if (limit == 1) + { // low limit + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = 0; + } + else + { // high limit + info->m_lowerLimit[srow] = 0; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + // bounce (we'll use slider parameter abs(1.0 - m_dampingLimLin) for that) + btScalar bounce = btFabs(btScalar(1.0) - getDampingLimLin()); + if (bounce > btScalar(0.0)) + { + btScalar vel = linVelA.dot(ax1); + vel -= linVelB.dot(ax1); + vel *= signFact; + // only apply bounce if the velocity is incoming, and if the + // resulting c[] exceeds what we already have. + if (limit == 1) + { // low limit + if (vel < 0) + { + btScalar newc = -bounce * vel; + if (newc > info->m_constraintError[srow]) + { + info->m_constraintError[srow] = newc; + } + } + } + else + { // high limit - all those computations are reversed + if (vel > 0) + { + btScalar newc = -bounce * vel; + if (newc < info->m_constraintError[srow]) + { + info->m_constraintError[srow] = newc; + } + } + } + } + info->m_constraintError[srow] *= getSoftnessLimLin(); + } // if(limit) + } // if linear limit + // check angular limits + limit_err = btScalar(0.0); + limit = 0; + if (getSolveAngLimit()) + { + limit_err = getAngDepth(); + limit = (limit_err > btScalar(0.0)) ? 1 : 2; + } + // if the slider has joint limits, add in the extra row + powered = getPoweredAngMotor(); + if (limit || powered) + { + nrow++; + srow = nrow * info->rowskip; + info->m_J1angularAxis[srow + 0] = ax1[0]; + info->m_J1angularAxis[srow + 1] = ax1[1]; + info->m_J1angularAxis[srow + 2] = ax1[2]; + + info->m_J2angularAxis[srow + 0] = -ax1[0]; + info->m_J2angularAxis[srow + 1] = -ax1[1]; + info->m_J2angularAxis[srow + 2] = -ax1[2]; + + btScalar lostop = getLowerAngLimit(); + btScalar histop = getUpperAngLimit(); + if (limit && (lostop == histop)) + { // the joint motor is ineffective + powered = false; + } + currERP = (m_flags & BT_SLIDER_FLAGS_ERP_LIMANG) ? m_softnessLimAng : info->erp; + if (powered) + { + if (m_flags & BT_SLIDER_FLAGS_CFM_DIRANG) + { + info->cfm[srow] = m_cfmDirAng; + } + btScalar mot_fact = getMotorFactor(m_angPos, m_lowerAngLimit, m_upperAngLimit, getTargetAngMotorVelocity(), info->fps * currERP); + info->m_constraintError[srow] = mot_fact * getTargetAngMotorVelocity(); + info->m_lowerLimit[srow] = -getMaxAngMotorForce() / info->fps; + info->m_upperLimit[srow] = getMaxAngMotorForce() / info->fps; + } + if (limit) + { + k = info->fps * currERP; + info->m_constraintError[srow] += k * limit_err; + if (m_flags & BT_SLIDER_FLAGS_CFM_LIMANG) + { + info->cfm[srow] = m_cfmLimAng; + } + if (lostop == histop) + { + // limited low and high simultaneously + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + else if (limit == 1) + { // low limit + info->m_lowerLimit[srow] = 0; + info->m_upperLimit[srow] = SIMD_INFINITY; + } + else + { // high limit + info->m_lowerLimit[srow] = -SIMD_INFINITY; + info->m_upperLimit[srow] = 0; + } + // bounce (we'll use slider parameter abs(1.0 - m_dampingLimAng) for that) + btScalar bounce = btFabs(btScalar(1.0) - getDampingLimAng()); + if (bounce > btScalar(0.0)) + { + btScalar vel = m_rbA.getAngularVelocity().dot(ax1); + vel -= m_rbB.getAngularVelocity().dot(ax1); + // only apply bounce if the velocity is incoming, and if the + // resulting c[] exceeds what we already have. + if (limit == 1) + { // low limit + if (vel < 0) + { + btScalar newc = -bounce * vel; + if (newc > info->m_constraintError[srow]) + { + info->m_constraintError[srow] = newc; + } + } + } + else + { // high limit - all those computations are reversed + if (vel > 0) + { + btScalar newc = -bounce * vel; + if (newc < info->m_constraintError[srow]) + { + info->m_constraintError[srow] = newc; + } + } + } + } + info->m_constraintError[srow] *= getSoftnessLimAng(); + } // if(limit) + } // if angular limit or powered +} + +///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). +///If no axis is provided, it uses the default axis for this constraint. +void btSliderConstraint::setParam(int num, btScalar value, int axis) +{ + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + if (axis < 1) + { + m_softnessLimLin = value; + m_flags |= BT_SLIDER_FLAGS_ERP_LIMLIN; + } + else if (axis < 3) + { + m_softnessOrthoLin = value; + m_flags |= BT_SLIDER_FLAGS_ERP_ORTLIN; + } + else if (axis == 3) + { + m_softnessLimAng = value; + m_flags |= BT_SLIDER_FLAGS_ERP_LIMANG; + } + else if (axis < 6) + { + m_softnessOrthoAng = value; + m_flags |= BT_SLIDER_FLAGS_ERP_ORTANG; + } + else + { + btAssertConstrParams(0); + } + break; + case BT_CONSTRAINT_CFM: + if (axis < 1) + { + m_cfmDirLin = value; + m_flags |= BT_SLIDER_FLAGS_CFM_DIRLIN; + } + else if (axis == 3) + { + m_cfmDirAng = value; + m_flags |= BT_SLIDER_FLAGS_CFM_DIRANG; + } + else + { + btAssertConstrParams(0); + } + break; + case BT_CONSTRAINT_STOP_CFM: + if (axis < 1) + { + m_cfmLimLin = value; + m_flags |= BT_SLIDER_FLAGS_CFM_LIMLIN; + } + else if (axis < 3) + { + m_cfmOrthoLin = value; + m_flags |= BT_SLIDER_FLAGS_CFM_ORTLIN; + } + else if (axis == 3) + { + m_cfmLimAng = value; + m_flags |= BT_SLIDER_FLAGS_CFM_LIMANG; + } + else if (axis < 6) + { + m_cfmOrthoAng = value; + m_flags |= BT_SLIDER_FLAGS_CFM_ORTANG; + } + else + { + btAssertConstrParams(0); + } + break; + } +} + +///return the local value of parameter +btScalar btSliderConstraint::getParam(int num, int axis) const +{ + btScalar retVal(SIMD_INFINITY); + switch (num) + { + case BT_CONSTRAINT_STOP_ERP: + if (axis < 1) + { + btAssertConstrParams(m_flags & BT_SLIDER_FLAGS_ERP_LIMLIN); + retVal = m_softnessLimLin; + } + else if (axis < 3) + { + btAssertConstrParams(m_flags & BT_SLIDER_FLAGS_ERP_ORTLIN); + retVal = m_softnessOrthoLin; + } + else if (axis == 3) + { + btAssertConstrParams(m_flags & BT_SLIDER_FLAGS_ERP_LIMANG); + retVal = m_softnessLimAng; + } + else if (axis < 6) + { + btAssertConstrParams(m_flags & BT_SLIDER_FLAGS_ERP_ORTANG); + retVal = m_softnessOrthoAng; + } + else + { + btAssertConstrParams(0); + } + break; + case BT_CONSTRAINT_CFM: + if (axis < 1) + { + btAssertConstrParams(m_flags & BT_SLIDER_FLAGS_CFM_DIRLIN); + retVal = m_cfmDirLin; + } + else if (axis == 3) + { + btAssertConstrParams(m_flags & BT_SLIDER_FLAGS_CFM_DIRANG); + retVal = m_cfmDirAng; + } + else + { + btAssertConstrParams(0); + } + break; + case BT_CONSTRAINT_STOP_CFM: + if (axis < 1) + { + btAssertConstrParams(m_flags & BT_SLIDER_FLAGS_CFM_LIMLIN); + retVal = m_cfmLimLin; + } + else if (axis < 3) + { + btAssertConstrParams(m_flags & BT_SLIDER_FLAGS_CFM_ORTLIN); + retVal = m_cfmOrthoLin; + } + else if (axis == 3) + { + btAssertConstrParams(m_flags & BT_SLIDER_FLAGS_CFM_LIMANG); + retVal = m_cfmLimAng; + } + else if (axis < 6) + { + btAssertConstrParams(m_flags & BT_SLIDER_FLAGS_CFM_ORTANG); + retVal = m_cfmOrthoAng; + } + else + { + btAssertConstrParams(0); + } + break; + } + return retVal; +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.cpp.i new file mode 100644 index 00000000..86218df4 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btSliderConstraint.cpp ---------------- + +// %include "BulletDynamics/ConstraintSolver/btSliderConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btSliderConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.h new file mode 100644 index 00000000..75b18575 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.h @@ -0,0 +1,349 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +Added by Roman Ponomarev (rponom@gmail.com) +April 04, 2008 + +TODO: + - add clamping od accumulated impulse to improve stability + - add conversion for ODE constraint solver +*/ + +#ifndef BT_SLIDER_CONSTRAINT_H +#define BT_SLIDER_CONSTRAINT_H + +#include "LinearMath/btScalar.h" //for BT_USE_DOUBLE_PRECISION + +#ifdef BT_USE_DOUBLE_PRECISION +#define btSliderConstraintData2 btSliderConstraintDoubleData +#define btSliderConstraintDataName "btSliderConstraintDoubleData" +#else +#define btSliderConstraintData2 btSliderConstraintData +#define btSliderConstraintDataName "btSliderConstraintData" +#endif //BT_USE_DOUBLE_PRECISION + +#include "LinearMath/btVector3.h" +#include "btJacobianEntry.h" +#include "btTypedConstraint.h" + +class btRigidBody; + +#define SLIDER_CONSTRAINT_DEF_SOFTNESS (btScalar(1.0)) +#define SLIDER_CONSTRAINT_DEF_DAMPING (btScalar(1.0)) +#define SLIDER_CONSTRAINT_DEF_RESTITUTION (btScalar(0.7)) +#define SLIDER_CONSTRAINT_DEF_CFM (btScalar(0.f)) + +enum btSliderFlags +{ + BT_SLIDER_FLAGS_CFM_DIRLIN = (1 << 0), + BT_SLIDER_FLAGS_ERP_DIRLIN = (1 << 1), + BT_SLIDER_FLAGS_CFM_DIRANG = (1 << 2), + BT_SLIDER_FLAGS_ERP_DIRANG = (1 << 3), + BT_SLIDER_FLAGS_CFM_ORTLIN = (1 << 4), + BT_SLIDER_FLAGS_ERP_ORTLIN = (1 << 5), + BT_SLIDER_FLAGS_CFM_ORTANG = (1 << 6), + BT_SLIDER_FLAGS_ERP_ORTANG = (1 << 7), + BT_SLIDER_FLAGS_CFM_LIMLIN = (1 << 8), + BT_SLIDER_FLAGS_ERP_LIMLIN = (1 << 9), + BT_SLIDER_FLAGS_CFM_LIMANG = (1 << 10), + BT_SLIDER_FLAGS_ERP_LIMANG = (1 << 11) +}; + +ATTRIBUTE_ALIGNED16(class) +btSliderConstraint : public btTypedConstraint +{ +protected: + ///for backwards compatibility during the transition to 'getInfo/getInfo2' + bool m_useSolveConstraintObsolete; + bool m_useOffsetForConstraintFrame; + btTransform m_frameInA; + btTransform m_frameInB; + // use frameA fo define limits, if true + bool m_useLinearReferenceFrameA; + // linear limits + btScalar m_lowerLinLimit; + btScalar m_upperLinLimit; + // angular limits + btScalar m_lowerAngLimit; + btScalar m_upperAngLimit; + // softness, restitution and damping for different cases + // DirLin - moving inside linear limits + // LimLin - hitting linear limit + // DirAng - moving inside angular limits + // LimAng - hitting angular limit + // OrthoLin, OrthoAng - against constraint axis + btScalar m_softnessDirLin; + btScalar m_restitutionDirLin; + btScalar m_dampingDirLin; + btScalar m_cfmDirLin; + + btScalar m_softnessDirAng; + btScalar m_restitutionDirAng; + btScalar m_dampingDirAng; + btScalar m_cfmDirAng; + + btScalar m_softnessLimLin; + btScalar m_restitutionLimLin; + btScalar m_dampingLimLin; + btScalar m_cfmLimLin; + + btScalar m_softnessLimAng; + btScalar m_restitutionLimAng; + btScalar m_dampingLimAng; + btScalar m_cfmLimAng; + + btScalar m_softnessOrthoLin; + btScalar m_restitutionOrthoLin; + btScalar m_dampingOrthoLin; + btScalar m_cfmOrthoLin; + + btScalar m_softnessOrthoAng; + btScalar m_restitutionOrthoAng; + btScalar m_dampingOrthoAng; + btScalar m_cfmOrthoAng; + + // for interlal use + bool m_solveLinLim; + bool m_solveAngLim; + + int m_flags; + + btJacobianEntry m_jacLin[3]; + btScalar m_jacLinDiagABInv[3]; + + btJacobianEntry m_jacAng[3]; + + btScalar m_timeStep; + btTransform m_calculatedTransformA; + btTransform m_calculatedTransformB; + + btVector3 m_sliderAxis; + btVector3 m_realPivotAInW; + btVector3 m_realPivotBInW; + btVector3 m_projPivotInW; + btVector3 m_delta; + btVector3 m_depth; + btVector3 m_relPosA; + btVector3 m_relPosB; + + btScalar m_linPos; + btScalar m_angPos; + + btScalar m_angDepth; + btScalar m_kAngle; + + bool m_poweredLinMotor; + btScalar m_targetLinMotorVelocity; + btScalar m_maxLinMotorForce; + btScalar m_accumulatedLinMotorImpulse; + + bool m_poweredAngMotor; + btScalar m_targetAngMotorVelocity; + btScalar m_maxAngMotorForce; + btScalar m_accumulatedAngMotorImpulse; + + //------------------------ + void initParams(); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + // constructors + btSliderConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA); + btSliderConstraint(btRigidBody & rbB, const btTransform& frameInB, bool useLinearReferenceFrameA); + + // overrides + + virtual void getInfo1(btConstraintInfo1 * info); + + void getInfo1NonVirtual(btConstraintInfo1 * info); + + virtual void getInfo2(btConstraintInfo2 * info); + + void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, btScalar rbAinvMass, btScalar rbBinvMass); + + // access + const btRigidBody& getRigidBodyA() const { return m_rbA; } + const btRigidBody& getRigidBodyB() const { return m_rbB; } + const btTransform& getCalculatedTransformA() const { return m_calculatedTransformA; } + const btTransform& getCalculatedTransformB() const { return m_calculatedTransformB; } + const btTransform& getFrameOffsetA() const { return m_frameInA; } + const btTransform& getFrameOffsetB() const { return m_frameInB; } + btTransform& getFrameOffsetA() { return m_frameInA; } + btTransform& getFrameOffsetB() { return m_frameInB; } + btScalar getLowerLinLimit() { return m_lowerLinLimit; } + void setLowerLinLimit(btScalar lowerLimit) { m_lowerLinLimit = lowerLimit; } + btScalar getUpperLinLimit() { return m_upperLinLimit; } + void setUpperLinLimit(btScalar upperLimit) { m_upperLinLimit = upperLimit; } + btScalar getLowerAngLimit() { return m_lowerAngLimit; } + void setLowerAngLimit(btScalar lowerLimit) { m_lowerAngLimit = btNormalizeAngle(lowerLimit); } + btScalar getUpperAngLimit() { return m_upperAngLimit; } + void setUpperAngLimit(btScalar upperLimit) { m_upperAngLimit = btNormalizeAngle(upperLimit); } + bool getUseLinearReferenceFrameA() { return m_useLinearReferenceFrameA; } + btScalar getSoftnessDirLin() { return m_softnessDirLin; } + btScalar getRestitutionDirLin() { return m_restitutionDirLin; } + btScalar getDampingDirLin() { return m_dampingDirLin; } + btScalar getSoftnessDirAng() { return m_softnessDirAng; } + btScalar getRestitutionDirAng() { return m_restitutionDirAng; } + btScalar getDampingDirAng() { return m_dampingDirAng; } + btScalar getSoftnessLimLin() { return m_softnessLimLin; } + btScalar getRestitutionLimLin() { return m_restitutionLimLin; } + btScalar getDampingLimLin() { return m_dampingLimLin; } + btScalar getSoftnessLimAng() { return m_softnessLimAng; } + btScalar getRestitutionLimAng() { return m_restitutionLimAng; } + btScalar getDampingLimAng() { return m_dampingLimAng; } + btScalar getSoftnessOrthoLin() { return m_softnessOrthoLin; } + btScalar getRestitutionOrthoLin() { return m_restitutionOrthoLin; } + btScalar getDampingOrthoLin() { return m_dampingOrthoLin; } + btScalar getSoftnessOrthoAng() { return m_softnessOrthoAng; } + btScalar getRestitutionOrthoAng() { return m_restitutionOrthoAng; } + btScalar getDampingOrthoAng() { return m_dampingOrthoAng; } + void setSoftnessDirLin(btScalar softnessDirLin) { m_softnessDirLin = softnessDirLin; } + void setRestitutionDirLin(btScalar restitutionDirLin) { m_restitutionDirLin = restitutionDirLin; } + void setDampingDirLin(btScalar dampingDirLin) { m_dampingDirLin = dampingDirLin; } + void setSoftnessDirAng(btScalar softnessDirAng) { m_softnessDirAng = softnessDirAng; } + void setRestitutionDirAng(btScalar restitutionDirAng) { m_restitutionDirAng = restitutionDirAng; } + void setDampingDirAng(btScalar dampingDirAng) { m_dampingDirAng = dampingDirAng; } + void setSoftnessLimLin(btScalar softnessLimLin) { m_softnessLimLin = softnessLimLin; } + void setRestitutionLimLin(btScalar restitutionLimLin) { m_restitutionLimLin = restitutionLimLin; } + void setDampingLimLin(btScalar dampingLimLin) { m_dampingLimLin = dampingLimLin; } + void setSoftnessLimAng(btScalar softnessLimAng) { m_softnessLimAng = softnessLimAng; } + void setRestitutionLimAng(btScalar restitutionLimAng) { m_restitutionLimAng = restitutionLimAng; } + void setDampingLimAng(btScalar dampingLimAng) { m_dampingLimAng = dampingLimAng; } + void setSoftnessOrthoLin(btScalar softnessOrthoLin) { m_softnessOrthoLin = softnessOrthoLin; } + void setRestitutionOrthoLin(btScalar restitutionOrthoLin) { m_restitutionOrthoLin = restitutionOrthoLin; } + void setDampingOrthoLin(btScalar dampingOrthoLin) { m_dampingOrthoLin = dampingOrthoLin; } + void setSoftnessOrthoAng(btScalar softnessOrthoAng) { m_softnessOrthoAng = softnessOrthoAng; } + void setRestitutionOrthoAng(btScalar restitutionOrthoAng) { m_restitutionOrthoAng = restitutionOrthoAng; } + void setDampingOrthoAng(btScalar dampingOrthoAng) { m_dampingOrthoAng = dampingOrthoAng; } + void setPoweredLinMotor(bool onOff) { m_poweredLinMotor = onOff; } + bool getPoweredLinMotor() { return m_poweredLinMotor; } + void setTargetLinMotorVelocity(btScalar targetLinMotorVelocity) { m_targetLinMotorVelocity = targetLinMotorVelocity; } + btScalar getTargetLinMotorVelocity() { return m_targetLinMotorVelocity; } + void setMaxLinMotorForce(btScalar maxLinMotorForce) { m_maxLinMotorForce = maxLinMotorForce; } + btScalar getMaxLinMotorForce() { return m_maxLinMotorForce; } + void setPoweredAngMotor(bool onOff) { m_poweredAngMotor = onOff; } + bool getPoweredAngMotor() { return m_poweredAngMotor; } + void setTargetAngMotorVelocity(btScalar targetAngMotorVelocity) { m_targetAngMotorVelocity = targetAngMotorVelocity; } + btScalar getTargetAngMotorVelocity() { return m_targetAngMotorVelocity; } + void setMaxAngMotorForce(btScalar maxAngMotorForce) { m_maxAngMotorForce = maxAngMotorForce; } + btScalar getMaxAngMotorForce() { return m_maxAngMotorForce; } + + btScalar getLinearPos() const { return m_linPos; } + btScalar getAngularPos() const { return m_angPos; } + + // access for ODE solver + bool getSolveLinLimit() { return m_solveLinLim; } + btScalar getLinDepth() { return m_depth[0]; } + bool getSolveAngLimit() { return m_solveAngLim; } + btScalar getAngDepth() { return m_angDepth; } + // shared code used by ODE solver + void calculateTransforms(const btTransform& transA, const btTransform& transB); + void testLinLimits(); + void testAngLimits(); + // access for PE Solver + btVector3 getAncorInA(); + btVector3 getAncorInB(); + // access for UseFrameOffset + bool getUseFrameOffset() { return m_useOffsetForConstraintFrame; } + void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; } + + void setFrames(const btTransform& frameA, const btTransform& frameB) + { + m_frameInA = frameA; + m_frameInB = frameB; + calculateTransforms(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform()); + buildJacobian(); + } + + ///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + ///If no axis is provided, it uses the default axis for this constraint. + virtual void setParam(int num, btScalar value, int axis = -1); + ///return the local value of parameter + virtual btScalar getParam(int num, int axis = -1) const; + + virtual int getFlags() const + { + return m_flags; + } + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 + +struct btSliderConstraintData +{ + btTypedConstraintData m_typeConstraintData; + btTransformFloatData m_rbAFrame; // constraint axii. Assumes z is hinge axis. + btTransformFloatData m_rbBFrame; + + float m_linearUpperLimit; + float m_linearLowerLimit; + + float m_angularUpperLimit; + float m_angularLowerLimit; + + int m_useLinearReferenceFrameA; + int m_useOffsetForConstraintFrame; +}; + +struct btSliderConstraintDoubleData +{ + btTypedConstraintDoubleData m_typeConstraintData; + btTransformDoubleData m_rbAFrame; // constraint axii. Assumes z is hinge axis. + btTransformDoubleData m_rbBFrame; + + double m_linearUpperLimit; + double m_linearLowerLimit; + + double m_angularUpperLimit; + double m_angularLowerLimit; + + int m_useLinearReferenceFrameA; + int m_useOffsetForConstraintFrame; +}; + +SIMD_FORCE_INLINE int btSliderConstraint::calculateSerializeBufferSize() const +{ + return sizeof(btSliderConstraintData2); +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +SIMD_FORCE_INLINE const char* btSliderConstraint::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btSliderConstraintData2* sliderData = (btSliderConstraintData2*)dataBuffer; + btTypedConstraint::serialize(&sliderData->m_typeConstraintData, serializer); + + m_frameInA.serialize(sliderData->m_rbAFrame); + m_frameInB.serialize(sliderData->m_rbBFrame); + + sliderData->m_linearUpperLimit = m_upperLinLimit; + sliderData->m_linearLowerLimit = m_lowerLinLimit; + + sliderData->m_angularUpperLimit = m_upperAngLimit; + sliderData->m_angularLowerLimit = m_lowerAngLimit; + + sliderData->m_useLinearReferenceFrameA = m_useLinearReferenceFrameA; + sliderData->m_useOffsetForConstraintFrame = m_useOffsetForConstraintFrame; + + return btSliderConstraintDataName; +} + +#endif //BT_SLIDER_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.h.i new file mode 100644 index 00000000..f65b5eff --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSliderConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btSliderConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btSliderConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btSliderConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp new file mode 100644 index 00000000..5c2060cf --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp @@ -0,0 +1,239 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btSolve2LinearConstraint.h" + +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btVector3.h" +#include "btJacobianEntry.h" + +void btSolve2LinearConstraint::resolveUnilateralPairConstraint( + btRigidBody* body1, + btRigidBody* body2, + + const btMatrix3x3& world2A, + const btMatrix3x3& world2B, + + const btVector3& invInertiaADiag, + const btScalar invMassA, + const btVector3& linvelA, const btVector3& angvelA, + const btVector3& rel_posA1, + const btVector3& invInertiaBDiag, + const btScalar invMassB, + const btVector3& linvelB, const btVector3& angvelB, + const btVector3& rel_posA2, + + btScalar depthA, const btVector3& normalA, + const btVector3& rel_posB1, const btVector3& rel_posB2, + btScalar depthB, const btVector3& normalB, + btScalar& imp0, btScalar& imp1) +{ + (void)linvelA; + (void)linvelB; + (void)angvelB; + (void)angvelA; + + imp0 = btScalar(0.); + imp1 = btScalar(0.); + + btScalar len = btFabs(normalA.length()) - btScalar(1.); + if (btFabs(len) >= SIMD_EPSILON) + return; + + btAssert(len < SIMD_EPSILON); + + //this jacobian entry could be re-used for all iterations + btJacobianEntry jacA(world2A, world2B, rel_posA1, rel_posA2, normalA, invInertiaADiag, invMassA, + invInertiaBDiag, invMassB); + btJacobianEntry jacB(world2A, world2B, rel_posB1, rel_posB2, normalB, invInertiaADiag, invMassA, + invInertiaBDiag, invMassB); + + //const btScalar vel0 = jacA.getRelativeVelocity(linvelA,angvelA,linvelB,angvelB); + //const btScalar vel1 = jacB.getRelativeVelocity(linvelA,angvelA,linvelB,angvelB); + + const btScalar vel0 = normalA.dot(body1->getVelocityInLocalPoint(rel_posA1) - body2->getVelocityInLocalPoint(rel_posA1)); + const btScalar vel1 = normalB.dot(body1->getVelocityInLocalPoint(rel_posB1) - body2->getVelocityInLocalPoint(rel_posB1)); + + // btScalar penetrationImpulse = (depth*contactTau*timeCorrection) * massTerm;//jacDiagABInv + btScalar massTerm = btScalar(1.) / (invMassA + invMassB); + + // calculate rhs (or error) terms + const btScalar dv0 = depthA * m_tau * massTerm - vel0 * m_damping; + const btScalar dv1 = depthB * m_tau * massTerm - vel1 * m_damping; + + // dC/dv * dv = -C + + // jacobian * impulse = -error + // + + //impulse = jacobianInverse * -error + + // inverting 2x2 symmetric system (offdiagonal are equal!) + // + + btScalar nonDiag = jacA.getNonDiagonal(jacB, invMassA, invMassB); + btScalar invDet = btScalar(1.0) / (jacA.getDiagonal() * jacB.getDiagonal() - nonDiag * nonDiag); + + //imp0 = dv0 * jacA.getDiagonal() * invDet + dv1 * -nonDiag * invDet; + //imp1 = dv1 * jacB.getDiagonal() * invDet + dv0 * - nonDiag * invDet; + + imp0 = dv0 * jacA.getDiagonal() * invDet + dv1 * -nonDiag * invDet; + imp1 = dv1 * jacB.getDiagonal() * invDet + dv0 * -nonDiag * invDet; + + //[a b] [d -c] + //[c d] inverse = (1 / determinant) * [-b a] where determinant is (ad - bc) + + //[jA nD] * [imp0] = [dv0] + //[nD jB] [imp1] [dv1] +} + +void btSolve2LinearConstraint::resolveBilateralPairConstraint( + btRigidBody* body1, + btRigidBody* body2, + const btMatrix3x3& world2A, + const btMatrix3x3& world2B, + + const btVector3& invInertiaADiag, + const btScalar invMassA, + const btVector3& linvelA, const btVector3& angvelA, + const btVector3& rel_posA1, + const btVector3& invInertiaBDiag, + const btScalar invMassB, + const btVector3& linvelB, const btVector3& angvelB, + const btVector3& rel_posA2, + + btScalar depthA, const btVector3& normalA, + const btVector3& rel_posB1, const btVector3& rel_posB2, + btScalar depthB, const btVector3& normalB, + btScalar& imp0, btScalar& imp1) +{ + (void)linvelA; + (void)linvelB; + (void)angvelA; + (void)angvelB; + + imp0 = btScalar(0.); + imp1 = btScalar(0.); + + btScalar len = btFabs(normalA.length()) - btScalar(1.); + if (btFabs(len) >= SIMD_EPSILON) + return; + + btAssert(len < SIMD_EPSILON); + + //this jacobian entry could be re-used for all iterations + btJacobianEntry jacA(world2A, world2B, rel_posA1, rel_posA2, normalA, invInertiaADiag, invMassA, + invInertiaBDiag, invMassB); + btJacobianEntry jacB(world2A, world2B, rel_posB1, rel_posB2, normalB, invInertiaADiag, invMassA, + invInertiaBDiag, invMassB); + + //const btScalar vel0 = jacA.getRelativeVelocity(linvelA,angvelA,linvelB,angvelB); + //const btScalar vel1 = jacB.getRelativeVelocity(linvelA,angvelA,linvelB,angvelB); + + const btScalar vel0 = normalA.dot(body1->getVelocityInLocalPoint(rel_posA1) - body2->getVelocityInLocalPoint(rel_posA1)); + const btScalar vel1 = normalB.dot(body1->getVelocityInLocalPoint(rel_posB1) - body2->getVelocityInLocalPoint(rel_posB1)); + + // calculate rhs (or error) terms + const btScalar dv0 = depthA * m_tau - vel0 * m_damping; + const btScalar dv1 = depthB * m_tau - vel1 * m_damping; + + // dC/dv * dv = -C + + // jacobian * impulse = -error + // + + //impulse = jacobianInverse * -error + + // inverting 2x2 symmetric system (offdiagonal are equal!) + // + + btScalar nonDiag = jacA.getNonDiagonal(jacB, invMassA, invMassB); + btScalar invDet = btScalar(1.0) / (jacA.getDiagonal() * jacB.getDiagonal() - nonDiag * nonDiag); + + //imp0 = dv0 * jacA.getDiagonal() * invDet + dv1 * -nonDiag * invDet; + //imp1 = dv1 * jacB.getDiagonal() * invDet + dv0 * - nonDiag * invDet; + + imp0 = dv0 * jacA.getDiagonal() * invDet + dv1 * -nonDiag * invDet; + imp1 = dv1 * jacB.getDiagonal() * invDet + dv0 * -nonDiag * invDet; + + //[a b] [d -c] + //[c d] inverse = (1 / determinant) * [-b a] where determinant is (ad - bc) + + //[jA nD] * [imp0] = [dv0] + //[nD jB] [imp1] [dv1] + + if (imp0 > btScalar(0.0)) + { + if (imp1 > btScalar(0.0)) + { + //both positive + } + else + { + imp1 = btScalar(0.); + + // now imp0>0 imp1<0 + imp0 = dv0 / jacA.getDiagonal(); + if (imp0 > btScalar(0.0)) + { + } + else + { + imp0 = btScalar(0.); + } + } + } + else + { + imp0 = btScalar(0.); + + imp1 = dv1 / jacB.getDiagonal(); + if (imp1 <= btScalar(0.0)) + { + imp1 = btScalar(0.); + // now imp0>0 imp1<0 + imp0 = dv0 / jacA.getDiagonal(); + if (imp0 > btScalar(0.0)) + { + } + else + { + imp0 = btScalar(0.); + } + } + else + { + } + } +} + +/* +void btSolve2LinearConstraint::resolveAngularConstraint( const btMatrix3x3& invInertiaAWS, + const btScalar invMassA, + const btVector3& linvelA,const btVector3& angvelA, + const btVector3& rel_posA1, + const btMatrix3x3& invInertiaBWS, + const btScalar invMassB, + const btVector3& linvelB,const btVector3& angvelB, + const btVector3& rel_posA2, + + btScalar depthA, const btVector3& normalA, + const btVector3& rel_posB1,const btVector3& rel_posB2, + btScalar depthB, const btVector3& normalB, + btScalar& imp0,btScalar& imp1) +{ + +} +*/ diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp.i new file mode 100644 index 00000000..1bbfa11c --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h new file mode 100644 index 00000000..0a8c901b --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h @@ -0,0 +1,101 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SOLVE_2LINEAR_CONSTRAINT_H +#define BT_SOLVE_2LINEAR_CONSTRAINT_H + +#include "LinearMath/btMatrix3x3.h" +#include "LinearMath/btVector3.h" + +class btRigidBody; + +/// constraint class used for lateral tyre friction. +class btSolve2LinearConstraint +{ + btScalar m_tau; + btScalar m_damping; + +public: + btSolve2LinearConstraint(btScalar tau, btScalar damping) + { + m_tau = tau; + m_damping = damping; + } + // + // solve unilateral constraint (equality, direct method) + // + void resolveUnilateralPairConstraint( + btRigidBody* body0, + btRigidBody* body1, + + const btMatrix3x3& world2A, + const btMatrix3x3& world2B, + + const btVector3& invInertiaADiag, + const btScalar invMassA, + const btVector3& linvelA, const btVector3& angvelA, + const btVector3& rel_posA1, + const btVector3& invInertiaBDiag, + const btScalar invMassB, + const btVector3& linvelB, const btVector3& angvelB, + const btVector3& rel_posA2, + + btScalar depthA, const btVector3& normalA, + const btVector3& rel_posB1, const btVector3& rel_posB2, + btScalar depthB, const btVector3& normalB, + btScalar& imp0, btScalar& imp1); + + // + // solving 2x2 lcp problem (inequality, direct solution ) + // + void resolveBilateralPairConstraint( + btRigidBody* body0, + btRigidBody* body1, + const btMatrix3x3& world2A, + const btMatrix3x3& world2B, + + const btVector3& invInertiaADiag, + const btScalar invMassA, + const btVector3& linvelA, const btVector3& angvelA, + const btVector3& rel_posA1, + const btVector3& invInertiaBDiag, + const btScalar invMassB, + const btVector3& linvelB, const btVector3& angvelB, + const btVector3& rel_posA2, + + btScalar depthA, const btVector3& normalA, + const btVector3& rel_posB1, const btVector3& rel_posB2, + btScalar depthB, const btVector3& normalB, + btScalar& imp0, btScalar& imp1); + + /* + void resolveAngularConstraint( const btMatrix3x3& invInertiaAWS, + const btScalar invMassA, + const btVector3& linvelA,const btVector3& angvelA, + const btVector3& rel_posA1, + const btMatrix3x3& invInertiaBWS, + const btScalar invMassB, + const btVector3& linvelB,const btVector3& angvelB, + const btVector3& rel_posA2, + + btScalar depthA, const btVector3& normalA, + const btVector3& rel_posB1,const btVector3& rel_posB2, + btScalar depthB, const btVector3& normalB, + btScalar& imp0,btScalar& imp1); + +*/ +}; + +#endif //BT_SOLVE_2LINEAR_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h.i new file mode 100644 index 00000000..58408a13 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverBody.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverBody.h new file mode 100644 index 00000000..8d2f108f --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverBody.h @@ -0,0 +1,285 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SOLVER_BODY_H +#define BT_SOLVER_BODY_H + +class btRigidBody; +#include "LinearMath/btVector3.h" +#include "LinearMath/btMatrix3x3.h" + +#include "LinearMath/btAlignedAllocator.h" +#include "LinearMath/btTransformUtil.h" + +///Until we get other contributions, only use SIMD on Windows, when using Visual Studio 2008 or later, and not double precision +#ifdef BT_USE_SSE +#define USE_SIMD 1 +#endif // + +#ifdef USE_SIMD + +struct btSimdScalar +{ + SIMD_FORCE_INLINE btSimdScalar() + { + } + + SIMD_FORCE_INLINE btSimdScalar(float fl) + : m_vec128(_mm_set1_ps(fl)) + { + } + + SIMD_FORCE_INLINE btSimdScalar(__m128 v128) + : m_vec128(v128) + { + } + union { + __m128 m_vec128; + float m_floats[4]; + int m_ints[4]; + btScalar m_unusedPadding; + }; + SIMD_FORCE_INLINE __m128 get128() + { + return m_vec128; + } + + SIMD_FORCE_INLINE const __m128 get128() const + { + return m_vec128; + } + + SIMD_FORCE_INLINE void set128(__m128 v128) + { + m_vec128 = v128; + } + + SIMD_FORCE_INLINE operator __m128() + { + return m_vec128; + } + SIMD_FORCE_INLINE operator const __m128() const + { + return m_vec128; + } + + SIMD_FORCE_INLINE operator float() const + { + return m_floats[0]; + } +}; + +///@brief Return the elementwise product of two btSimdScalar +SIMD_FORCE_INLINE btSimdScalar +operator*(const btSimdScalar& v1, const btSimdScalar& v2) +{ + return btSimdScalar(_mm_mul_ps(v1.get128(), v2.get128())); +} + +///@brief Return the elementwise product of two btSimdScalar +SIMD_FORCE_INLINE btSimdScalar +operator+(const btSimdScalar& v1, const btSimdScalar& v2) +{ + return btSimdScalar(_mm_add_ps(v1.get128(), v2.get128())); +} + +#else +#define btSimdScalar btScalar +#endif + +///The btSolverBody is an internal datastructure for the constraint solver. Only necessary data is packed to increase cache coherence/performance. +ATTRIBUTE_ALIGNED16(struct) +btSolverBody +{ + BT_DECLARE_ALIGNED_ALLOCATOR(); + btTransform m_worldTransform; + btVector3 m_deltaLinearVelocity; + btVector3 m_deltaAngularVelocity; + btVector3 m_angularFactor; + btVector3 m_linearFactor; + btVector3 m_invMass; + btVector3 m_pushVelocity; + btVector3 m_turnVelocity; + btVector3 m_linearVelocity; + btVector3 m_angularVelocity; + btVector3 m_externalForceImpulse; + btVector3 m_externalTorqueImpulse; + + btRigidBody* m_originalBody; + void setWorldTransform(const btTransform& worldTransform) + { + m_worldTransform = worldTransform; + } + + const btTransform& getWorldTransform() const + { + return m_worldTransform; + } + + SIMD_FORCE_INLINE void getVelocityInLocalPointNoDelta(const btVector3& rel_pos, btVector3& velocity) const + { + if (m_originalBody) + velocity = m_linearVelocity + m_externalForceImpulse + (m_angularVelocity + m_externalTorqueImpulse).cross(rel_pos); + else + velocity.setValue(0, 0, 0); + } + + SIMD_FORCE_INLINE void getVelocityInLocalPointObsolete(const btVector3& rel_pos, btVector3& velocity) const + { + if (m_originalBody) + velocity = m_linearVelocity + m_deltaLinearVelocity + (m_angularVelocity + m_deltaAngularVelocity).cross(rel_pos); + else + velocity.setValue(0, 0, 0); + } + + SIMD_FORCE_INLINE void getAngularVelocity(btVector3 & angVel) const + { + if (m_originalBody) + angVel = m_angularVelocity + m_deltaAngularVelocity; + else + angVel.setValue(0, 0, 0); + } + + //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position + SIMD_FORCE_INLINE void applyImpulse(const btVector3& linearComponent, const btVector3& angularComponent, const btScalar impulseMagnitude) + { + if (m_originalBody) + { + m_deltaLinearVelocity += linearComponent * impulseMagnitude * m_linearFactor; + m_deltaAngularVelocity += angularComponent * (impulseMagnitude * m_angularFactor); + } + } + + SIMD_FORCE_INLINE void internalApplyPushImpulse(const btVector3& linearComponent, const btVector3& angularComponent, btScalar impulseMagnitude) + { + if (m_originalBody) + { + m_pushVelocity += linearComponent * impulseMagnitude * m_linearFactor; + m_turnVelocity += angularComponent * (impulseMagnitude * m_angularFactor); + } + } + + const btVector3& getDeltaLinearVelocity() const + { + return m_deltaLinearVelocity; + } + + const btVector3& getDeltaAngularVelocity() const + { + return m_deltaAngularVelocity; + } + + const btVector3& getPushVelocity() const + { + return m_pushVelocity; + } + + const btVector3& getTurnVelocity() const + { + return m_turnVelocity; + } + + //////////////////////////////////////////////// + ///some internal methods, don't use them + + btVector3& internalGetDeltaLinearVelocity() + { + return m_deltaLinearVelocity; + } + + btVector3& internalGetDeltaAngularVelocity() + { + return m_deltaAngularVelocity; + } + + const btVector3& internalGetAngularFactor() const + { + return m_angularFactor; + } + + const btVector3& internalGetInvMass() const + { + return m_invMass; + } + + void internalSetInvMass(const btVector3& invMass) + { + m_invMass = invMass; + } + + btVector3& internalGetPushVelocity() + { + return m_pushVelocity; + } + + btVector3& internalGetTurnVelocity() + { + return m_turnVelocity; + } + + SIMD_FORCE_INLINE void internalGetVelocityInLocalPointObsolete(const btVector3& rel_pos, btVector3& velocity) const + { + velocity = m_linearVelocity + m_deltaLinearVelocity + (m_angularVelocity + m_deltaAngularVelocity).cross(rel_pos); + } + + SIMD_FORCE_INLINE void internalGetAngularVelocity(btVector3 & angVel) const + { + angVel = m_angularVelocity + m_deltaAngularVelocity; + } + + //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position + SIMD_FORCE_INLINE void internalApplyImpulse(const btVector3& linearComponent, const btVector3& angularComponent, const btScalar impulseMagnitude) + { + if (m_originalBody) + { + m_deltaLinearVelocity += linearComponent * impulseMagnitude * m_linearFactor; + m_deltaAngularVelocity += angularComponent * (impulseMagnitude * m_angularFactor); + } + } + + void writebackVelocity() + { + if (m_originalBody) + { + m_linearVelocity += m_deltaLinearVelocity; + m_angularVelocity += m_deltaAngularVelocity; + + //m_originalBody->setCompanionId(-1); + } + } + + void writebackVelocityAndTransform(btScalar timeStep, btScalar splitImpulseTurnErp) + { + (void)timeStep; + if (m_originalBody) + { + m_linearVelocity += m_deltaLinearVelocity; + m_angularVelocity += m_deltaAngularVelocity; + + //correct the position/orientation based on push/turn recovery + btTransform newTransform; + if (m_pushVelocity[0] != 0.f || m_pushVelocity[1] != 0 || m_pushVelocity[2] != 0 || m_turnVelocity[0] != 0.f || m_turnVelocity[1] != 0 || m_turnVelocity[2] != 0) + { + // btQuaternion orn = m_worldTransform.getRotation(); + btTransformUtil::integrateTransform(m_worldTransform, m_pushVelocity, m_turnVelocity * splitImpulseTurnErp, timeStep, newTransform); + m_worldTransform = newTransform; + } + //m_worldTransform.setRotation(orn); + //m_originalBody->setCompanionId(-1); + } + } +}; + +#endif //BT_SOLVER_BODY_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverBody.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverBody.h.i new file mode 100644 index 00000000..87ea5596 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverBody.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btSolverBody.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btSolverBody.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btSolverBody.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverConstraint.h new file mode 100644 index 00000000..9749b331 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverConstraint.h @@ -0,0 +1,74 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SOLVER_CONSTRAINT_H +#define BT_SOLVER_CONSTRAINT_H + +class btRigidBody; +#include "LinearMath/btVector3.h" +#include "LinearMath/btMatrix3x3.h" +#include "btJacobianEntry.h" +#include "LinearMath/btAlignedObjectArray.h" + +//#define NO_FRICTION_TANGENTIALS 1 +#include "btSolverBody.h" + +///1D constraint along a normal axis between bodyA and bodyB. It can be combined to solve contact and friction constraints. +ATTRIBUTE_ALIGNED16(struct) +btSolverConstraint +{ + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btVector3 m_relpos1CrossNormal; + btVector3 m_contactNormal1; + + btVector3 m_relpos2CrossNormal; + btVector3 m_contactNormal2; //usually m_contactNormal2 == -m_contactNormal1, but not always + + btVector3 m_angularComponentA; + btVector3 m_angularComponentB; + + mutable btSimdScalar m_appliedPushImpulse; + mutable btSimdScalar m_appliedImpulse; + + btScalar m_friction; + btScalar m_jacDiagABInv; + btScalar m_rhs; + btScalar m_cfm; + + btScalar m_lowerLimit; + btScalar m_upperLimit; + btScalar m_rhsPenetration; + union { + void* m_originalContactPoint; + btScalar m_unusedPadding4; + int m_numRowsForNonContactConstraint; + }; + + int m_overrideNumSolverIterations; + int m_frictionIndex; + int m_solverBodyIdA; + int m_solverBodyIdB; + + enum btSolverConstraintType + { + BT_SOLVER_CONTACT_1D = 0, + BT_SOLVER_FRICTION_1D + }; +}; + +typedef btAlignedObjectArray btConstraintArray; + +#endif //BT_SOLVER_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverConstraint.h.i new file mode 100644 index 00000000..84223359 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btSolverConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btSolverConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp new file mode 100644 index 00000000..95309119 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp @@ -0,0 +1,214 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btTypedConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btSerializer.h" + +#define DEFAULT_DEBUGDRAW_SIZE btScalar(0.05f) + +btTypedConstraint::btTypedConstraint(btTypedConstraintType type, btRigidBody& rbA) + : btTypedObject(type), + m_userConstraintType(-1), + m_userConstraintPtr((void*)-1), + m_breakingImpulseThreshold(SIMD_INFINITY), + m_isEnabled(true), + m_needsFeedback(false), + m_overrideNumSolverIterations(-1), + m_rbA(rbA), + m_rbB(getFixedBody()), + m_appliedImpulse(btScalar(0.)), + m_dbgDrawSize(DEFAULT_DEBUGDRAW_SIZE), + m_jointFeedback(0) +{ +} + +btTypedConstraint::btTypedConstraint(btTypedConstraintType type, btRigidBody& rbA, btRigidBody& rbB) + : btTypedObject(type), + m_userConstraintType(-1), + m_userConstraintPtr((void*)-1), + m_breakingImpulseThreshold(SIMD_INFINITY), + m_isEnabled(true), + m_needsFeedback(false), + m_overrideNumSolverIterations(-1), + m_rbA(rbA), + m_rbB(rbB), + m_appliedImpulse(btScalar(0.)), + m_dbgDrawSize(DEFAULT_DEBUGDRAW_SIZE), + m_jointFeedback(0) +{ +} + +btScalar btTypedConstraint::getMotorFactor(btScalar pos, btScalar lowLim, btScalar uppLim, btScalar vel, btScalar timeFact) +{ + if (lowLim > uppLim) + { + return btScalar(1.0f); + } + else if (lowLim == uppLim) + { + return btScalar(0.0f); + } + btScalar lim_fact = btScalar(1.0f); + btScalar delta_max = vel / timeFact; + if (delta_max < btScalar(0.0f)) + { + if ((pos >= lowLim) && (pos < (lowLim - delta_max))) + { + lim_fact = (lowLim - pos) / delta_max; + } + else if (pos < lowLim) + { + lim_fact = btScalar(0.0f); + } + else + { + lim_fact = btScalar(1.0f); + } + } + else if (delta_max > btScalar(0.0f)) + { + if ((pos <= uppLim) && (pos > (uppLim - delta_max))) + { + lim_fact = (uppLim - pos) / delta_max; + } + else if (pos > uppLim) + { + lim_fact = btScalar(0.0f); + } + else + { + lim_fact = btScalar(1.0f); + } + } + else + { + lim_fact = btScalar(0.0f); + } + return lim_fact; +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +const char* btTypedConstraint::serialize(void* dataBuffer, btSerializer* serializer) const +{ + btTypedConstraintData2* tcd = (btTypedConstraintData2*)dataBuffer; + + tcd->m_rbA = (btRigidBodyData*)serializer->getUniquePointer(&m_rbA); + tcd->m_rbB = (btRigidBodyData*)serializer->getUniquePointer(&m_rbB); + char* name = (char*)serializer->findNameForPointer(this); + tcd->m_name = (char*)serializer->getUniquePointer(name); + if (tcd->m_name) + { + serializer->serializeName(name); + } + + tcd->m_objectType = m_objectType; + tcd->m_needsFeedback = m_needsFeedback; + tcd->m_overrideNumSolverIterations = m_overrideNumSolverIterations; + tcd->m_breakingImpulseThreshold = m_breakingImpulseThreshold; + tcd->m_isEnabled = m_isEnabled ? 1 : 0; + + tcd->m_userConstraintId = m_userConstraintId; + tcd->m_userConstraintType = m_userConstraintType; + + tcd->m_appliedImpulse = m_appliedImpulse; + tcd->m_dbgDrawSize = m_dbgDrawSize; + + tcd->m_disableCollisionsBetweenLinkedBodies = false; + + int i; + for (i = 0; i < m_rbA.getNumConstraintRefs(); i++) + if (m_rbA.getConstraintRef(i) == this) + tcd->m_disableCollisionsBetweenLinkedBodies = true; + for (i = 0; i < m_rbB.getNumConstraintRefs(); i++) + if (m_rbB.getConstraintRef(i) == this) + tcd->m_disableCollisionsBetweenLinkedBodies = true; + + return btTypedConstraintDataName; +} + +btRigidBody& btTypedConstraint::getFixedBody() +{ + static btRigidBody s_fixed(0, 0, 0); + s_fixed.setMassProps(btScalar(0.), btVector3(btScalar(0.), btScalar(0.), btScalar(0.))); + return s_fixed; +} + +void btAngularLimit::set(btScalar low, btScalar high, btScalar _softness, btScalar _biasFactor, btScalar _relaxationFactor) +{ + m_halfRange = (high - low) / 2.0f; + m_center = btNormalizeAngle(low + m_halfRange); + m_softness = _softness; + m_biasFactor = _biasFactor; + m_relaxationFactor = _relaxationFactor; +} + +void btAngularLimit::test(const btScalar angle) +{ + m_correction = 0.0f; + m_sign = 0.0f; + m_solveLimit = false; + + if (m_halfRange >= 0.0f) + { + btScalar deviation = btNormalizeAngle(angle - m_center); + if (deviation < -m_halfRange) + { + m_solveLimit = true; + m_correction = -(deviation + m_halfRange); + m_sign = +1.0f; + } + else if (deviation > m_halfRange) + { + m_solveLimit = true; + m_correction = m_halfRange - deviation; + m_sign = -1.0f; + } + } +} + +btScalar btAngularLimit::getError() const +{ + return m_correction * m_sign; +} + +void btAngularLimit::fit(btScalar& angle) const +{ + if (m_halfRange > 0.0f) + { + btScalar relativeAngle = btNormalizeAngle(angle - m_center); + if (!btEqual(relativeAngle, m_halfRange)) + { + if (relativeAngle > 0.0f) + { + angle = getHigh(); + } + else + { + angle = getLow(); + } + } + } +} + +btScalar btAngularLimit::getLow() const +{ + return btNormalizeAngle(m_center - m_halfRange); +} + +btScalar btAngularLimit::getHigh() const +{ + return btNormalizeAngle(m_center + m_halfRange); +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp.i new file mode 100644 index 00000000..2d1b0d6a --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btTypedConstraint.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btTypedConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.h new file mode 100644 index 00000000..3d6b08d7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.h @@ -0,0 +1,532 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2010 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_TYPED_CONSTRAINT_H +#define BT_TYPED_CONSTRAINT_H + +#include "LinearMath/btScalar.h" +#include "btSolverConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define btTypedConstraintData2 btTypedConstraintDoubleData +#define btTypedConstraintDataName "btTypedConstraintDoubleData" +#else +#define btTypedConstraintData2 btTypedConstraintFloatData +#define btTypedConstraintDataName "btTypedConstraintFloatData" +#endif //BT_USE_DOUBLE_PRECISION + +class btSerializer; + +//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility +enum btTypedConstraintType +{ + POINT2POINT_CONSTRAINT_TYPE = 3, + HINGE_CONSTRAINT_TYPE, + CONETWIST_CONSTRAINT_TYPE, + D6_CONSTRAINT_TYPE, + SLIDER_CONSTRAINT_TYPE, + CONTACT_CONSTRAINT_TYPE, + D6_SPRING_CONSTRAINT_TYPE, + GEAR_CONSTRAINT_TYPE, + FIXED_CONSTRAINT_TYPE, + D6_SPRING_2_CONSTRAINT_TYPE, + MAX_CONSTRAINT_TYPE +}; + +enum btConstraintParams +{ + BT_CONSTRAINT_ERP = 1, + BT_CONSTRAINT_STOP_ERP, + BT_CONSTRAINT_CFM, + BT_CONSTRAINT_STOP_CFM +}; + +#if 1 +#define btAssertConstrParams(_par) btAssert(_par) +#else +#define btAssertConstrParams(_par) +#endif + +ATTRIBUTE_ALIGNED16(struct) +btJointFeedback +{ + BT_DECLARE_ALIGNED_ALLOCATOR(); + btVector3 m_appliedForceBodyA; + btVector3 m_appliedTorqueBodyA; + btVector3 m_appliedForceBodyB; + btVector3 m_appliedTorqueBodyB; +}; + +///TypedConstraint is the baseclass for Bullet constraints and vehicles +ATTRIBUTE_ALIGNED16(class) +btTypedConstraint : public btTypedObject +{ + int m_userConstraintType; + + union { + int m_userConstraintId; + void* m_userConstraintPtr; + }; + + btScalar m_breakingImpulseThreshold; + bool m_isEnabled; + bool m_needsFeedback; + int m_overrideNumSolverIterations; + + btTypedConstraint& operator=(btTypedConstraint& other) + { + btAssert(0); + (void)other; + return *this; + } + +protected: + btRigidBody& m_rbA; + btRigidBody& m_rbB; + btScalar m_appliedImpulse; + btScalar m_dbgDrawSize; + btJointFeedback* m_jointFeedback; + + ///internal method used by the constraint solver, don't use them directly + btScalar getMotorFactor(btScalar pos, btScalar lowLim, btScalar uppLim, btScalar vel, btScalar timeFact); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + virtual ~btTypedConstraint(){}; + btTypedConstraint(btTypedConstraintType type, btRigidBody & rbA); + btTypedConstraint(btTypedConstraintType type, btRigidBody & rbA, btRigidBody & rbB); + + struct btConstraintInfo1 + { + int m_numConstraintRows, nub; + }; + + static btRigidBody& getFixedBody(); + + struct btConstraintInfo2 + { + // integrator parameters: frames per second (1/stepsize), default error + // reduction parameter (0..1). + btScalar fps, erp; + + // for the first and second body, pointers to two (linear and angular) + // n*3 jacobian sub matrices, stored by rows. these matrices will have + // been initialized to 0 on entry. if the second body is zero then the + // J2xx pointers may be 0. + btScalar *m_J1linearAxis, *m_J1angularAxis, *m_J2linearAxis, *m_J2angularAxis; + + // elements to jump from one row to the next in J's + int rowskip; + + // right hand sides of the equation J*v = c + cfm * lambda. cfm is the + // "constraint force mixing" vector. c is set to zero on entry, cfm is + // set to a constant value (typically very small or zero) value on entry. + btScalar *m_constraintError, *cfm; + + // lo and hi limits for variables (set to -/+ infinity on entry). + btScalar *m_lowerLimit, *m_upperLimit; + + // number of solver iterations + int m_numIterations; + + //damping of the velocity + btScalar m_damping; + }; + + int getOverrideNumSolverIterations() const + { + return m_overrideNumSolverIterations; + } + + ///override the number of constraint solver iterations used to solve this constraint + ///-1 will use the default number of iterations, as specified in SolverInfo.m_numIterations + void setOverrideNumSolverIterations(int overideNumIterations) + { + m_overrideNumSolverIterations = overideNumIterations; + } + + ///internal method used by the constraint solver, don't use them directly + virtual void buildJacobian(){}; + + ///internal method used by the constraint solver, don't use them directly + virtual void setupSolverConstraint(btConstraintArray & ca, int solverBodyA, int solverBodyB, btScalar timeStep) + { + (void)ca; + (void)solverBodyA; + (void)solverBodyB; + (void)timeStep; + } + + ///internal method used by the constraint solver, don't use them directly + virtual void getInfo1(btConstraintInfo1 * info) = 0; + + ///internal method used by the constraint solver, don't use them directly + virtual void getInfo2(btConstraintInfo2 * info) = 0; + + ///internal method used by the constraint solver, don't use them directly + void internalSetAppliedImpulse(btScalar appliedImpulse) + { + m_appliedImpulse = appliedImpulse; + } + ///internal method used by the constraint solver, don't use them directly + btScalar internalGetAppliedImpulse() + { + return m_appliedImpulse; + } + + btScalar getBreakingImpulseThreshold() const + { + return m_breakingImpulseThreshold; + } + + void setBreakingImpulseThreshold(btScalar threshold) + { + m_breakingImpulseThreshold = threshold; + } + + bool isEnabled() const + { + return m_isEnabled; + } + + void setEnabled(bool enabled) + { + m_isEnabled = enabled; + } + + ///internal method used by the constraint solver, don't use them directly + virtual void solveConstraintObsolete(btSolverBody& /*bodyA*/, btSolverBody& /*bodyB*/, btScalar /*timeStep*/){}; + + const btRigidBody& getRigidBodyA() const + { + return m_rbA; + } + const btRigidBody& getRigidBodyB() const + { + return m_rbB; + } + + btRigidBody& getRigidBodyA() + { + return m_rbA; + } + btRigidBody& getRigidBodyB() + { + return m_rbB; + } + + int getUserConstraintType() const + { + return m_userConstraintType; + } + + void setUserConstraintType(int userConstraintType) + { + m_userConstraintType = userConstraintType; + }; + + void setUserConstraintId(int uid) + { + m_userConstraintId = uid; + } + + int getUserConstraintId() const + { + return m_userConstraintId; + } + + void setUserConstraintPtr(void* ptr) + { + m_userConstraintPtr = ptr; + } + + void* getUserConstraintPtr() + { + return m_userConstraintPtr; + } + + void setJointFeedback(btJointFeedback * jointFeedback) + { + m_jointFeedback = jointFeedback; + } + + const btJointFeedback* getJointFeedback() const + { + return m_jointFeedback; + } + + btJointFeedback* getJointFeedback() + { + return m_jointFeedback; + } + + int getUid() const + { + return m_userConstraintId; + } + + bool needsFeedback() const + { + return m_needsFeedback; + } + + ///enableFeedback will allow to read the applied linear and angular impulse + ///use getAppliedImpulse, getAppliedLinearImpulse and getAppliedAngularImpulse to read feedback information + void enableFeedback(bool needsFeedback) + { + m_needsFeedback = needsFeedback; + } + + ///getAppliedImpulse is an estimated total applied impulse. + ///This feedback could be used to determine breaking constraints or playing sounds. + btScalar getAppliedImpulse() const + { + btAssert(m_needsFeedback); + return m_appliedImpulse; + } + + btTypedConstraintType getConstraintType() const + { + return btTypedConstraintType(m_objectType); + } + + void setDbgDrawSize(btScalar dbgDrawSize) + { + m_dbgDrawSize = dbgDrawSize; + } + btScalar getDbgDrawSize() + { + return m_dbgDrawSize; + } + + ///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + ///If no axis is provided, it uses the default axis for this constraint. + virtual void setParam(int num, btScalar value, int axis = -1) = 0; + + ///return the local value of parameter + virtual btScalar getParam(int num, int axis = -1) const = 0; + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const; +}; + +// returns angle in range [-SIMD_2_PI, SIMD_2_PI], closest to one of the limits +// all arguments should be normalized angles (i.e. in range [-SIMD_PI, SIMD_PI]) +SIMD_FORCE_INLINE btScalar btAdjustAngleToLimits(btScalar angleInRadians, btScalar angleLowerLimitInRadians, btScalar angleUpperLimitInRadians) +{ + if (angleLowerLimitInRadians >= angleUpperLimitInRadians) + { + return angleInRadians; + } + else if (angleInRadians < angleLowerLimitInRadians) + { + btScalar diffLo = btFabs(btNormalizeAngle(angleLowerLimitInRadians - angleInRadians)); + btScalar diffHi = btFabs(btNormalizeAngle(angleUpperLimitInRadians - angleInRadians)); + return (diffLo < diffHi) ? angleInRadians : (angleInRadians + SIMD_2_PI); + } + else if (angleInRadians > angleUpperLimitInRadians) + { + btScalar diffHi = btFabs(btNormalizeAngle(angleInRadians - angleUpperLimitInRadians)); + btScalar diffLo = btFabs(btNormalizeAngle(angleInRadians - angleLowerLimitInRadians)); + return (diffLo < diffHi) ? (angleInRadians - SIMD_2_PI) : angleInRadians; + } + else + { + return angleInRadians; + } +} + +// clang-format off + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btTypedConstraintFloatData +{ + btRigidBodyFloatData *m_rbA; + btRigidBodyFloatData *m_rbB; + char *m_name; + + int m_objectType; + int m_userConstraintType; + int m_userConstraintId; + int m_needsFeedback; + + float m_appliedImpulse; + float m_dbgDrawSize; + + int m_disableCollisionsBetweenLinkedBodies; + int m_overrideNumSolverIterations; + + float m_breakingImpulseThreshold; + int m_isEnabled; + +}; + + + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 + +#define BT_BACKWARDS_COMPATIBLE_SERIALIZATION +#ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +///this structure is not used, except for loading pre-2.82 .bullet files +struct btTypedConstraintData +{ + btRigidBodyData *m_rbA; + btRigidBodyData *m_rbB; + char *m_name; + + int m_objectType; + int m_userConstraintType; + int m_userConstraintId; + int m_needsFeedback; + + float m_appliedImpulse; + float m_dbgDrawSize; + + int m_disableCollisionsBetweenLinkedBodies; + int m_overrideNumSolverIterations; + + float m_breakingImpulseThreshold; + int m_isEnabled; + +}; +#endif //BACKWARDS_COMPATIBLE + +struct btTypedConstraintDoubleData +{ + btRigidBodyDoubleData *m_rbA; + btRigidBodyDoubleData *m_rbB; + char *m_name; + + int m_objectType; + int m_userConstraintType; + int m_userConstraintId; + int m_needsFeedback; + + double m_appliedImpulse; + double m_dbgDrawSize; + + int m_disableCollisionsBetweenLinkedBodies; + int m_overrideNumSolverIterations; + + double m_breakingImpulseThreshold; + int m_isEnabled; + char padding[4]; + +}; + +// clang-format on + +SIMD_FORCE_INLINE int btTypedConstraint::calculateSerializeBufferSize() const +{ + return sizeof(btTypedConstraintData2); +} + +class btAngularLimit +{ +private: + btScalar + m_center, + m_halfRange, + m_softness, + m_biasFactor, + m_relaxationFactor, + m_correction, + m_sign; + + bool + m_solveLimit; + +public: + /// Default constructor initializes limit as inactive, allowing free constraint movement + btAngularLimit() + : m_center(0.0f), + m_halfRange(-1.0f), + m_softness(0.9f), + m_biasFactor(0.3f), + m_relaxationFactor(1.0f), + m_correction(0.0f), + m_sign(0.0f), + m_solveLimit(false) + { + } + + /// Sets all limit's parameters. + /// When low > high limit becomes inactive. + /// When high - low > 2PI limit is ineffective too becouse no angle can exceed the limit + void set(btScalar low, btScalar high, btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f); + + /// Checks conastaint angle against limit. If limit is active and the angle violates the limit + /// correction is calculated. + void test(const btScalar angle); + + /// Returns limit's softness + inline btScalar getSoftness() const + { + return m_softness; + } + + /// Returns limit's bias factor + inline btScalar getBiasFactor() const + { + return m_biasFactor; + } + + /// Returns limit's relaxation factor + inline btScalar getRelaxationFactor() const + { + return m_relaxationFactor; + } + + /// Returns correction value evaluated when test() was invoked + inline btScalar getCorrection() const + { + return m_correction; + } + + /// Returns sign value evaluated when test() was invoked + inline btScalar getSign() const + { + return m_sign; + } + + /// Gives half of the distance between min and max limit angle + inline btScalar getHalfRange() const + { + return m_halfRange; + } + + /// Returns true when the last test() invocation recognized limit violation + inline bool isLimit() const + { + return m_solveLimit; + } + + /// Checks given angle against limit. If limit is active and angle doesn't fit it, the angle + /// returned is modified so it equals to the limit closest to given angle. + void fit(btScalar& angle) const; + + /// Returns correction value multiplied by sign value + btScalar getError() const; + + btScalar getLow() const; + + btScalar getHigh() const; +}; + +#endif //BT_TYPED_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.h.i new file mode 100644 index 00000000..217bffa0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btTypedConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btTypedConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp new file mode 100644 index 00000000..42ed1fbb --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp @@ -0,0 +1,80 @@ +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btUniversalConstraint.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "LinearMath/btTransformUtil.h" + +#define UNIV_EPS btScalar(0.01f) + +// constructor +// anchor, axis1 and axis2 are in world coordinate system +// axis1 must be orthogonal to axis2 +btUniversalConstraint::btUniversalConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& anchor, const btVector3& axis1, const btVector3& axis2) + : btGeneric6DofConstraint(rbA, rbB, btTransform::getIdentity(), btTransform::getIdentity(), true), + m_anchor(anchor), + m_axis1(axis1), + m_axis2(axis2) +{ + // build frame basis + // 6DOF constraint uses Euler angles and to define limits + // it is assumed that rotational order is : + // Z - first, allowed limits are (-PI,PI); + // new position of Y - second (allowed limits are (-PI/2 + epsilon, PI/2 - epsilon), where epsilon is a small positive number + // used to prevent constraint from instability on poles; + // new position of X, allowed limits are (-PI,PI); + // So to simulate ODE Universal joint we should use parent axis as Z, child axis as Y and limit all other DOFs + // Build the frame in world coordinate system first + btVector3 zAxis = m_axis1.normalize(); + btVector3 yAxis = m_axis2.normalize(); + btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system + btTransform frameInW; + frameInW.setIdentity(); + frameInW.getBasis().setValue(xAxis[0], yAxis[0], zAxis[0], + xAxis[1], yAxis[1], zAxis[1], + xAxis[2], yAxis[2], zAxis[2]); + frameInW.setOrigin(anchor); + // now get constraint frame in local coordinate systems + m_frameInA = rbA.getCenterOfMassTransform().inverse() * frameInW; + m_frameInB = rbB.getCenterOfMassTransform().inverse() * frameInW; + // sei limits + setLinearLowerLimit(btVector3(0., 0., 0.)); + setLinearUpperLimit(btVector3(0., 0., 0.)); + setAngularLowerLimit(btVector3(0.f, -SIMD_HALF_PI + UNIV_EPS, -SIMD_PI + UNIV_EPS)); + setAngularUpperLimit(btVector3(0.f, SIMD_HALF_PI - UNIV_EPS, SIMD_PI - UNIV_EPS)); +} + +void btUniversalConstraint::setAxis(const btVector3& axis1, const btVector3& axis2) +{ + m_axis1 = axis1; + m_axis2 = axis2; + + btVector3 zAxis = axis1.normalized(); + btVector3 yAxis = axis2.normalized(); + btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system + + btTransform frameInW; + frameInW.setIdentity(); + frameInW.getBasis().setValue(xAxis[0], yAxis[0], zAxis[0], + xAxis[1], yAxis[1], zAxis[1], + xAxis[2], yAxis[2], zAxis[2]); + frameInW.setOrigin(m_anchor); + + // now get constraint frame in local coordinate systems + m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW; + m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW; + + calculateTransforms(); +} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp.i new file mode 100644 index 00000000..5b79b9a5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp ---------------- + +%include "BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp" + +%{ +#include "BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.h b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.h new file mode 100644 index 00000000..8c24d93a --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.h @@ -0,0 +1,59 @@ +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +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_UNIVERSAL_CONSTRAINT_H +#define BT_UNIVERSAL_CONSTRAINT_H + +#include "LinearMath/btVector3.h" +#include "btTypedConstraint.h" +#include "btGeneric6DofConstraint.h" + +/// Constraint similar to ODE Universal Joint +/// has 2 rotatioonal degrees of freedom, similar to Euler rotations around Z (axis 1) +/// and Y (axis 2) +/// Description from ODE manual : +/// "Given axis 1 on body 1, and axis 2 on body 2 that is perpendicular to axis 1, it keeps them perpendicular. +/// In other words, rotation of the two bodies about the direction perpendicular to the two axes will be equal." + +ATTRIBUTE_ALIGNED16(class) +btUniversalConstraint : public btGeneric6DofConstraint +{ +protected: + btVector3 m_anchor; + btVector3 m_axis1; + btVector3 m_axis2; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + // constructor + // anchor, axis1 and axis2 are in world coordinate system + // axis1 must be orthogonal to axis2 + btUniversalConstraint(btRigidBody & rbA, btRigidBody & rbB, const btVector3& anchor, const btVector3& axis1, const btVector3& axis2); + // access + const btVector3& getAnchor() { return m_calculatedTransformA.getOrigin(); } + const btVector3& getAnchor2() { return m_calculatedTransformB.getOrigin(); } + const btVector3& getAxis1() { return m_axis1; } + const btVector3& getAxis2() { return m_axis2; } + btScalar getAngle1() { return getAngle(2); } + btScalar getAngle2() { return getAngle(1); } + // limits + void setUpperLimit(btScalar ang1max, btScalar ang2max) { setAngularUpperLimit(btVector3(0.f, ang1max, ang2max)); } + void setLowerLimit(btScalar ang1min, btScalar ang2min) { setAngularLowerLimit(btVector3(0.f, ang1min, ang2min)); } + + void setAxis(const btVector3& axis1, const btVector3& axis2); +}; + +#endif // BT_UNIVERSAL_CONSTRAINT_H diff --git a/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.h.i b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.h.i new file mode 100644 index 00000000..c669fa9d --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/ConstraintSolver/btUniversalConstraint.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/ConstraintSolver/btUniversalConstraint.h ---------------- + +%include "BulletDynamics/ConstraintSolver/btUniversalConstraint.h" + +%{ +#include "BulletDynamics/ConstraintSolver/btUniversalConstraint.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btActionInterface.h b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btActionInterface.h new file mode 100644 index 00000000..51a3fa47 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btActionInterface.h @@ -0,0 +1,41 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef _BT_ACTION_INTERFACE_H +#define _BT_ACTION_INTERFACE_H + +class btIDebugDraw; +class btCollisionWorld; + +#include "LinearMath/btScalar.h" +#include "btRigidBody.h" + +///Basic interface to allow actions such as vehicles and characters to be updated inside a btDynamicsWorld +class btActionInterface +{ +protected: + static btRigidBody& getFixedBody(); + +public: + virtual ~btActionInterface() + { + } + + virtual void updateAction(btCollisionWorld* collisionWorld, btScalar deltaTimeStep) = 0; + + virtual void debugDraw(btIDebugDraw* debugDrawer) = 0; +}; + +#endif //_BT_ACTION_INTERFACE_H diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btActionInterface.h.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btActionInterface.h.i new file mode 100644 index 00000000..e3342164 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btActionInterface.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btActionInterface.h ---------------- + +%include "BulletDynamics/Dynamics/btActionInterface.h" + +%{ +#include "BulletDynamics/Dynamics/btActionInterface.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp new file mode 100644 index 00000000..85f342cc --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp @@ -0,0 +1,1484 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +#include + +#include "btDiscreteDynamicsWorld.h" + +//collision detection +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h" +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +#include "BulletCollision/CollisionShapes/btCollisionShape.h" +#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" +#include "LinearMath/btTransformUtil.h" +#include "LinearMath/btQuickprof.h" + +//rigidbody & constraints +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h" +#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +#include "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h" +#include "BulletDynamics/ConstraintSolver/btHingeConstraint.h" +#include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h" +#include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h" +#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h" +#include "BulletDynamics/ConstraintSolver/btSliderConstraint.h" +#include "BulletDynamics/ConstraintSolver/btContactConstraint.h" + +#include "LinearMath/btIDebugDraw.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" + +#include "BulletDynamics/Dynamics/btActionInterface.h" +#include "LinearMath/btQuickprof.h" +#include "LinearMath/btMotionState.h" + +#include "LinearMath/btSerializer.h" + +#if 0 +btAlignedObjectArray debugContacts; +btAlignedObjectArray debugNormals; +int startHit=2; +int firstHit=startHit; +#endif + +SIMD_FORCE_INLINE int btGetConstraintIslandId(const btTypedConstraint* lhs) +{ + int islandId; + + const btCollisionObject& rcolObj0 = lhs->getRigidBodyA(); + const btCollisionObject& rcolObj1 = lhs->getRigidBodyB(); + islandId = rcolObj0.getIslandTag() >= 0 ? rcolObj0.getIslandTag() : rcolObj1.getIslandTag(); + return islandId; +} + +class btSortConstraintOnIslandPredicate +{ +public: + bool operator()(const btTypedConstraint* lhs, const btTypedConstraint* rhs) const + { + int rIslandId0, lIslandId0; + rIslandId0 = btGetConstraintIslandId(rhs); + lIslandId0 = btGetConstraintIslandId(lhs); + return lIslandId0 < rIslandId0; + } +}; + +struct InplaceSolverIslandCallback : public btSimulationIslandManager::IslandCallback +{ + btContactSolverInfo* m_solverInfo; + btConstraintSolver* m_solver; + btTypedConstraint** m_sortedConstraints; + int m_numConstraints; + btIDebugDraw* m_debugDrawer; + btDispatcher* m_dispatcher; + + btAlignedObjectArray m_bodies; + btAlignedObjectArray m_manifolds; + btAlignedObjectArray m_constraints; + + InplaceSolverIslandCallback( + btConstraintSolver* solver, + btStackAlloc* stackAlloc, + btDispatcher* dispatcher) + : m_solverInfo(NULL), + m_solver(solver), + m_sortedConstraints(NULL), + m_numConstraints(0), + m_debugDrawer(NULL), + m_dispatcher(dispatcher) + { + } + + InplaceSolverIslandCallback& operator=(InplaceSolverIslandCallback& other) + { + btAssert(0); + (void)other; + return *this; + } + + SIMD_FORCE_INLINE void setup(btContactSolverInfo* solverInfo, btTypedConstraint** sortedConstraints, int numConstraints, btIDebugDraw* debugDrawer) + { + btAssert(solverInfo); + m_solverInfo = solverInfo; + m_sortedConstraints = sortedConstraints; + m_numConstraints = numConstraints; + m_debugDrawer = debugDrawer; + m_bodies.resize(0); + m_manifolds.resize(0); + m_constraints.resize(0); + } + + virtual void processIsland(btCollisionObject** bodies, int numBodies, btPersistentManifold** manifolds, int numManifolds, int islandId) + { + if (islandId < 0) + { + ///we don't split islands, so all constraints/contact manifolds/bodies are passed into the solver regardless the island id + m_solver->solveGroup(bodies, numBodies, manifolds, numManifolds, &m_sortedConstraints[0], m_numConstraints, *m_solverInfo, m_debugDrawer, m_dispatcher); + } + else + { + //also add all non-contact constraints/joints for this island + btTypedConstraint** startConstraint = 0; + int numCurConstraints = 0; + int i; + + //find the first constraint for this island + for (i = 0; i < m_numConstraints; i++) + { + if (btGetConstraintIslandId(m_sortedConstraints[i]) == islandId) + { + startConstraint = &m_sortedConstraints[i]; + break; + } + } + //count the number of constraints in this island + for (; i < m_numConstraints; i++) + { + if (btGetConstraintIslandId(m_sortedConstraints[i]) == islandId) + { + numCurConstraints++; + } + } + + if (m_solverInfo->m_minimumSolverBatchSize <= 1) + { + m_solver->solveGroup(bodies, numBodies, manifolds, numManifolds, startConstraint, numCurConstraints, *m_solverInfo, m_debugDrawer, m_dispatcher); + } + else + { + for (i = 0; i < numBodies; i++) + m_bodies.push_back(bodies[i]); + for (i = 0; i < numManifolds; i++) + m_manifolds.push_back(manifolds[i]); + for (i = 0; i < numCurConstraints; i++) + m_constraints.push_back(startConstraint[i]); + if ((m_constraints.size() + m_manifolds.size()) > m_solverInfo->m_minimumSolverBatchSize) + { + processConstraints(); + } + else + { + //printf("deferred\n"); + } + } + } + } + void processConstraints() + { + btCollisionObject** bodies = m_bodies.size() ? &m_bodies[0] : 0; + btPersistentManifold** manifold = m_manifolds.size() ? &m_manifolds[0] : 0; + btTypedConstraint** constraints = m_constraints.size() ? &m_constraints[0] : 0; + + m_solver->solveGroup(bodies, m_bodies.size(), manifold, m_manifolds.size(), constraints, m_constraints.size(), *m_solverInfo, m_debugDrawer, m_dispatcher); + m_bodies.resize(0); + m_manifolds.resize(0); + m_constraints.resize(0); + } +}; + +btDiscreteDynamicsWorld::btDiscreteDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration) + : btDynamicsWorld(dispatcher, pairCache, collisionConfiguration), + m_sortedConstraints(), + m_solverIslandCallback(NULL), + m_constraintSolver(constraintSolver), + m_gravity(0, -10, 0), + m_localTime(0), + m_fixedTimeStep(0), + m_synchronizeAllMotionStates(false), + m_applySpeculativeContactRestitution(false), + m_profileTimings(0), + m_latencyMotionStateInterpolation(true) + +{ + if (!m_constraintSolver) + { + void* mem = btAlignedAlloc(sizeof(btSequentialImpulseConstraintSolver), 16); + m_constraintSolver = new (mem) btSequentialImpulseConstraintSolver; + m_ownsConstraintSolver = true; + } + else + { + m_ownsConstraintSolver = false; + } + + { + void* mem = btAlignedAlloc(sizeof(btSimulationIslandManager), 16); + m_islandManager = new (mem) btSimulationIslandManager(); + } + + m_ownsIslandManager = true; + + { + void* mem = btAlignedAlloc(sizeof(InplaceSolverIslandCallback), 16); + m_solverIslandCallback = new (mem) InplaceSolverIslandCallback(m_constraintSolver, 0, dispatcher); + } +} + +btDiscreteDynamicsWorld::~btDiscreteDynamicsWorld() +{ + //only delete it when we created it + if (m_ownsIslandManager) + { + m_islandManager->~btSimulationIslandManager(); + btAlignedFree(m_islandManager); + } + if (m_solverIslandCallback) + { + m_solverIslandCallback->~InplaceSolverIslandCallback(); + btAlignedFree(m_solverIslandCallback); + } + if (m_ownsConstraintSolver) + { + m_constraintSolver->~btConstraintSolver(); + btAlignedFree(m_constraintSolver); + } +} + +void btDiscreteDynamicsWorld::saveKinematicState(btScalar timeStep) +{ + ///would like to iterate over m_nonStaticRigidBodies, but unfortunately old API allows + ///to switch status _after_ adding kinematic objects to the world + ///fix it for Bullet 3.x release + for (int i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + btRigidBody* body = btRigidBody::upcast(colObj); + if (body && body->getActivationState() != ISLAND_SLEEPING) + { + if (body->isKinematicObject()) + { + //to calculate velocities next frame + body->saveKinematicState(timeStep); + } + } + } +} + +void btDiscreteDynamicsWorld::debugDrawWorld() +{ +//\1("debugDrawWorld"); + // printf("btDiscreteDynamicsWorld::debugDrawWorld ---------\n"); + + btCollisionWorld::debugDrawWorld(); + + bool drawConstraints = false; + if (getDebugDrawer()) + { + int mode = getDebugDrawer()->getDebugMode(); + // printf("mode = %d\n", mode); + if (mode & (btIDebugDraw::DBG_DrawConstraints | btIDebugDraw::DBG_DrawConstraintLimits)) + { + drawConstraints = true; + } + // printf("drawConstraints = %d\n", drawConstraints); + } + if (drawConstraints) + { + for (int i = getNumConstraints() - 1; i >= 0; i--) + { + // printf("debugDrawConstraint[%d]\n", i); + btTypedConstraint* constraint = getConstraint(i); + debugDrawConstraint(constraint); + } + } + + if (getDebugDrawer() && (getDebugDrawer()->getDebugMode() & (btIDebugDraw::DBG_DrawWireframe | btIDebugDraw::DBG_DrawAabb | btIDebugDraw::DBG_DrawNormals))) + { + int i; + // printf("m_nonStaticRigidBodies.size() = %d\n", m_nonStaticRigidBodies.size()); + if (getDebugDrawer() && getDebugDrawer()->getDebugMode()) + { + // printf("getDebugDrawer()->getDebugMode() = %d\n", getDebugDrawer()->getDebugMode()); + for (i = 0; i < m_actions.size(); i++) + { + // printf("m_actions[%d]->debugDraw(getDebugDrawer())\n", i); + m_actions[i]->debugDraw(m_debugDrawer); + } + } + } + if (getDebugDrawer()) + getDebugDrawer()->flushLines(); +} + +void btDiscreteDynamicsWorld::clearForces() +{ + ///@todo: iterate over awake simulation islands! + for (int i = 0; i < m_nonStaticRigidBodies.size(); i++) + { + btRigidBody* body = m_nonStaticRigidBodies[i]; + //need to check if next line is ok + //it might break backward compatibility (people applying forces on sleeping objects get never cleared and accumulate on wake-up + body->clearForces(); + } +} + +///apply gravity, call this once per timestep +void btDiscreteDynamicsWorld::applyGravity() +{ + ///@todo: iterate over awake simulation islands! + for (int i = 0; i < m_nonStaticRigidBodies.size(); i++) + { + btRigidBody* body = m_nonStaticRigidBodies[i]; + if (body->isActive()) + { + body->applyGravity(); + } + } +} + +void btDiscreteDynamicsWorld::synchronizeSingleMotionState(btRigidBody* body) +{ + btAssert(body); + + if (body->getMotionState() && !body->isStaticOrKinematicObject()) + { + //we need to call the update at least once, even for sleeping objects + //otherwise the 'graphics' transform never updates properly + ///@todo: add 'dirty' flag + //if (body->getActivationState() != ISLAND_SLEEPING) + { + btTransform interpolatedTransform; + btTransformUtil::integrateTransform(body->getInterpolationWorldTransform(), + body->getInterpolationLinearVelocity(), body->getInterpolationAngularVelocity(), + (m_latencyMotionStateInterpolation && m_fixedTimeStep) ? m_localTime - m_fixedTimeStep : m_localTime * body->getHitFraction(), + interpolatedTransform); + body->getMotionState()->setWorldTransform(interpolatedTransform); + } + } +} + +void btDiscreteDynamicsWorld::synchronizeMotionStates() +{ + // BT_PROFILE("synchronizeMotionStates"); + if (m_synchronizeAllMotionStates) + { + //iterate over all collision objects + for (int i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + btRigidBody* body = btRigidBody::upcast(colObj); + if (body) + synchronizeSingleMotionState(body); + } + } + else + { + //iterate over all active rigid bodies + for (int i = 0; i < m_nonStaticRigidBodies.size(); i++) + { + btRigidBody* body = m_nonStaticRigidBodies[i]; + if (body->isActive()) + synchronizeSingleMotionState(body); + } + } +} + +int btDiscreteDynamicsWorld::stepSimulation(btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep) +{ + startProfiling(timeStep); + + int numSimulationSubSteps = 0; + + if (maxSubSteps) + { + //fixed timestep with interpolation + m_fixedTimeStep = fixedTimeStep; + m_localTime += timeStep; + if (m_localTime >= fixedTimeStep) + { + numSimulationSubSteps = int(m_localTime / fixedTimeStep); + m_localTime -= numSimulationSubSteps * fixedTimeStep; + } + } + else + { + //variable timestep + fixedTimeStep = timeStep; + m_localTime = m_latencyMotionStateInterpolation ? 0 : timeStep; + m_fixedTimeStep = 0; + if (btFuzzyZero(timeStep)) + { + numSimulationSubSteps = 0; + maxSubSteps = 0; + } + else + { + numSimulationSubSteps = 1; + maxSubSteps = 1; + } + } + + // printf("numSimulationSubSteps = %d, maxSubSteps = %d\n", numSimulationSubSteps, maxSubSteps); + + // printf("btDiscreteDynamicsWorld::stepSimulation ----------\n"); + + //process some debugging flags + if (getDebugDrawer()) + { + btIDebugDraw* debugDrawer = getDebugDrawer(); + // printf("debugDrawer pointer: %p\n", (void*)debugDrawer); + // printf("debugDrawer->getDebugMode() = %d\n", debugDrawer->getDebugMode()); + gDisableDeactivation = (debugDrawer->getDebugMode() & btIDebugDraw::DBG_NoDeactivation) != 0; + } + if (numSimulationSubSteps) + { + //clamp the number of substeps, to prevent simulation grinding spiralling down to a halt + int clampedSimulationSteps = (numSimulationSubSteps > maxSubSteps) ? maxSubSteps : numSimulationSubSteps; + // printf("clampedSimulationSteps = %d\n", clampedSimulationSteps); + + saveKinematicState(fixedTimeStep * clampedSimulationSteps); + + applyGravity(); + + for (int i = 0; i < clampedSimulationSteps; i++) + { + internalSingleStepSimulation(fixedTimeStep); + synchronizeMotionStates(); + } + } + else + { + // printf("synchronizeMotionStates\n"); + synchronizeMotionStates(); + } + + clearForces(); + +#ifndef BT_NO_PROFILE + CProfileManager::Increment_Frame_Counter(); +#endif //BT_NO_PROFILE + + return numSimulationSubSteps; +} + +void btDiscreteDynamicsWorld::internalSingleStepSimulation(btScalar timeStep) +{ +//\1("internalSingleStepSimulation"); + + if (0 != m_internalPreTickCallback) + { + (*m_internalPreTickCallback)(this, timeStep); + } + + ///apply gravity, predict motion + predictUnconstraintMotion(timeStep); + + btDispatcherInfo& dispatchInfo = getDispatchInfo(); + + dispatchInfo.m_timeStep = timeStep; + dispatchInfo.m_stepCount = 0; + dispatchInfo.m_debugDraw = getDebugDrawer(); + + createPredictiveContacts(timeStep); + + ///perform collision detection + performDiscreteCollisionDetection(); + + calculateSimulationIslands(); + + getSolverInfo().m_timeStep = timeStep; + + ///solve contact and other joint constraints + solveConstraints(getSolverInfo()); + + ///CallbackTriggers(); + + ///integrate transforms + + integrateTransforms(timeStep); + + ///update vehicle simulation + updateActions(timeStep); + + updateActivationState(timeStep); + + if (0 != m_internalTickCallback) + { + (*m_internalTickCallback)(this, timeStep); + } +} + +void btDiscreteDynamicsWorld::setGravity(const btVector3& gravity) +{ + m_gravity = gravity; + for (int i = 0; i < m_nonStaticRigidBodies.size(); i++) + { + btRigidBody* body = m_nonStaticRigidBodies[i]; + if (body->isActive() && !(body->getFlags() & BT_DISABLE_WORLD_GRAVITY)) + { + body->setGravity(gravity); + } + } +} + +btVector3 btDiscreteDynamicsWorld::getGravity() const +{ + return m_gravity; +} + +void btDiscreteDynamicsWorld::addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup, int collisionFilterMask) +{ + btCollisionWorld::addCollisionObject(collisionObject, collisionFilterGroup, collisionFilterMask); +} + +void btDiscreteDynamicsWorld::removeCollisionObject(btCollisionObject* collisionObject) +{ + btRigidBody* body = btRigidBody::upcast(collisionObject); + if (body) + removeRigidBody(body); + else + btCollisionWorld::removeCollisionObject(collisionObject); +} + +void btDiscreteDynamicsWorld::removeRigidBody(btRigidBody* body) +{ + m_nonStaticRigidBodies.remove(body); + btCollisionWorld::removeCollisionObject(body); +} + +void btDiscreteDynamicsWorld::addRigidBody(btRigidBody* body) +{ + if (!body->isStaticOrKinematicObject() && !(body->getFlags() & BT_DISABLE_WORLD_GRAVITY)) + { + body->setGravity(m_gravity); + } + + if (body->getCollisionShape()) + { + if (!body->isStaticObject()) + { + m_nonStaticRigidBodies.push_back(body); + } + else + { + body->setActivationState(ISLAND_SLEEPING); + } + + bool isDynamic = !(body->isStaticObject() || body->isKinematicObject()); + int collisionFilterGroup = isDynamic ? int(btBroadphaseProxy::DefaultFilter) : int(btBroadphaseProxy::StaticFilter); + int collisionFilterMask = isDynamic ? int(btBroadphaseProxy::AllFilter) : int(btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter); + + addCollisionObject(body, collisionFilterGroup, collisionFilterMask); + } +} + +void btDiscreteDynamicsWorld::addRigidBody(btRigidBody* body, int group, int mask) +{ + if (!body->isStaticOrKinematicObject() && !(body->getFlags() & BT_DISABLE_WORLD_GRAVITY)) + { + body->setGravity(m_gravity); + } + + if (body->getCollisionShape()) + { + if (!body->isStaticObject()) + { + m_nonStaticRigidBodies.push_back(body); + } + else + { + body->setActivationState(ISLAND_SLEEPING); + } + addCollisionObject(body, group, mask); + } +} + +void btDiscreteDynamicsWorld::updateActions(btScalar timeStep) +{ +//\1("updateActions"); + + for (int i = 0; i < m_actions.size(); i++) + { + m_actions[i]->updateAction(this, timeStep); + } +} + +void btDiscreteDynamicsWorld::updateActivationState(btScalar timeStep) +{ +//\1("updateActivationState"); + + for (int i = 0; i < m_nonStaticRigidBodies.size(); i++) + { + btRigidBody* body = m_nonStaticRigidBodies[i]; + if (body) + { + body->updateDeactivation(timeStep); + + if (body->wantsSleeping()) + { + if (body->isStaticOrKinematicObject()) + { + body->setActivationState(ISLAND_SLEEPING); + } + else + { + if (body->getActivationState() == ACTIVE_TAG) + body->setActivationState(WANTS_DEACTIVATION); + if (body->getActivationState() == ISLAND_SLEEPING) + { + body->setAngularVelocity(btVector3(0, 0, 0)); + body->setLinearVelocity(btVector3(0, 0, 0)); + } + } + } + else + { + if (body->getActivationState() != DISABLE_DEACTIVATION) + body->setActivationState(ACTIVE_TAG); + } + } + } +} + +void btDiscreteDynamicsWorld::addConstraint(btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies) +{ + m_constraints.push_back(constraint); + //Make sure the two bodies of a type constraint are different (possibly add this to the btTypedConstraint constructor?) + btAssert(&constraint->getRigidBodyA() != &constraint->getRigidBodyB()); + + if (disableCollisionsBetweenLinkedBodies) + { + constraint->getRigidBodyA().addConstraintRef(constraint); + constraint->getRigidBodyB().addConstraintRef(constraint); + } +} + +void btDiscreteDynamicsWorld::removeConstraint(btTypedConstraint* constraint) +{ + m_constraints.remove(constraint); + constraint->getRigidBodyA().removeConstraintRef(constraint); + constraint->getRigidBodyB().removeConstraintRef(constraint); +} + +void btDiscreteDynamicsWorld::addAction(btActionInterface* action) +{ + m_actions.push_back(action); +} + +void btDiscreteDynamicsWorld::removeAction(btActionInterface* action) +{ + m_actions.remove(action); +} + +void btDiscreteDynamicsWorld::addVehicle(btActionInterface* vehicle) +{ + addAction(vehicle); +} + +void btDiscreteDynamicsWorld::removeVehicle(btActionInterface* vehicle) +{ + removeAction(vehicle); +} + +void btDiscreteDynamicsWorld::addCharacter(btActionInterface* character) +{ + addAction(character); +} + +void btDiscreteDynamicsWorld::removeCharacter(btActionInterface* character) +{ + removeAction(character); +} + +void btDiscreteDynamicsWorld::solveConstraints(btContactSolverInfo& solverInfo) +{ +//\1("solveConstraints"); + + m_sortedConstraints.resize(m_constraints.size()); + int i; + for (i = 0; i < getNumConstraints(); i++) + { + m_sortedConstraints[i] = m_constraints[i]; + } + + // btAssert(0); + + m_sortedConstraints.quickSort(btSortConstraintOnIslandPredicate()); + + btTypedConstraint** constraintsPtr = getNumConstraints() ? &m_sortedConstraints[0] : 0; + + m_solverIslandCallback->setup(&solverInfo, constraintsPtr, m_sortedConstraints.size(), getDebugDrawer()); + m_constraintSolver->prepareSolve(getCollisionWorld()->getNumCollisionObjects(), getCollisionWorld()->getDispatcher()->getNumManifolds()); + + /// solve all the constraints for this island + m_islandManager->buildAndProcessIslands(getCollisionWorld()->getDispatcher(), getCollisionWorld(), m_solverIslandCallback); + + m_solverIslandCallback->processConstraints(); + + m_constraintSolver->allSolved(solverInfo, m_debugDrawer); +} + +void btDiscreteDynamicsWorld::calculateSimulationIslands() +{ +//\1("calculateSimulationIslands"); + + getSimulationIslandManager()->updateActivationState(getCollisionWorld(), getCollisionWorld()->getDispatcher()); + + { + //merge islands based on speculative contact manifolds too + for (int i = 0; i < this->m_predictiveManifolds.size(); i++) + { + btPersistentManifold* manifold = m_predictiveManifolds[i]; + + const btCollisionObject* colObj0 = manifold->getBody0(); + const btCollisionObject* colObj1 = manifold->getBody1(); + + if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) && + ((colObj1) && (!(colObj1)->isStaticOrKinematicObject()))) + { + getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(), (colObj1)->getIslandTag()); + } + } + } + + { + int i; + int numConstraints = int(m_constraints.size()); + for (i = 0; i < numConstraints; i++) + { + btTypedConstraint* constraint = m_constraints[i]; + if (constraint->isEnabled()) + { + const btRigidBody* colObj0 = &constraint->getRigidBodyA(); + const btRigidBody* colObj1 = &constraint->getRigidBodyB(); + + if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) && + ((colObj1) && (!(colObj1)->isStaticOrKinematicObject()))) + { + getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(), (colObj1)->getIslandTag()); + } + } + } + } + + //Store the island id in each body + getSimulationIslandManager()->storeIslandActivationState(getCollisionWorld()); +} + +class btClosestNotMeConvexResultCallback : public btCollisionWorld::ClosestConvexResultCallback +{ +public: + btCollisionObject* m_me; + btScalar m_allowedPenetration; + btOverlappingPairCache* m_pairCache; + btDispatcher* m_dispatcher; + +public: + btClosestNotMeConvexResultCallback(btCollisionObject* me, const btVector3& fromA, const btVector3& toA, btOverlappingPairCache* pairCache, btDispatcher* dispatcher) : btCollisionWorld::ClosestConvexResultCallback(fromA, toA), + m_me(me), + m_allowedPenetration(0.0f), + m_pairCache(pairCache), + m_dispatcher(dispatcher) + { + } + + virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& convexResult, bool normalInWorldSpace) + { + if (convexResult.m_hitCollisionObject == m_me) + return 1.0f; + + //ignore result if there is no contact response + if (!convexResult.m_hitCollisionObject->hasContactResponse()) + return 1.0f; + + btVector3 linVelA, linVelB; + linVelA = m_convexToWorld - m_convexFromWorld; + linVelB = btVector3(0, 0, 0); //toB.getOrigin()-fromB.getOrigin(); + + btVector3 relativeVelocity = (linVelA - linVelB); + //don't report time of impact for motion away from the contact normal (or causes minor penetration) + if (convexResult.m_hitNormalLocal.dot(relativeVelocity) >= -m_allowedPenetration) + return 1.f; + + return ClosestConvexResultCallback::addSingleResult(convexResult, normalInWorldSpace); + } + + virtual bool needsCollision(btBroadphaseProxy* proxy0) const + { + //don't collide with itself + if (proxy0->m_clientObject == m_me) + return false; + + ///don't do CCD when the collision filters are not matching + if (!ClosestConvexResultCallback::needsCollision(proxy0)) + return false; + if (m_pairCache->getOverlapFilterCallback()) { + btBroadphaseProxy* proxy1 = m_me->getBroadphaseHandle(); + bool collides = m_pairCache->needsBroadphaseCollision(proxy0, proxy1); + if (!collides) + { + return false; + } + } + + btCollisionObject* otherObj = (btCollisionObject*)proxy0->m_clientObject; + + if (!m_dispatcher->needsCollision(m_me, otherObj)) + return false; + + //call needsResponse, see http://code.google.com/p/bullet/issues/detail?id=179 + if (m_dispatcher->needsResponse(m_me, otherObj)) + { +#if 0 + ///don't do CCD when there are already contact points (touching contact/penetration) + btAlignedObjectArray manifoldArray; + btBroadphasePair* collisionPair = m_pairCache->findPair(m_me->getBroadphaseHandle(),proxy0); + if (collisionPair) + { + if (collisionPair->m_algorithm) + { + manifoldArray.resize(0); + collisionPair->m_algorithm->getAllContactManifolds(manifoldArray); + for (int j=0;jgetNumContacts()>0) + return false; + } + } + } +#endif + return true; + } + + return false; + } +}; + +///internal debugging variable. this value shouldn't be too high +int gNumClampedCcdMotions = 0; + +void btDiscreteDynamicsWorld::createPredictiveContactsInternal(btRigidBody** bodies, int numBodies, btScalar timeStep) +{ + btTransform predictedTrans; + for (int i = 0; i < numBodies; i++) + { + btRigidBody* body = bodies[i]; + body->setHitFraction(1.f); + + if (body->isActive() && (!body->isStaticOrKinematicObject())) + { + body->predictIntegratedTransform(timeStep, predictedTrans); + + btScalar squareMotion = (predictedTrans.getOrigin() - body->getWorldTransform().getOrigin()).length2(); + + if (getDispatchInfo().m_useContinuous && body->getCcdSquareMotionThreshold() && body->getCcdSquareMotionThreshold() < squareMotion) + { +//\1("predictive convexSweepTest"); + if (body->getCollisionShape()->isConvex()) + { + gNumClampedCcdMotions++; +#ifdef PREDICTIVE_CONTACT_USE_STATIC_ONLY + class StaticOnlyCallback : public btClosestNotMeConvexResultCallback + { + public: + StaticOnlyCallback(btCollisionObject* me, const btVector3& fromA, const btVector3& toA, btOverlappingPairCache* pairCache, btDispatcher* dispatcher) : btClosestNotMeConvexResultCallback(me, fromA, toA, pairCache, dispatcher) + { + } + + virtual bool needsCollision(btBroadphaseProxy* proxy0) const + { + btCollisionObject* otherObj = (btCollisionObject*)proxy0->m_clientObject; + if (!otherObj->isStaticOrKinematicObject()) + return false; + return btClosestNotMeConvexResultCallback::needsCollision(proxy0); + } + }; + + StaticOnlyCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher()); +#else + btClosestNotMeConvexResultCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher()); +#endif + //btConvexShape* convexShape = static_cast(body->getCollisionShape()); + btSphereShape tmpSphere(body->getCcdSweptSphereRadius()); //btConvexShape* convexShape = static_cast(body->getCollisionShape()); + sweepResults.m_allowedPenetration = getDispatchInfo().m_allowedCcdPenetration; + + sweepResults.m_collisionFilterGroup = body->getBroadphaseProxy()->m_collisionFilterGroup; + sweepResults.m_collisionFilterMask = body->getBroadphaseProxy()->m_collisionFilterMask; + btTransform modifiedPredictedTrans = predictedTrans; + modifiedPredictedTrans.setBasis(body->getWorldTransform().getBasis()); + + convexSweepTest(&tmpSphere, body->getWorldTransform(), modifiedPredictedTrans, sweepResults); + if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f)) + { + btVector3 distVec = (predictedTrans.getOrigin() - body->getWorldTransform().getOrigin()) * sweepResults.m_closestHitFraction; + btScalar distance = distVec.dot(-sweepResults.m_hitNormalWorld); + + btMutexLock(&m_predictiveManifoldsMutex); + btPersistentManifold* manifold = m_dispatcher1->getNewManifold(body, sweepResults.m_hitCollisionObject); + m_predictiveManifolds.push_back(manifold); + btMutexUnlock(&m_predictiveManifoldsMutex); + + btVector3 worldPointB = body->getWorldTransform().getOrigin() + distVec; + btVector3 localPointB = sweepResults.m_hitCollisionObject->getWorldTransform().inverse() * worldPointB; + + btManifoldPoint newPoint(btVector3(0, 0, 0), localPointB, sweepResults.m_hitNormalWorld, distance); + + bool isPredictive = true; + int index = manifold->addManifoldPoint(newPoint, isPredictive); + btManifoldPoint& pt = manifold->getContactPoint(index); + pt.m_combinedRestitution = 0; + pt.m_combinedFriction = gCalculateCombinedFrictionCallback(body, sweepResults.m_hitCollisionObject); + pt.m_positionWorldOnA = body->getWorldTransform().getOrigin(); + pt.m_positionWorldOnB = worldPointB; + } + } + } + } + } +} + +void btDiscreteDynamicsWorld::releasePredictiveContacts() +{ +//\1("release predictive contact manifolds"); + + for (int i = 0; i < m_predictiveManifolds.size(); i++) + { + btPersistentManifold* manifold = m_predictiveManifolds[i]; + this->m_dispatcher1->releaseManifold(manifold); + } + m_predictiveManifolds.clear(); +} + +void btDiscreteDynamicsWorld::createPredictiveContacts(btScalar timeStep) +{ +//\1("createPredictiveContacts"); + releasePredictiveContacts(); + if (m_nonStaticRigidBodies.size() > 0) + { + createPredictiveContactsInternal(&m_nonStaticRigidBodies[0], m_nonStaticRigidBodies.size(), timeStep); + } +} + +void btDiscreteDynamicsWorld::integrateTransformsInternal(btRigidBody** bodies, int numBodies, btScalar timeStep) +{ + btTransform predictedTrans; + for (int i = 0; i < numBodies; i++) + { + btRigidBody* body = bodies[i]; + body->setHitFraction(1.f); + + if (body->isActive() && (!body->isStaticOrKinematicObject())) + { + body->predictIntegratedTransform(timeStep, predictedTrans); + + btScalar squareMotion = (predictedTrans.getOrigin() - body->getWorldTransform().getOrigin()).length2(); + + if (getDispatchInfo().m_useContinuous && body->getCcdSquareMotionThreshold() && body->getCcdSquareMotionThreshold() < squareMotion) + { +//\1("CCD motion clamping"); + if (body->getCollisionShape()->isConvex()) + { + gNumClampedCcdMotions++; +#ifdef USE_STATIC_ONLY + class StaticOnlyCallback : public btClosestNotMeConvexResultCallback + { + public: + StaticOnlyCallback(btCollisionObject* me, const btVector3& fromA, const btVector3& toA, btOverlappingPairCache* pairCache, btDispatcher* dispatcher) : btClosestNotMeConvexResultCallback(me, fromA, toA, pairCache, dispatcher) + { + } + + virtual bool needsCollision(btBroadphaseProxy* proxy0) const + { + btCollisionObject* otherObj = (btCollisionObject*)proxy0->m_clientObject; + if (!otherObj->isStaticOrKinematicObject()) + return false; + return btClosestNotMeConvexResultCallback::needsCollision(proxy0); + } + }; + + StaticOnlyCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher()); +#else + btClosestNotMeConvexResultCallback sweepResults(body, body->getWorldTransform().getOrigin(), predictedTrans.getOrigin(), getBroadphase()->getOverlappingPairCache(), getDispatcher()); +#endif + //btConvexShape* convexShape = static_cast(body->getCollisionShape()); + btSphereShape tmpSphere(body->getCcdSweptSphereRadius()); //btConvexShape* convexShape = static_cast(body->getCollisionShape()); + sweepResults.m_allowedPenetration = getDispatchInfo().m_allowedCcdPenetration; + + sweepResults.m_collisionFilterGroup = body->getBroadphaseProxy()->m_collisionFilterGroup; + sweepResults.m_collisionFilterMask = body->getBroadphaseProxy()->m_collisionFilterMask; + btTransform modifiedPredictedTrans = predictedTrans; + modifiedPredictedTrans.setBasis(body->getWorldTransform().getBasis()); + + convexSweepTest(&tmpSphere, body->getWorldTransform(), modifiedPredictedTrans, sweepResults); + if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f)) + { + //printf("clamped integration to hit fraction = %f\n",fraction); + body->setHitFraction(sweepResults.m_closestHitFraction); + body->predictIntegratedTransform(timeStep * body->getHitFraction(), predictedTrans); + body->setHitFraction(0.f); + body->proceedToTransform(predictedTrans); + +#if 0 + btVector3 linVel = body->getLinearVelocity(); + + btScalar maxSpeed = body->getCcdMotionThreshold()/getSolverInfo().m_timeStep; + btScalar maxSpeedSqr = maxSpeed*maxSpeed; + if (linVel.length2()>maxSpeedSqr) + { + linVel.normalize(); + linVel*= maxSpeed; + body->setLinearVelocity(linVel); + btScalar ms2 = body->getLinearVelocity().length2(); + body->predictIntegratedTransform(timeStep, predictedTrans); + + btScalar sm2 = (predictedTrans.getOrigin()-body->getWorldTransform().getOrigin()).length2(); + btScalar smt = body->getCcdSquareMotionThreshold(); + // printf("sm2=%f\n",sm2); + } +#else + + //don't apply the collision response right now, it will happen next frame + //if you really need to, you can uncomment next 3 lines. Note that is uses zero restitution. + //btScalar appliedImpulse = 0.f; + //btScalar depth = 0.f; + //appliedImpulse = resolveSingleCollision(body,(btCollisionObject*)sweepResults.m_hitCollisionObject,sweepResults.m_hitPointWorld,sweepResults.m_hitNormalWorld,getSolverInfo(), depth); + +#endif + + continue; + } + } + } + + body->proceedToTransform(predictedTrans); + } + } +} + +void btDiscreteDynamicsWorld::integrateTransforms(btScalar timeStep) +{ +//\1("integrateTransforms"); + if (m_nonStaticRigidBodies.size() > 0) + { + integrateTransformsInternal(&m_nonStaticRigidBodies[0], m_nonStaticRigidBodies.size(), timeStep); + } + + ///this should probably be switched on by default, but it is not well tested yet + if (m_applySpeculativeContactRestitution) + { +//\1("apply speculative contact restitution"); + for (int i = 0; i < m_predictiveManifolds.size(); i++) + { + btPersistentManifold* manifold = m_predictiveManifolds[i]; + btRigidBody* body0 = btRigidBody::upcast((btCollisionObject*)manifold->getBody0()); + btRigidBody* body1 = btRigidBody::upcast((btCollisionObject*)manifold->getBody1()); + + for (int p = 0; p < manifold->getNumContacts(); p++) + { + const btManifoldPoint& pt = manifold->getContactPoint(p); + btScalar combinedRestitution = gCalculateCombinedRestitutionCallback(body0, body1); + + if (combinedRestitution > 0 && pt.m_appliedImpulse != 0.f) + //if (pt.getDistance()>0 && combinedRestitution>0 && pt.m_appliedImpulse != 0.f) + { + btVector3 imp = -pt.m_normalWorldOnB * pt.m_appliedImpulse * combinedRestitution; + + const btVector3& pos1 = pt.getPositionWorldOnA(); + const btVector3& pos2 = pt.getPositionWorldOnB(); + + btVector3 rel_pos0 = pos1 - body0->getWorldTransform().getOrigin(); + btVector3 rel_pos1 = pos2 - body1->getWorldTransform().getOrigin(); + + if (body0) + body0->applyImpulse(imp, rel_pos0); + if (body1) + body1->applyImpulse(-imp, rel_pos1); + } + } + } + } +} + +void btDiscreteDynamicsWorld::predictUnconstraintMotion(btScalar timeStep) +{ +//\1("predictUnconstraintMotion"); + for (int i = 0; i < m_nonStaticRigidBodies.size(); i++) + { + btRigidBody* body = m_nonStaticRigidBodies[i]; + if (!body->isStaticOrKinematicObject()) + { + //don't integrate/update velocities here, it happens in the constraint solver + + body->applyDamping(timeStep); + + body->predictIntegratedTransform(timeStep, body->getInterpolationWorldTransform()); + } + } +} + +void btDiscreteDynamicsWorld::startProfiling(btScalar timeStep) +{ + (void)timeStep; + +#ifndef BT_NO_PROFILE + CProfileManager::Reset(); +#endif //BT_NO_PROFILE +} + +void btDiscreteDynamicsWorld::debugDrawConstraint(btTypedConstraint* constraint) +{ + bool drawFrames = (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawConstraints) != 0; + bool drawLimits = (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawConstraintLimits) != 0; + btScalar dbgDrawSize = constraint->getDbgDrawSize(); + if (dbgDrawSize <= btScalar(0.f)) + { + return; + } + + switch (constraint->getConstraintType()) + { + case POINT2POINT_CONSTRAINT_TYPE: + { + btPoint2PointConstraint* p2pC = (btPoint2PointConstraint*)constraint; + btTransform tr; + tr.setIdentity(); + btVector3 pivot = p2pC->getPivotInA(); + pivot = p2pC->getRigidBodyA().getCenterOfMassTransform() * pivot; + tr.setOrigin(pivot); + getDebugDrawer()->drawTransform(tr, dbgDrawSize); + // that ideally should draw the same frame + pivot = p2pC->getPivotInB(); + pivot = p2pC->getRigidBodyB().getCenterOfMassTransform() * pivot; + tr.setOrigin(pivot); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + } + break; + case HINGE_CONSTRAINT_TYPE: + { + btHingeConstraint* pHinge = (btHingeConstraint*)constraint; + btTransform tr = pHinge->getRigidBodyA().getCenterOfMassTransform() * pHinge->getAFrame(); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + tr = pHinge->getRigidBodyB().getCenterOfMassTransform() * pHinge->getBFrame(); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + btScalar minAng = pHinge->getLowerLimit(); + btScalar maxAng = pHinge->getUpperLimit(); + if (minAng == maxAng) + { + break; + } + bool drawSect = true; + if (!pHinge->hasLimit()) + { + minAng = btScalar(0.f); + maxAng = SIMD_2_PI; + drawSect = false; + } + if (drawLimits) + { + btVector3& center = tr.getOrigin(); + btVector3 normal = tr.getBasis().getColumn(2); + btVector3 axis = tr.getBasis().getColumn(0); + getDebugDrawer()->drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, minAng, maxAng, btVector3(0, 0, 0), drawSect); + } + } + break; + case CONETWIST_CONSTRAINT_TYPE: + { + btConeTwistConstraint* pCT = (btConeTwistConstraint*)constraint; + btTransform tr = pCT->getRigidBodyA().getCenterOfMassTransform() * pCT->getAFrame(); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + tr = pCT->getRigidBodyB().getCenterOfMassTransform() * pCT->getBFrame(); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + if (drawLimits) + { + //const btScalar length = btScalar(5); + const btScalar length = dbgDrawSize; + static int nSegments = 8 * 4; + btScalar fAngleInRadians = btScalar(2. * 3.1415926) * (btScalar)(nSegments - 1) / btScalar(nSegments); + btVector3 pPrev = pCT->GetPointForAngle(fAngleInRadians, length); + pPrev = tr * pPrev; + for (int i = 0; i < nSegments; i++) + { + fAngleInRadians = btScalar(2. * 3.1415926) * (btScalar)i / btScalar(nSegments); + btVector3 pCur = pCT->GetPointForAngle(fAngleInRadians, length); + pCur = tr * pCur; + getDebugDrawer()->drawLine(pPrev, pCur, btVector3(0, 0, 0)); + + if (i % (nSegments / 8) == 0) + getDebugDrawer()->drawLine(tr.getOrigin(), pCur, btVector3(0, 0, 0)); + + pPrev = pCur; + } + btScalar tws = pCT->getTwistSpan(); + btScalar twa = pCT->getTwistAngle(); + bool useFrameB = (pCT->getRigidBodyB().getInvMass() > btScalar(0.f)); + if (useFrameB) + { + tr = pCT->getRigidBodyB().getCenterOfMassTransform() * pCT->getBFrame(); + } + else + { + tr = pCT->getRigidBodyA().getCenterOfMassTransform() * pCT->getAFrame(); + } + btVector3 pivot = tr.getOrigin(); + btVector3 normal = tr.getBasis().getColumn(0); + btVector3 axis1 = tr.getBasis().getColumn(1); + getDebugDrawer()->drawArc(pivot, normal, axis1, dbgDrawSize, dbgDrawSize, -twa - tws, -twa + tws, btVector3(0, 0, 0), true); + } + } + break; + case D6_SPRING_CONSTRAINT_TYPE: + case D6_CONSTRAINT_TYPE: + { + btGeneric6DofConstraint* p6DOF = (btGeneric6DofConstraint*)constraint; + btTransform tr = p6DOF->getCalculatedTransformA(); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + tr = p6DOF->getCalculatedTransformB(); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + if (drawLimits) + { + tr = p6DOF->getCalculatedTransformA(); + const btVector3& center = p6DOF->getCalculatedTransformB().getOrigin(); + btVector3 up = tr.getBasis().getColumn(2); + btVector3 axis = tr.getBasis().getColumn(0); + btScalar minTh = p6DOF->getRotationalLimitMotor(1)->m_loLimit; + btScalar maxTh = p6DOF->getRotationalLimitMotor(1)->m_hiLimit; + btScalar minPs = p6DOF->getRotationalLimitMotor(2)->m_loLimit; + btScalar maxPs = p6DOF->getRotationalLimitMotor(2)->m_hiLimit; + getDebugDrawer()->drawSpherePatch(center, up, axis, dbgDrawSize * btScalar(.9f), minTh, maxTh, minPs, maxPs, btVector3(0, 0, 0)); + axis = tr.getBasis().getColumn(1); + btScalar ay = p6DOF->getAngle(1); + btScalar az = p6DOF->getAngle(2); + btScalar cy = btCos(ay); + btScalar sy = btSin(ay); + btScalar cz = btCos(az); + btScalar sz = btSin(az); + btVector3 ref; + ref[0] = cy * cz * axis[0] + cy * sz * axis[1] - sy * axis[2]; + ref[1] = -sz * axis[0] + cz * axis[1]; + ref[2] = cz * sy * axis[0] + sz * sy * axis[1] + cy * axis[2]; + tr = p6DOF->getCalculatedTransformB(); + btVector3 normal = -tr.getBasis().getColumn(0); + btScalar minFi = p6DOF->getRotationalLimitMotor(0)->m_loLimit; + btScalar maxFi = p6DOF->getRotationalLimitMotor(0)->m_hiLimit; + if (minFi > maxFi) + { + getDebugDrawer()->drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -SIMD_PI, SIMD_PI, btVector3(0, 0, 0), false); + } + else if (minFi < maxFi) + { + getDebugDrawer()->drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi, btVector3(0, 0, 0), true); + } + tr = p6DOF->getCalculatedTransformA(); + btVector3 bbMin = p6DOF->getTranslationalLimitMotor()->m_lowerLimit; + btVector3 bbMax = p6DOF->getTranslationalLimitMotor()->m_upperLimit; + getDebugDrawer()->drawBox(bbMin, bbMax, tr, btVector3(0, 0, 0)); + } + } + break; + ///note: the code for D6_SPRING_2_CONSTRAINT_TYPE is identical to D6_CONSTRAINT_TYPE, the D6_CONSTRAINT_TYPE+D6_SPRING_CONSTRAINT_TYPE will likely become obsolete/deprecated at some stage + case D6_SPRING_2_CONSTRAINT_TYPE: + { + { + btGeneric6DofSpring2Constraint* p6DOF = (btGeneric6DofSpring2Constraint*)constraint; + btTransform tr = p6DOF->getCalculatedTransformA(); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + tr = p6DOF->getCalculatedTransformB(); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + if (drawLimits) + { + tr = p6DOF->getCalculatedTransformA(); + const btVector3& center = p6DOF->getCalculatedTransformB().getOrigin(); + btVector3 up = tr.getBasis().getColumn(2); + btVector3 axis = tr.getBasis().getColumn(0); + btScalar minTh = p6DOF->getRotationalLimitMotor(1)->m_loLimit; + btScalar maxTh = p6DOF->getRotationalLimitMotor(1)->m_hiLimit; + if (minTh <= maxTh) + { + btScalar minPs = p6DOF->getRotationalLimitMotor(2)->m_loLimit; + btScalar maxPs = p6DOF->getRotationalLimitMotor(2)->m_hiLimit; + getDebugDrawer()->drawSpherePatch(center, up, axis, dbgDrawSize * btScalar(.9f), minTh, maxTh, minPs, maxPs, btVector3(0, 0, 0)); + } + axis = tr.getBasis().getColumn(1); + btScalar ay = p6DOF->getAngle(1); + btScalar az = p6DOF->getAngle(2); + btScalar cy = btCos(ay); + btScalar sy = btSin(ay); + btScalar cz = btCos(az); + btScalar sz = btSin(az); + btVector3 ref; + ref[0] = cy * cz * axis[0] + cy * sz * axis[1] - sy * axis[2]; + ref[1] = -sz * axis[0] + cz * axis[1]; + ref[2] = cz * sy * axis[0] + sz * sy * axis[1] + cy * axis[2]; + tr = p6DOF->getCalculatedTransformB(); + btVector3 normal = -tr.getBasis().getColumn(0); + btScalar minFi = p6DOF->getRotationalLimitMotor(0)->m_loLimit; + btScalar maxFi = p6DOF->getRotationalLimitMotor(0)->m_hiLimit; + if (minFi > maxFi) + { + getDebugDrawer()->drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, -SIMD_PI, SIMD_PI, btVector3(0, 0, 0), false); + } + else if (minFi < maxFi) + { + getDebugDrawer()->drawArc(center, normal, ref, dbgDrawSize, dbgDrawSize, minFi, maxFi, btVector3(0, 0, 0), true); + } + tr = p6DOF->getCalculatedTransformA(); + btVector3 bbMin = p6DOF->getTranslationalLimitMotor()->m_lowerLimit; + btVector3 bbMax = p6DOF->getTranslationalLimitMotor()->m_upperLimit; + getDebugDrawer()->drawBox(bbMin, bbMax, tr, btVector3(0, 0, 0)); + } + } + break; + } + case SLIDER_CONSTRAINT_TYPE: + { + btSliderConstraint* pSlider = (btSliderConstraint*)constraint; + btTransform tr = pSlider->getCalculatedTransformA(); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + tr = pSlider->getCalculatedTransformB(); + if (drawFrames) getDebugDrawer()->drawTransform(tr, dbgDrawSize); + if (drawLimits) + { + btTransform tr = pSlider->getUseLinearReferenceFrameA() ? pSlider->getCalculatedTransformA() : pSlider->getCalculatedTransformB(); + btVector3 li_min = tr * btVector3(pSlider->getLowerLinLimit(), 0.f, 0.f); + btVector3 li_max = tr * btVector3(pSlider->getUpperLinLimit(), 0.f, 0.f); + getDebugDrawer()->drawLine(li_min, li_max, btVector3(0, 0, 0)); + btVector3 normal = tr.getBasis().getColumn(0); + btVector3 axis = tr.getBasis().getColumn(1); + btScalar a_min = pSlider->getLowerAngLimit(); + btScalar a_max = pSlider->getUpperAngLimit(); + const btVector3& center = pSlider->getCalculatedTransformB().getOrigin(); + getDebugDrawer()->drawArc(center, normal, axis, dbgDrawSize, dbgDrawSize, a_min, a_max, btVector3(0, 0, 0), true); + } + } + break; + default: + break; + } + return; +} + +void btDiscreteDynamicsWorld::setConstraintSolver(btConstraintSolver* solver) +{ + if (m_ownsConstraintSolver) + { + btAlignedFree(m_constraintSolver); + } + m_ownsConstraintSolver = false; + m_constraintSolver = solver; + m_solverIslandCallback->m_solver = solver; +} + +btConstraintSolver* btDiscreteDynamicsWorld::getConstraintSolver() +{ + return m_constraintSolver; +} + +int btDiscreteDynamicsWorld::getNumConstraints() const +{ + return int(m_constraints.size()); +} +btTypedConstraint* btDiscreteDynamicsWorld::getConstraint(int index) +{ + return m_constraints[index]; +} +const btTypedConstraint* btDiscreteDynamicsWorld::getConstraint(int index) const +{ + return m_constraints[index]; +} + +void btDiscreteDynamicsWorld::serializeRigidBodies(btSerializer* serializer) +{ + int i; + //serialize all collision objects + for (i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + if (colObj->getInternalType() & btCollisionObject::CO_RIGID_BODY) + { + int len = colObj->calculateSerializeBufferSize(); + btChunk* chunk = serializer->allocate(len, 1); + const char* structType = colObj->serialize(chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_RIGIDBODY_CODE, colObj); + } + } + + for (i = 0; i < m_constraints.size(); i++) + { + btTypedConstraint* constraint = m_constraints[i]; + int size = constraint->calculateSerializeBufferSize(); + btChunk* chunk = serializer->allocate(size, 1); + const char* structType = constraint->serialize(chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_CONSTRAINT_CODE, constraint); + } +} + +void btDiscreteDynamicsWorld::serializeDynamicsWorldInfo(btSerializer* serializer) +{ +#ifdef BT_USE_DOUBLE_PRECISION + int len = sizeof(btDynamicsWorldDoubleData); + btChunk* chunk = serializer->allocate(len, 1); + btDynamicsWorldDoubleData* worldInfo = (btDynamicsWorldDoubleData*)chunk->m_oldPtr; +#else //BT_USE_DOUBLE_PRECISION + int len = sizeof(btDynamicsWorldFloatData); + btChunk* chunk = serializer->allocate(len, 1); + btDynamicsWorldFloatData* worldInfo = (btDynamicsWorldFloatData*)chunk->m_oldPtr; +#endif //BT_USE_DOUBLE_PRECISION + + memset(worldInfo, 0x00, len); + + m_gravity.serialize(worldInfo->m_gravity); + worldInfo->m_solverInfo.m_tau = getSolverInfo().m_tau; + worldInfo->m_solverInfo.m_damping = getSolverInfo().m_damping; + worldInfo->m_solverInfo.m_friction = getSolverInfo().m_friction; + worldInfo->m_solverInfo.m_timeStep = getSolverInfo().m_timeStep; + + worldInfo->m_solverInfo.m_restitution = getSolverInfo().m_restitution; + worldInfo->m_solverInfo.m_maxErrorReduction = getSolverInfo().m_maxErrorReduction; + worldInfo->m_solverInfo.m_sor = getSolverInfo().m_sor; + worldInfo->m_solverInfo.m_erp = getSolverInfo().m_erp; + + worldInfo->m_solverInfo.m_erp2 = getSolverInfo().m_erp2; + worldInfo->m_solverInfo.m_globalCfm = getSolverInfo().m_globalCfm; + worldInfo->m_solverInfo.m_splitImpulsePenetrationThreshold = getSolverInfo().m_splitImpulsePenetrationThreshold; + worldInfo->m_solverInfo.m_splitImpulseTurnErp = getSolverInfo().m_splitImpulseTurnErp; + + worldInfo->m_solverInfo.m_linearSlop = getSolverInfo().m_linearSlop; + worldInfo->m_solverInfo.m_warmstartingFactor = getSolverInfo().m_warmstartingFactor; + worldInfo->m_solverInfo.m_maxGyroscopicForce = getSolverInfo().m_maxGyroscopicForce; + worldInfo->m_solverInfo.m_singleAxisRollingFrictionThreshold = getSolverInfo().m_singleAxisRollingFrictionThreshold; + + worldInfo->m_solverInfo.m_numIterations = getSolverInfo().m_numIterations; + worldInfo->m_solverInfo.m_solverMode = getSolverInfo().m_solverMode; + worldInfo->m_solverInfo.m_restingContactRestitutionThreshold = getSolverInfo().m_restingContactRestitutionThreshold; + worldInfo->m_solverInfo.m_minimumSolverBatchSize = getSolverInfo().m_minimumSolverBatchSize; + + worldInfo->m_solverInfo.m_splitImpulse = getSolverInfo().m_splitImpulse; + + +#ifdef BT_USE_DOUBLE_PRECISION + const char* structType = "btDynamicsWorldDoubleData"; +#else //BT_USE_DOUBLE_PRECISION + const char* structType = "btDynamicsWorldFloatData"; +#endif //BT_USE_DOUBLE_PRECISION + serializer->finalizeChunk(chunk, structType, BT_DYNAMICSWORLD_CODE, worldInfo); +} + +void btDiscreteDynamicsWorld::serialize(btSerializer* serializer) +{ + serializer->startSerialization(); + + serializeDynamicsWorldInfo(serializer); + + serializeCollisionObjects(serializer); + + serializeRigidBodies(serializer); + + serializeContactManifolds(serializer); + + serializer->finishSerialization(); +} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp.i new file mode 100644 index 00000000..4d13838c --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp ---------------- + +%include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp" + +%{ +#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h new file mode 100644 index 00000000..73607c61 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h @@ -0,0 +1,244 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_DISCRETE_DYNAMICS_WORLD_H +#define BT_DISCRETE_DYNAMICS_WORLD_H + +#include "btDynamicsWorld.h" +class btDispatcher; +class btOverlappingPairCache; +class btConstraintSolver; +class btSimulationIslandManager; +class btTypedConstraint; +class btActionInterface; +class btPersistentManifold; +class btIDebugDraw; + +struct InplaceSolverIslandCallback; + +#include "LinearMath/btAlignedObjectArray.h" +#include "LinearMath/btThreads.h" + +///btDiscreteDynamicsWorld provides discrete rigid body simulation +///those classes replace the obsolete CcdPhysicsEnvironment/CcdPhysicsController +ATTRIBUTE_ALIGNED16(class) +btDiscreteDynamicsWorld : public btDynamicsWorld +{ +protected: + btAlignedObjectArray m_sortedConstraints; + InplaceSolverIslandCallback* m_solverIslandCallback; + + btConstraintSolver* m_constraintSolver; + + btSimulationIslandManager* m_islandManager; + + btAlignedObjectArray m_constraints; + + btAlignedObjectArray m_nonStaticRigidBodies; + + btVector3 m_gravity; + + //for variable timesteps + btScalar m_localTime; + btScalar m_fixedTimeStep; + //for variable timesteps + + bool m_ownsIslandManager; + bool m_ownsConstraintSolver; + bool m_synchronizeAllMotionStates; + bool m_applySpeculativeContactRestitution; + + btAlignedObjectArray m_actions; + + int m_profileTimings; + + bool m_latencyMotionStateInterpolation; + + btAlignedObjectArray m_predictiveManifolds; + btSpinMutex m_predictiveManifoldsMutex; // used to synchronize threads creating predictive contacts + + virtual void predictUnconstraintMotion(btScalar timeStep); + + void integrateTransformsInternal(btRigidBody * *bodies, int numBodies, btScalar timeStep); // can be called in parallel + virtual void integrateTransforms(btScalar timeStep); + + virtual void calculateSimulationIslands(); + + + + virtual void updateActivationState(btScalar timeStep); + + void updateActions(btScalar timeStep); + + void startProfiling(btScalar timeStep); + + virtual void internalSingleStepSimulation(btScalar timeStep); + + void releasePredictiveContacts(); + void createPredictiveContactsInternal(btRigidBody * *bodies, int numBodies, btScalar timeStep); // can be called in parallel + virtual void createPredictiveContacts(btScalar timeStep); + + virtual void saveKinematicState(btScalar timeStep); + + void serializeRigidBodies(btSerializer * serializer); + + void serializeDynamicsWorldInfo(btSerializer * serializer); + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + ///this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those + btDiscreteDynamicsWorld(btDispatcher * dispatcher, btBroadphaseInterface * pairCache, btConstraintSolver * constraintSolver, btCollisionConfiguration * collisionConfiguration); + + virtual ~btDiscreteDynamicsWorld(); + + ///if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's + virtual int stepSimulation(btScalar timeStep, int maxSubSteps = 1, btScalar fixedTimeStep = btScalar(1.) / btScalar(60.)); + + virtual void solveConstraints(btContactSolverInfo & solverInfo); + + virtual void synchronizeMotionStates(); + + ///this can be useful to synchronize a single rigid body -> graphics object + void synchronizeSingleMotionState(btRigidBody * body); + + virtual void addConstraint(btTypedConstraint * constraint, bool disableCollisionsBetweenLinkedBodies = false); + + virtual void removeConstraint(btTypedConstraint * constraint); + + virtual void addAction(btActionInterface*); + + virtual void removeAction(btActionInterface*); + + btSimulationIslandManager* getSimulationIslandManager() + { + return m_islandManager; + } + + const btSimulationIslandManager* getSimulationIslandManager() const + { + return m_islandManager; + } + + btCollisionWorld* getCollisionWorld() + { + return this; + } + + virtual void setGravity(const btVector3& gravity); + + virtual btVector3 getGravity() const; + + virtual void addCollisionObject(btCollisionObject * collisionObject, int collisionFilterGroup = btBroadphaseProxy::StaticFilter, int collisionFilterMask = btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter); + + virtual void addRigidBody(btRigidBody * body); + + virtual void addRigidBody(btRigidBody * body, int group, int mask); + + virtual void removeRigidBody(btRigidBody * body); + + ///removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject + virtual void removeCollisionObject(btCollisionObject * collisionObject); + + virtual void debugDrawConstraint(btTypedConstraint * constraint); + + virtual void debugDrawWorld(); + + virtual void setConstraintSolver(btConstraintSolver * solver); + + virtual btConstraintSolver* getConstraintSolver(); + + virtual int getNumConstraints() const; + + virtual btTypedConstraint* getConstraint(int index); + + virtual const btTypedConstraint* getConstraint(int index) const; + + virtual btDynamicsWorldType getWorldType() const + { + return BT_DISCRETE_DYNAMICS_WORLD; + } + + ///the forces on each rigidbody is accumulating together with gravity. clear this after each timestep. + virtual void clearForces(); + + ///apply gravity, call this once per timestep + virtual void applyGravity(); + + virtual void setNumTasks(int numTasks) + { + (void)numTasks; + } + + ///obsolete, use updateActions instead + virtual void updateVehicles(btScalar timeStep) + { + updateActions(timeStep); + } + + ///obsolete, use addAction instead + virtual void addVehicle(btActionInterface * vehicle); + ///obsolete, use removeAction instead + virtual void removeVehicle(btActionInterface * vehicle); + ///obsolete, use addAction instead + virtual void addCharacter(btActionInterface * character); + ///obsolete, use removeAction instead + virtual void removeCharacter(btActionInterface * character); + + void setSynchronizeAllMotionStates(bool synchronizeAll) + { + m_synchronizeAllMotionStates = synchronizeAll; + } + bool getSynchronizeAllMotionStates() const + { + return m_synchronizeAllMotionStates; + } + + void setApplySpeculativeContactRestitution(bool enable) + { + m_applySpeculativeContactRestitution = enable; + } + + bool getApplySpeculativeContactRestitution() const + { + return m_applySpeculativeContactRestitution; + } + + ///Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see Bullet/Demos/SerializeDemo) + virtual void serialize(btSerializer * serializer); + + ///Interpolate motion state between previous and current transform, instead of current and next transform. + ///This can relieve discontinuities in the rendering, due to penetrations + void setLatencyMotionStateInterpolation(bool latencyInterpolation) + { + m_latencyMotionStateInterpolation = latencyInterpolation; + } + bool getLatencyMotionStateInterpolation() const + { + return m_latencyMotionStateInterpolation; + } + + btAlignedObjectArray& getNonStaticRigidBodies() + { + return m_nonStaticRigidBodies; + } + + const btAlignedObjectArray& getNonStaticRigidBodies() const + { + return m_nonStaticRigidBodies; + } +}; + +#endif //BT_DISCRETE_DYNAMICS_WORLD_H diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h.i new file mode 100644 index 00000000..6a6009e5 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h ---------------- + +%include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" + +%{ +#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp new file mode 100644 index 00000000..55d94732 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp @@ -0,0 +1,263 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btDiscreteDynamicsWorldMt.h" + +//collision detection +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h" +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +#include "BulletCollision/CollisionShapes/btCollisionShape.h" +#include "btSimulationIslandManagerMt.h" +#include "LinearMath/btTransformUtil.h" +#include "LinearMath/btQuickprof.h" + +//rigidbody & constraints +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h" +#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +#include "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h" +#include "BulletDynamics/ConstraintSolver/btHingeConstraint.h" +#include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h" +#include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h" +#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h" +#include "BulletDynamics/ConstraintSolver/btSliderConstraint.h" +#include "BulletDynamics/ConstraintSolver/btContactConstraint.h" + +#include "LinearMath/btIDebugDraw.h" +#include "BulletCollision/CollisionShapes/btSphereShape.h" + +#include "BulletDynamics/Dynamics/btActionInterface.h" +#include "LinearMath/btQuickprof.h" +#include "LinearMath/btMotionState.h" + +#include "LinearMath/btSerializer.h" + +/// +/// btConstraintSolverPoolMt +/// + +btConstraintSolverPoolMt::ThreadSolver* btConstraintSolverPoolMt::getAndLockThreadSolver() +{ + int i = 0; +#if BT_THREADSAFE + i = btGetCurrentThreadIndex() % m_solvers.size(); +#endif // #if BT_THREADSAFE + while (true) + { + ThreadSolver& solver = m_solvers[i]; + if (solver.mutex.tryLock()) + { + return &solver; + } + // failed, try the next one + i = (i + 1) % m_solvers.size(); + } + return NULL; +} + +void btConstraintSolverPoolMt::init(btConstraintSolver** solvers, int numSolvers) +{ + m_solverType = BT_SEQUENTIAL_IMPULSE_SOLVER; + m_solvers.resize(numSolvers); + for (int i = 0; i < numSolvers; ++i) + { + m_solvers[i].solver = solvers[i]; + } + if (numSolvers > 0) + { + m_solverType = solvers[0]->getSolverType(); + } +} + +// create the solvers for me +btConstraintSolverPoolMt::btConstraintSolverPoolMt(int numSolvers) +{ + btAlignedObjectArray solvers; + solvers.reserve(numSolvers); + for (int i = 0; i < numSolvers; ++i) + { + btConstraintSolver* solver = new btSequentialImpulseConstraintSolver(); + solvers.push_back(solver); + } + init(&solvers[0], numSolvers); +} + +// pass in fully constructed solvers (destructor will delete them) +btConstraintSolverPoolMt::btConstraintSolverPoolMt(btConstraintSolver** solvers, int numSolvers) +{ + init(solvers, numSolvers); +} + +btConstraintSolverPoolMt::~btConstraintSolverPoolMt() +{ + // delete all solvers + for (int i = 0; i < m_solvers.size(); ++i) + { + ThreadSolver& solver = m_solvers[i]; + delete solver.solver; + solver.solver = NULL; + } +} + +///solve a group of constraints +btScalar btConstraintSolverPoolMt::solveGroup(btCollisionObject** bodies, + int numBodies, + btPersistentManifold** manifolds, + int numManifolds, + btTypedConstraint** constraints, + int numConstraints, + const btContactSolverInfo& info, + btIDebugDraw* debugDrawer, + btDispatcher* dispatcher) +{ + ThreadSolver* ts = getAndLockThreadSolver(); + ts->solver->solveGroup(bodies, numBodies, manifolds, numManifolds, constraints, numConstraints, info, debugDrawer, dispatcher); + ts->mutex.unlock(); + return 0.0f; +} + +void btConstraintSolverPoolMt::reset() +{ + for (int i = 0; i < m_solvers.size(); ++i) + { + ThreadSolver& solver = m_solvers[i]; + solver.mutex.lock(); + solver.solver->reset(); + solver.mutex.unlock(); + } +} + +/// +/// btDiscreteDynamicsWorldMt +/// + +btDiscreteDynamicsWorldMt::btDiscreteDynamicsWorldMt(btDispatcher* dispatcher, + btBroadphaseInterface* pairCache, + btConstraintSolverPoolMt* solverPool, + btConstraintSolver* constraintSolverMt, + btCollisionConfiguration* collisionConfiguration) + : btDiscreteDynamicsWorld(dispatcher, pairCache, solverPool, collisionConfiguration) +{ + if (m_ownsIslandManager) + { + m_islandManager->~btSimulationIslandManager(); + btAlignedFree(m_islandManager); + } + { + void* mem = btAlignedAlloc(sizeof(btSimulationIslandManagerMt), 16); + btSimulationIslandManagerMt* im = new (mem) btSimulationIslandManagerMt(); + im->setMinimumSolverBatchSize(m_solverInfo.m_minimumSolverBatchSize); + m_islandManager = im; + } + m_constraintSolverMt = constraintSolverMt; +} + +btDiscreteDynamicsWorldMt::~btDiscreteDynamicsWorldMt() +{ +} + +void btDiscreteDynamicsWorldMt::solveConstraints(btContactSolverInfo& solverInfo) +{ +//\1("solveConstraints"); + + m_constraintSolver->prepareSolve(getCollisionWorld()->getNumCollisionObjects(), getCollisionWorld()->getDispatcher()->getNumManifolds()); + + /// solve all the constraints for this island + btSimulationIslandManagerMt* im = static_cast(m_islandManager); + btSimulationIslandManagerMt::SolverParams solverParams; + solverParams.m_solverPool = m_constraintSolver; + solverParams.m_solverMt = m_constraintSolverMt; + solverParams.m_solverInfo = &solverInfo; + solverParams.m_debugDrawer = m_debugDrawer; + solverParams.m_dispatcher = getCollisionWorld()->getDispatcher(); + im->buildAndProcessIslands(getCollisionWorld()->getDispatcher(), getCollisionWorld(), m_constraints, solverParams); + + m_constraintSolver->allSolved(solverInfo, m_debugDrawer); +} + +struct UpdaterUnconstrainedMotion : public btIParallelForBody +{ + btScalar timeStep; + btRigidBody** rigidBodies; + + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + for (int i = iBegin; i < iEnd; ++i) + { + btRigidBody* body = rigidBodies[i]; + if (!body->isStaticOrKinematicObject()) + { + //don't integrate/update velocities here, it happens in the constraint solver + body->applyDamping(timeStep); + body->predictIntegratedTransform(timeStep, body->getInterpolationWorldTransform()); + } + } + } +}; + +void btDiscreteDynamicsWorldMt::predictUnconstraintMotion(btScalar timeStep) +{ +//\1("predictUnconstraintMotion"); + if (m_nonStaticRigidBodies.size() > 0) + { + UpdaterUnconstrainedMotion update; + update.timeStep = timeStep; + update.rigidBodies = &m_nonStaticRigidBodies[0]; + int grainSize = 50; // num of iterations per task for task scheduler + btParallelFor(0, m_nonStaticRigidBodies.size(), grainSize, update); + } +} + +void btDiscreteDynamicsWorldMt::createPredictiveContacts(btScalar timeStep) +{ +//\1("createPredictiveContacts"); + releasePredictiveContacts(); + if (m_nonStaticRigidBodies.size() > 0) + { + UpdaterCreatePredictiveContacts update; + update.world = this; + update.timeStep = timeStep; + update.rigidBodies = &m_nonStaticRigidBodies[0]; + int grainSize = 50; // num of iterations per task for task scheduler + btParallelFor(0, m_nonStaticRigidBodies.size(), grainSize, update); + } +} + +void btDiscreteDynamicsWorldMt::integrateTransforms(btScalar timeStep) +{ +//\1("integrateTransforms"); + if (m_nonStaticRigidBodies.size() > 0) + { + UpdaterIntegrateTransforms update; + update.world = this; + update.timeStep = timeStep; + update.rigidBodies = &m_nonStaticRigidBodies[0]; + int grainSize = 50; // num of iterations per task for task scheduler + btParallelFor(0, m_nonStaticRigidBodies.size(), grainSize, update); + } +} + +int btDiscreteDynamicsWorldMt::stepSimulation(btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep) +{ + int numSubSteps = btDiscreteDynamicsWorld::stepSimulation(timeStep, maxSubSteps, fixedTimeStep); + if (btITaskScheduler* scheduler = btGetTaskScheduler()) + { + // tell Bullet's threads to sleep, so other threads can run + scheduler->sleepWorkerThreadsHint(); + } + return numSubSteps; +} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp.i new file mode 100644 index 00000000..76deab9a --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp ---------------- + +%include "BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp" + +%{ +#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h new file mode 100644 index 00000000..dccf35d7 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h @@ -0,0 +1,131 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_DISCRETE_DYNAMICS_WORLD_MT_H +#define BT_DISCRETE_DYNAMICS_WORLD_MT_H + +#include "btDiscreteDynamicsWorld.h" +#include "btSimulationIslandManagerMt.h" +#include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" + +/// +/// btConstraintSolverPoolMt - masquerades as a constraint solver, but really it is a threadsafe pool of them. +/// +/// Each solver in the pool is protected by a mutex. When solveGroup is called from a thread, +/// the pool looks for a solver that isn't being used by another thread, locks it, and dispatches the +/// call to the solver. +/// So long as there are at least as many solvers as there are hardware threads, it should never need to +/// spin wait. +/// +class btConstraintSolverPoolMt : public btConstraintSolver +{ +public: + // create the solvers for me + explicit btConstraintSolverPoolMt(int numSolvers); + + // pass in fully constructed solvers (destructor will delete them) + btConstraintSolverPoolMt(btConstraintSolver** solvers, int numSolvers); + + virtual ~btConstraintSolverPoolMt(); + + ///solve a group of constraints + virtual btScalar solveGroup(btCollisionObject** bodies, + int numBodies, + btPersistentManifold** manifolds, + int numManifolds, + btTypedConstraint** constraints, + int numConstraints, + const btContactSolverInfo& info, + btIDebugDraw* debugDrawer, + btDispatcher* dispatcher) BT_OVERRIDE; + + virtual void reset() BT_OVERRIDE; + virtual btConstraintSolverType getSolverType() const BT_OVERRIDE { return m_solverType; } + +private: + const static size_t kCacheLineSize = 128; + struct ThreadSolver + { + btConstraintSolver* solver; + btSpinMutex mutex; + char _cachelinePadding[kCacheLineSize - sizeof(btSpinMutex) - sizeof(void*)]; // keep mutexes from sharing a cache line + }; + btAlignedObjectArray m_solvers; + btConstraintSolverType m_solverType; + + ThreadSolver* getAndLockThreadSolver(); + void init(btConstraintSolver** solvers, int numSolvers); +}; + +/// +/// btDiscreteDynamicsWorldMt -- a version of DiscreteDynamicsWorld with some minor changes to support +/// solving simulation islands on multiple threads. +/// +/// Should function exactly like btDiscreteDynamicsWorld. +/// Also 3 methods that iterate over all of the rigidbodies can run in parallel: +/// - predictUnconstraintMotion +/// - integrateTransforms +/// - createPredictiveContacts +/// +ATTRIBUTE_ALIGNED16(class) +btDiscreteDynamicsWorldMt : public btDiscreteDynamicsWorld +{ +protected: + btConstraintSolver* m_constraintSolverMt; + + virtual void solveConstraints(btContactSolverInfo & solverInfo) BT_OVERRIDE; + + virtual void predictUnconstraintMotion(btScalar timeStep) BT_OVERRIDE; + + struct UpdaterCreatePredictiveContacts : public btIParallelForBody + { + btScalar timeStep; + btRigidBody** rigidBodies; + btDiscreteDynamicsWorldMt* world; + + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + world->createPredictiveContactsInternal(&rigidBodies[iBegin], iEnd - iBegin, timeStep); + } + }; + virtual void createPredictiveContacts(btScalar timeStep) BT_OVERRIDE; + + struct UpdaterIntegrateTransforms : public btIParallelForBody + { + btScalar timeStep; + btRigidBody** rigidBodies; + btDiscreteDynamicsWorldMt* world; + + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + world->integrateTransformsInternal(&rigidBodies[iBegin], iEnd - iBegin, timeStep); + } + }; + virtual void integrateTransforms(btScalar timeStep) BT_OVERRIDE; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btDiscreteDynamicsWorldMt(btDispatcher * dispatcher, + btBroadphaseInterface * pairCache, + btConstraintSolverPoolMt * solverPool, // Note this should be a solver-pool for multi-threading + btConstraintSolver * constraintSolverMt, // single multi-threaded solver for large islands (or NULL) + btCollisionConfiguration * collisionConfiguration); + virtual ~btDiscreteDynamicsWorldMt(); + + virtual int stepSimulation(btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep) BT_OVERRIDE; +}; + +#endif //BT_DISCRETE_DYNAMICS_WORLD_H diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h.i new file mode 100644 index 00000000..f25f6e49 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h ---------------- + +%include "BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h" + +%{ +#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDynamicsWorld.h b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDynamicsWorld.h new file mode 100644 index 00000000..a5a4411a --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDynamicsWorld.h @@ -0,0 +1,174 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_DYNAMICS_WORLD_H +#define BT_DYNAMICS_WORLD_H + +#include "BulletCollision/CollisionDispatch/btCollisionWorld.h" +#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" + +class btTypedConstraint; +class btActionInterface; +class btConstraintSolver; +class btDynamicsWorld; + +/// Type for the callback for each tick +typedef void (*btInternalTickCallback)(btDynamicsWorld* world, btScalar timeStep); + +enum btDynamicsWorldType +{ + BT_SIMPLE_DYNAMICS_WORLD = 1, + BT_DISCRETE_DYNAMICS_WORLD = 2, + BT_CONTINUOUS_DYNAMICS_WORLD = 3, + BT_SOFT_RIGID_DYNAMICS_WORLD = 4, + BT_GPU_DYNAMICS_WORLD = 5, + BT_SOFT_MULTIBODY_DYNAMICS_WORLD = 6, + BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD = 7 +}; + +///The btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc. +class btDynamicsWorld : public btCollisionWorld +{ +protected: + btInternalTickCallback m_internalTickCallback; + btInternalTickCallback m_internalPreTickCallback; + void* m_worldUserInfo; + + btContactSolverInfo m_solverInfo; + +public: + btDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* broadphase, btCollisionConfiguration* collisionConfiguration) + : btCollisionWorld(dispatcher, broadphase, collisionConfiguration), m_internalTickCallback(0), m_internalPreTickCallback(0), m_worldUserInfo(0) + { + } + + virtual ~btDynamicsWorld() + { + } + + ///stepSimulation proceeds the simulation over 'timeStep', units in preferably in seconds. + ///By default, Bullet will subdivide the timestep in constant substeps of each 'fixedTimeStep'. + ///in order to keep the simulation real-time, the maximum number of substeps can be clamped to 'maxSubSteps'. + ///You can disable subdividing the timestep/substepping by passing maxSubSteps=0 as second argument to stepSimulation, but in that case you have to keep the timeStep constant. + virtual int stepSimulation(btScalar timeStep, int maxSubSteps = 1, btScalar fixedTimeStep = btScalar(1.) / btScalar(60.)) = 0; + + virtual void debugDrawWorld() = 0; + + virtual void addConstraint(btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies = false) + { + (void)constraint; + (void)disableCollisionsBetweenLinkedBodies; + } + + virtual void removeConstraint(btTypedConstraint* constraint) { (void)constraint; } + + virtual void addAction(btActionInterface* action) = 0; + + virtual void removeAction(btActionInterface* action) = 0; + + //once a rigidbody is added to the dynamics world, it will get this gravity assigned + //existing rigidbodies in the world get gravity assigned too, during this method + virtual void setGravity(const btVector3& gravity) = 0; + virtual btVector3 getGravity() const = 0; + + virtual void synchronizeMotionStates() = 0; + + virtual void addRigidBody(btRigidBody* body) = 0; + + virtual void addRigidBody(btRigidBody* body, int group, int mask) = 0; + + virtual void removeRigidBody(btRigidBody* body) = 0; + + virtual void setConstraintSolver(btConstraintSolver* solver) = 0; + + virtual btConstraintSolver* getConstraintSolver() = 0; + + virtual int getNumConstraints() const { return 0; } + + virtual btTypedConstraint* getConstraint(int index) + { + (void)index; + return 0; + } + + virtual const btTypedConstraint* getConstraint(int index) const + { + (void)index; + return 0; + } + + virtual btDynamicsWorldType getWorldType() const = 0; + + virtual void clearForces() = 0; + + /// Set the callback for when an internal tick (simulation substep) happens, optional user info + void setInternalTickCallback(btInternalTickCallback cb, void* worldUserInfo = 0, bool isPreTick = false) + { + if (isPreTick) + { + m_internalPreTickCallback = cb; + } + else + { + m_internalTickCallback = cb; + } + m_worldUserInfo = worldUserInfo; + } + + void setWorldUserInfo(void* worldUserInfo) + { + m_worldUserInfo = worldUserInfo; + } + + void* getWorldUserInfo() const + { + return m_worldUserInfo; + } + + btContactSolverInfo& getSolverInfo() + { + return m_solverInfo; + } + + const btContactSolverInfo& getSolverInfo() const + { + return m_solverInfo; + } + + ///obsolete, use addAction instead. + virtual void addVehicle(btActionInterface* vehicle) { (void)vehicle; } + ///obsolete, use removeAction instead + virtual void removeVehicle(btActionInterface* vehicle) { (void)vehicle; } + ///obsolete, use addAction instead. + virtual void addCharacter(btActionInterface* character) { (void)character; } + ///obsolete, use removeAction instead + virtual void removeCharacter(btActionInterface* character) { (void)character; } +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btDynamicsWorldDoubleData +{ + btContactSolverInfoDoubleData m_solverInfo; + btVector3DoubleData m_gravity; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btDynamicsWorldFloatData +{ + btContactSolverInfoFloatData m_solverInfo; + btVector3FloatData m_gravity; +}; + +#endif //BT_DYNAMICS_WORLD_H diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDynamicsWorld.h.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDynamicsWorld.h.i new file mode 100644 index 00000000..06bc42db --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btDynamicsWorld.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btDynamicsWorld.h ---------------- + +%include "BulletDynamics/Dynamics/btDynamicsWorld.h" + +%{ +#include "BulletDynamics/Dynamics/btDynamicsWorld.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.cpp b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.cpp new file mode 100644 index 00000000..bf7224b1 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.cpp @@ -0,0 +1,505 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btRigidBody.h" +#include "BulletCollision/CollisionShapes/btConvexShape.h" +#include "LinearMath/btMinMax.h" +#include "LinearMath/btTransformUtil.h" +#include "LinearMath/btMotionState.h" +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +#include "LinearMath/btSerializer.h" + +//'temporarily' global variables +btScalar gDeactivationTime = btScalar(2.); +bool gDisableDeactivation = false; +static int uniqueId = 0; + +btRigidBody::btRigidBody(const btRigidBody::btRigidBodyConstructionInfo& constructionInfo) +{ + setupRigidBody(constructionInfo); +} + +btRigidBody::btRigidBody(btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia) +{ + btRigidBodyConstructionInfo cinfo(mass, motionState, collisionShape, localInertia); + setupRigidBody(cinfo); +} + +void btRigidBody::setupRigidBody(const btRigidBody::btRigidBodyConstructionInfo& constructionInfo) +{ + m_internalType = CO_RIGID_BODY; + + m_linearVelocity.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)); + m_angularVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); + m_angularFactor.setValue(1, 1, 1); + m_linearFactor.setValue(1, 1, 1); + m_gravity.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)); + m_gravity_acceleration.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)); + m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)); + m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)), + setDamping(constructionInfo.m_linearDamping, constructionInfo.m_angularDamping); + + m_linearSleepingThreshold = constructionInfo.m_linearSleepingThreshold; + m_angularSleepingThreshold = constructionInfo.m_angularSleepingThreshold; + m_optionalMotionState = constructionInfo.m_motionState; + m_contactSolverType = 0; + m_frictionSolverType = 0; + m_additionalDamping = constructionInfo.m_additionalDamping; + m_additionalDampingFactor = constructionInfo.m_additionalDampingFactor; + m_additionalLinearDampingThresholdSqr = constructionInfo.m_additionalLinearDampingThresholdSqr; + m_additionalAngularDampingThresholdSqr = constructionInfo.m_additionalAngularDampingThresholdSqr; + m_additionalAngularDampingFactor = constructionInfo.m_additionalAngularDampingFactor; + + if (m_optionalMotionState) + { + m_optionalMotionState->getWorldTransform(m_worldTransform); + } + else + { + m_worldTransform = constructionInfo.m_startWorldTransform; + } + + m_interpolationWorldTransform = m_worldTransform; + m_interpolationLinearVelocity.setValue(0, 0, 0); + m_interpolationAngularVelocity.setValue(0, 0, 0); + + //moved to btCollisionObject + m_friction = constructionInfo.m_friction; + m_rollingFriction = constructionInfo.m_rollingFriction; + m_spinningFriction = constructionInfo.m_spinningFriction; + + m_restitution = constructionInfo.m_restitution; + + setCollisionShape(constructionInfo.m_collisionShape); + m_debugBodyId = uniqueId++; + + setMassProps(constructionInfo.m_mass, constructionInfo.m_localInertia); + updateInertiaTensor(); + + m_rigidbodyFlags = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY; + + m_deltaLinearVelocity.setZero(); + m_deltaAngularVelocity.setZero(); + m_invMass = m_inverseMass * m_linearFactor; + m_pushVelocity.setZero(); + m_turnVelocity.setZero(); +} + +void btRigidBody::predictIntegratedTransform(btScalar timeStep, btTransform& predictedTransform) +{ + btTransformUtil::integrateTransform(m_worldTransform, m_linearVelocity, m_angularVelocity, timeStep, predictedTransform); +} + +void btRigidBody::saveKinematicState(btScalar timeStep) +{ + //todo: clamp to some (user definable) safe minimum timestep, to limit maximum angular/linear velocities + if (timeStep != btScalar(0.)) + { + //if we use motionstate to synchronize world transforms, get the new kinematic/animated world transform + if (getMotionState()) + getMotionState()->getWorldTransform(m_worldTransform); + btVector3 linVel, angVel; + + btTransformUtil::calculateVelocity(m_interpolationWorldTransform, m_worldTransform, timeStep, m_linearVelocity, m_angularVelocity); + m_interpolationLinearVelocity = m_linearVelocity; + m_interpolationAngularVelocity = m_angularVelocity; + m_interpolationWorldTransform = m_worldTransform; + //printf("angular = %f %f %f\n",m_angularVelocity.getX(),m_angularVelocity.getY(),m_angularVelocity.getZ()); + } +} + +void btRigidBody::getAabb(btVector3& aabbMin, btVector3& aabbMax) const +{ + getCollisionShape()->getAabb(m_worldTransform, aabbMin, aabbMax); +} + +void btRigidBody::setGravity(const btVector3& acceleration) +{ + if (m_inverseMass != btScalar(0.0)) + { + m_gravity = acceleration * (btScalar(1.0) / m_inverseMass); + } + m_gravity_acceleration = acceleration; +} + +void btRigidBody::setDamping(btScalar lin_damping, btScalar ang_damping) +{ +#ifdef BT_USE_OLD_DAMPING_METHOD + m_linearDamping = btMax(lin_damping, btScalar(0.0)); + m_angularDamping = btMax(ang_damping, btScalar(0.0)); +#else + m_linearDamping = btClamped(lin_damping, btScalar(0.0), btScalar(1.0)); + m_angularDamping = btClamped(ang_damping, btScalar(0.0), btScalar(1.0)); +#endif +} + +///applyDamping damps the velocity, using the given m_linearDamping and m_angularDamping +void btRigidBody::applyDamping(btScalar timeStep) +{ + //On new damping: see discussion/issue report here: http://code.google.com/p/bullet/issues/detail?id=74 + //todo: do some performance comparisons (but other parts of the engine are probably bottleneck anyway + +#ifdef BT_USE_OLD_DAMPING_METHOD + m_linearVelocity *= btMax((btScalar(1.0) - timeStep * m_linearDamping), btScalar(0.0)); + m_angularVelocity *= btMax((btScalar(1.0) - timeStep * m_angularDamping), btScalar(0.0)); +#else + m_linearVelocity *= btPow(btScalar(1) - m_linearDamping, timeStep); + m_angularVelocity *= btPow(btScalar(1) - m_angularDamping, timeStep); +#endif + + if (m_additionalDamping) + { + //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc. + //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete + if ((m_angularVelocity.length2() < m_additionalAngularDampingThresholdSqr) && + (m_linearVelocity.length2() < m_additionalLinearDampingThresholdSqr)) + { + m_angularVelocity *= m_additionalDampingFactor; + m_linearVelocity *= m_additionalDampingFactor; + } + + btScalar speed = m_linearVelocity.length(); + if (speed < m_linearDamping) + { + btScalar dampVel = btScalar(0.005); + if (speed > dampVel) + { + btVector3 dir = m_linearVelocity.normalized(); + m_linearVelocity -= dir * dampVel; + } + else + { + m_linearVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); + } + } + + btScalar angSpeed = m_angularVelocity.length(); + if (angSpeed < m_angularDamping) + { + btScalar angDampVel = btScalar(0.005); + if (angSpeed > angDampVel) + { + btVector3 dir = m_angularVelocity.normalized(); + m_angularVelocity -= dir * angDampVel; + } + else + { + m_angularVelocity.setValue(btScalar(0.), btScalar(0.), btScalar(0.)); + } + } + } +} + +void btRigidBody::applyGravity() +{ + if (isStaticOrKinematicObject()) + return; + + applyCentralForce(m_gravity); +} + +void btRigidBody::clearGravity() +{ + if (isStaticOrKinematicObject()) + return; + + applyCentralForce(-m_gravity); +} + +void btRigidBody::proceedToTransform(const btTransform& newTrans) +{ + setCenterOfMassTransform(newTrans); +} + +void btRigidBody::setMassProps(btScalar mass, const btVector3& inertia) +{ + if (mass == btScalar(0.)) + { + m_collisionFlags |= btCollisionObject::CF_STATIC_OBJECT; + m_inverseMass = btScalar(0.); + } + else + { + m_collisionFlags &= (~btCollisionObject::CF_STATIC_OBJECT); + m_inverseMass = btScalar(1.0) / mass; + } + + //Fg = m * a + m_gravity = mass * m_gravity_acceleration; + + m_invInertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0), + inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0), + inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0)); + + m_invMass = m_linearFactor * m_inverseMass; +} + +void btRigidBody::updateInertiaTensor() +{ + m_invInertiaTensorWorld = m_worldTransform.getBasis().scaled(m_invInertiaLocal) * m_worldTransform.getBasis().transpose(); +} + +btVector3 btRigidBody::getLocalInertia() const +{ + btVector3 inertiaLocal; + const btVector3 inertia = m_invInertiaLocal; + inertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0), + inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0), + inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0)); + return inertiaLocal; +} + +inline btVector3 evalEulerEqn(const btVector3& w1, const btVector3& w0, const btVector3& T, const btScalar dt, + const btMatrix3x3& I) +{ + const btVector3 w2 = I * w1 + w1.cross(I * w1) * dt - (T * dt + I * w0); + return w2; +} + +inline btMatrix3x3 evalEulerEqnDeriv(const btVector3& w1, const btVector3& w0, const btScalar dt, + const btMatrix3x3& I) +{ + btMatrix3x3 w1x, Iw1x; + const btVector3 Iwi = (I * w1); + w1.getSkewSymmetricMatrix(&w1x[0], &w1x[1], &w1x[2]); + Iwi.getSkewSymmetricMatrix(&Iw1x[0], &Iw1x[1], &Iw1x[2]); + + const btMatrix3x3 dfw1 = I + (w1x * I - Iw1x) * dt; + return dfw1; +} + +btVector3 btRigidBody::computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const +{ + btVector3 inertiaLocal = getLocalInertia(); + btMatrix3x3 inertiaTensorWorld = getWorldTransform().getBasis().scaled(inertiaLocal) * getWorldTransform().getBasis().transpose(); + btVector3 tmp = inertiaTensorWorld * getAngularVelocity(); + btVector3 gf = getAngularVelocity().cross(tmp); + btScalar l2 = gf.length2(); + if (l2 > maxGyroscopicForce * maxGyroscopicForce) + { + gf *= btScalar(1.) / btSqrt(l2) * maxGyroscopicForce; + } + return gf; +} + +btVector3 btRigidBody::computeGyroscopicImpulseImplicit_Body(btScalar step) const +{ + btVector3 idl = getLocalInertia(); + btVector3 omega1 = getAngularVelocity(); + btQuaternion q = getWorldTransform().getRotation(); + + // Convert to body coordinates + btVector3 omegab = quatRotate(q.inverse(), omega1); + btMatrix3x3 Ib; + Ib.setValue(idl.x(), 0, 0, + 0, idl.y(), 0, + 0, 0, idl.z()); + + btVector3 ibo = Ib * omegab; + + // Residual vector + btVector3 f = step * omegab.cross(ibo); + + btMatrix3x3 skew0; + omegab.getSkewSymmetricMatrix(&skew0[0], &skew0[1], &skew0[2]); + btVector3 om = Ib * omegab; + btMatrix3x3 skew1; + om.getSkewSymmetricMatrix(&skew1[0], &skew1[1], &skew1[2]); + + // Jacobian + btMatrix3x3 J = Ib + (skew0 * Ib - skew1) * step; + + // btMatrix3x3 Jinv = J.inverse(); + // btVector3 omega_div = Jinv*f; + btVector3 omega_div = J.solve33(f); + + // Single Newton-Raphson update + omegab = omegab - omega_div; //Solve33(J, f); + // Back to world coordinates + btVector3 omega2 = quatRotate(q, omegab); + btVector3 gf = omega2 - omega1; + return gf; +} + +btVector3 btRigidBody::computeGyroscopicImpulseImplicit_World(btScalar step) const +{ + // use full newton-euler equations. common practice to drop the wxIw term. want it for better tumbling behavior. + // calculate using implicit euler step so it's stable. + + const btVector3 inertiaLocal = getLocalInertia(); + const btVector3 w0 = getAngularVelocity(); + + btMatrix3x3 I; + + I = m_worldTransform.getBasis().scaled(inertiaLocal) * + m_worldTransform.getBasis().transpose(); + + // use newtons method to find implicit solution for new angular velocity (w') + // f(w') = -(T*step + Iw) + Iw' + w' + w'xIw'*step = 0 + // df/dw' = I + 1xIw'*step + w'xI*step + + btVector3 w1 = w0; + + // one step of newton's method + { + const btVector3 fw = evalEulerEqn(w1, w0, btVector3(0, 0, 0), step, I); + const btMatrix3x3 dfw = evalEulerEqnDeriv(w1, w0, step, I); + + btVector3 dw; + dw = dfw.solve33(fw); + //const btMatrix3x3 dfw_inv = dfw.inverse(); + //dw = dfw_inv*fw; + + w1 -= dw; + } + + btVector3 gf = (w1 - w0); + return gf; +} + +void btRigidBody::integrateVelocities(btScalar step) +{ + if (isStaticOrKinematicObject()) + return; + + m_linearVelocity += m_totalForce * (m_inverseMass * step); + m_angularVelocity += m_invInertiaTensorWorld * m_totalTorque * step; + +#define MAX_ANGVEL SIMD_HALF_PI + /// clamp angular velocity. collision calculations will fail on higher angular velocities + btScalar angvel = m_angularVelocity.length(); + if (angvel * step > MAX_ANGVEL) + { + m_angularVelocity *= (MAX_ANGVEL / step) / angvel; + } + #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 + clampVelocity(m_angularVelocity); + #endif +} + +btQuaternion btRigidBody::getOrientation() const +{ + btQuaternion orn; + m_worldTransform.getBasis().getRotation(orn); + return orn; +} + +void btRigidBody::setCenterOfMassTransform(const btTransform& xform) +{ + if (isKinematicObject()) + { + m_interpolationWorldTransform = m_worldTransform; + } + else + { + m_interpolationWorldTransform = xform; + } + m_interpolationLinearVelocity = getLinearVelocity(); + m_interpolationAngularVelocity = getAngularVelocity(); + m_worldTransform = xform; + updateInertiaTensor(); +} + +void btRigidBody::addConstraintRef(btTypedConstraint* c) +{ + ///disable collision with the 'other' body + + int index = m_constraintRefs.findLinearSearch(c); + //don't add constraints that are already referenced + //btAssert(index == m_constraintRefs.size()); + if (index == m_constraintRefs.size()) + { + m_constraintRefs.push_back(c); + btCollisionObject* colObjA = &c->getRigidBodyA(); + btCollisionObject* colObjB = &c->getRigidBodyB(); + if (colObjA == this) + { + colObjA->setIgnoreCollisionCheck(colObjB, true); + } + else + { + colObjB->setIgnoreCollisionCheck(colObjA, true); + } + } +} + +void btRigidBody::removeConstraintRef(btTypedConstraint* c) +{ + int index = m_constraintRefs.findLinearSearch(c); + //don't remove constraints that are not referenced + if (index < m_constraintRefs.size()) + { + m_constraintRefs.remove(c); + btCollisionObject* colObjA = &c->getRigidBodyA(); + btCollisionObject* colObjB = &c->getRigidBodyB(); + if (colObjA == this) + { + colObjA->setIgnoreCollisionCheck(colObjB, false); + } + else + { + colObjB->setIgnoreCollisionCheck(colObjA, false); + } + } +} + +int btRigidBody::calculateSerializeBufferSize() const +{ + int sz = sizeof(btRigidBodyData); + return sz; +} + +///fills the dataBuffer and returns the struct name (and 0 on failure) +const char* btRigidBody::serialize(void* dataBuffer, class btSerializer* serializer) const +{ + btRigidBodyData* rbd = (btRigidBodyData*)dataBuffer; + + btCollisionObject::serialize(&rbd->m_collisionObjectData, serializer); + + m_invInertiaTensorWorld.serialize(rbd->m_invInertiaTensorWorld); + m_linearVelocity.serialize(rbd->m_linearVelocity); + m_angularVelocity.serialize(rbd->m_angularVelocity); + rbd->m_inverseMass = m_inverseMass; + m_angularFactor.serialize(rbd->m_angularFactor); + m_linearFactor.serialize(rbd->m_linearFactor); + m_gravity.serialize(rbd->m_gravity); + m_gravity_acceleration.serialize(rbd->m_gravity_acceleration); + m_invInertiaLocal.serialize(rbd->m_invInertiaLocal); + m_totalForce.serialize(rbd->m_totalForce); + m_totalTorque.serialize(rbd->m_totalTorque); + rbd->m_linearDamping = m_linearDamping; + rbd->m_angularDamping = m_angularDamping; + rbd->m_additionalDamping = m_additionalDamping; + rbd->m_additionalDampingFactor = m_additionalDampingFactor; + rbd->m_additionalLinearDampingThresholdSqr = m_additionalLinearDampingThresholdSqr; + rbd->m_additionalAngularDampingThresholdSqr = m_additionalAngularDampingThresholdSqr; + rbd->m_additionalAngularDampingFactor = m_additionalAngularDampingFactor; + rbd->m_linearSleepingThreshold = m_linearSleepingThreshold; + rbd->m_angularSleepingThreshold = m_angularSleepingThreshold; + + // Fill padding with zeros to appease msan. +#ifdef BT_USE_DOUBLE_PRECISION + memset(rbd->m_padding, 0, sizeof(rbd->m_padding)); +#endif + + return btRigidBodyDataName; +} + +void btRigidBody::serializeSingleObject(class btSerializer* serializer) const +{ + btChunk* chunk = serializer->allocate(calculateSerializeBufferSize(), 1); + const char* structType = serialize(chunk->m_oldPtr, serializer); + serializer->finalizeChunk(chunk, structType, BT_RIGIDBODY_CODE, (void*)this); +} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.cpp.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.cpp.i new file mode 100644 index 00000000..21e37ef0 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btRigidBody.cpp ---------------- + +%include "BulletDynamics/Dynamics/btRigidBody.cpp" + +%{ +#include "BulletDynamics/Dynamics/btRigidBody.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.h b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.h new file mode 100644 index 00000000..31d23c8f --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.h @@ -0,0 +1,688 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_RIGIDBODY_H +#define BT_RIGIDBODY_H + +#include "LinearMath/btAlignedObjectArray.h" +#include "LinearMath/btTransform.h" +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" + +class btCollisionShape; +class btMotionState; +class btTypedConstraint; + +extern btScalar gDeactivationTime; +extern bool gDisableDeactivation; + +#ifdef BT_USE_DOUBLE_PRECISION +#define btRigidBodyData btRigidBodyDoubleData +#define btRigidBodyDataName "btRigidBodyDoubleData" +#else +#define btRigidBodyData btRigidBodyFloatData +#define btRigidBodyDataName "btRigidBodyFloatData" +#endif //BT_USE_DOUBLE_PRECISION + +enum btRigidBodyFlags +{ + BT_DISABLE_WORLD_GRAVITY = 1, + ///BT_ENABLE_GYROPSCOPIC_FORCE flags is enabled by default in Bullet 2.83 and onwards. + ///and it BT_ENABLE_GYROPSCOPIC_FORCE becomes equivalent to BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY + ///See Demos/GyroscopicDemo and computeGyroscopicImpulseImplicit + BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT = 2, + BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD = 4, + BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY = 8, + BT_ENABLE_GYROPSCOPIC_FORCE = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY, +}; + +///The btRigidBody is the main class for rigid body objects. It is derived from btCollisionObject, so it keeps a pointer to a btCollisionShape. +///It is recommended for performance and memory use to share btCollisionShape objects whenever possible. +///There are 3 types of rigid bodies: +///- A) Dynamic rigid bodies, with positive mass. Motion is controlled by rigid body dynamics. +///- B) Fixed objects with zero mass. They are not moving (basically collision objects) +///- C) Kinematic objects, which are objects without mass, but the user can move them. There is one-way interaction, and Bullet calculates a velocity based on the timestep and previous and current world transform. +///Bullet automatically deactivates dynamic rigid bodies, when the velocity is below a threshold for a given time. +///Deactivated (sleeping) rigid bodies don't take any processing time, except a minor broadphase collision detection impact (to allow active objects to activate/wake up sleeping objects) +class btRigidBody : public btCollisionObject +{ + btMatrix3x3 m_invInertiaTensorWorld; + btVector3 m_linearVelocity; + btVector3 m_angularVelocity; + btScalar m_inverseMass; + btVector3 m_linearFactor; + + btVector3 m_gravity; + btVector3 m_gravity_acceleration; + btVector3 m_invInertiaLocal; + btVector3 m_totalForce; + btVector3 m_totalTorque; + + btScalar m_linearDamping; + btScalar m_angularDamping; + + bool m_additionalDamping; + btScalar m_additionalDampingFactor; + btScalar m_additionalLinearDampingThresholdSqr; + btScalar m_additionalAngularDampingThresholdSqr; + btScalar m_additionalAngularDampingFactor; + + btScalar m_linearSleepingThreshold; + btScalar m_angularSleepingThreshold; + + //m_optionalMotionState allows to automatic synchronize the world transform for active objects + btMotionState* m_optionalMotionState; + + //keep track of typed constraints referencing this rigid body, to disable collision between linked bodies + btAlignedObjectArray m_constraintRefs; + + int m_rigidbodyFlags; + + int m_debugBodyId; + +protected: + ATTRIBUTE_ALIGNED16(btVector3 m_deltaLinearVelocity); + btVector3 m_deltaAngularVelocity; + btVector3 m_angularFactor; + btVector3 m_invMass; + btVector3 m_pushVelocity; + btVector3 m_turnVelocity; + +public: + ///The btRigidBodyConstructionInfo structure provides information to create a rigid body. Setting mass to zero creates a fixed (non-dynamic) rigid body. + ///For dynamic objects, you can use the collision shape to approximate the local inertia tensor, otherwise use the zero vector (default argument) + ///You can use the motion state to synchronize the world transform between physics and graphics objects. + ///And if the motion state is provided, the rigid body will initialize its initial world transform from the motion state, + ///m_startWorldTransform is only used when you don't provide a motion state. + struct btRigidBodyConstructionInfo + { + btScalar m_mass; + + ///When a motionState is provided, the rigid body will initialize its world transform from the motion state + ///In this case, m_startWorldTransform is ignored. + btMotionState* m_motionState; + btTransform m_startWorldTransform; + + btCollisionShape* m_collisionShape; + btVector3 m_localInertia; + btScalar m_linearDamping; + btScalar m_angularDamping; + + ///best simulation results when friction is non-zero + btScalar m_friction; + ///the m_rollingFriction prevents rounded shapes, such as spheres, cylinders and capsules from rolling forever. + ///See Bullet/Demos/RollingFrictionDemo for usage + btScalar m_rollingFriction; + btScalar m_spinningFriction; //torsional friction around contact normal + + ///best simulation results using zero restitution. + btScalar m_restitution; + + btScalar m_linearSleepingThreshold; + btScalar m_angularSleepingThreshold; + + //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc. + //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete + bool m_additionalDamping; + btScalar m_additionalDampingFactor; + btScalar m_additionalLinearDampingThresholdSqr; + btScalar m_additionalAngularDampingThresholdSqr; + btScalar m_additionalAngularDampingFactor; + + btRigidBodyConstructionInfo(btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia = btVector3(0, 0, 0)) : m_mass(mass), + m_motionState(motionState), + m_collisionShape(collisionShape), + m_localInertia(localInertia), + m_linearDamping(btScalar(0.)), + m_angularDamping(btScalar(0.)), + m_friction(btScalar(0.5)), + m_rollingFriction(btScalar(0)), + m_spinningFriction(btScalar(0)), + m_restitution(btScalar(0.)), + m_linearSleepingThreshold(btScalar(0.8)), + m_angularSleepingThreshold(btScalar(1.f)), + m_additionalDamping(false), + m_additionalDampingFactor(btScalar(0.005)), + m_additionalLinearDampingThresholdSqr(btScalar(0.01)), + m_additionalAngularDampingThresholdSqr(btScalar(0.01)), + m_additionalAngularDampingFactor(btScalar(0.01)) + { + m_startWorldTransform.setIdentity(); + } + }; + + ///btRigidBody constructor using construction info + btRigidBody(const btRigidBodyConstructionInfo& constructionInfo); + + ///btRigidBody constructor for backwards compatibility. + ///To specify friction (etc) during rigid body construction, please use the other constructor (using btRigidBodyConstructionInfo) + btRigidBody(btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia = btVector3(0, 0, 0)); + + virtual ~btRigidBody() + { + //No constraints should point to this rigidbody + //Remove constraints from the dynamics world before you delete the related rigidbodies. + btAssert(m_constraintRefs.size() == 0); + } + +protected: + ///setupRigidBody is only used internally by the constructor + void setupRigidBody(const btRigidBodyConstructionInfo& constructionInfo); + +public: + void proceedToTransform(const btTransform& newTrans); + + ///to keep collision detection and dynamics separate we don't store a rigidbody pointer + ///but a rigidbody is derived from btCollisionObject, so we can safely perform an upcast + static const btRigidBody* upcast(const btCollisionObject* colObj) + { + if (colObj->getInternalType() & btCollisionObject::CO_RIGID_BODY) + return (const btRigidBody*)colObj; + return 0; + } + static btRigidBody* upcast(btCollisionObject* colObj) + { + if (colObj->getInternalType() & btCollisionObject::CO_RIGID_BODY) + return (btRigidBody*)colObj; + return 0; + } + + /// continuous collision detection needs prediction + void predictIntegratedTransform(btScalar step, btTransform& predictedTransform); + + void saveKinematicState(btScalar step); + + void applyGravity(); + + void clearGravity(); + + void setGravity(const btVector3& acceleration); + + const btVector3& getGravity() const + { + return m_gravity_acceleration; + } + + void setDamping(btScalar lin_damping, btScalar ang_damping); + + btScalar getLinearDamping() const + { + return m_linearDamping; + } + + btScalar getAngularDamping() const + { + return m_angularDamping; + } + + btScalar getLinearSleepingThreshold() const + { + return m_linearSleepingThreshold; + } + + btScalar getAngularSleepingThreshold() const + { + return m_angularSleepingThreshold; + } + + void applyDamping(btScalar timeStep); + + SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const + { + return m_collisionShape; + } + + SIMD_FORCE_INLINE btCollisionShape* getCollisionShape() + { + return m_collisionShape; + } + + void setMassProps(btScalar mass, const btVector3& inertia); + + const btVector3& getLinearFactor() const + { + return m_linearFactor; + } + void setLinearFactor(const btVector3& linearFactor) + { + m_linearFactor = linearFactor; + m_invMass = m_linearFactor * m_inverseMass; + } + btScalar getInvMass() const { return m_inverseMass; } + btScalar getMass() const { return m_inverseMass == btScalar(0.) ? btScalar(0.) : btScalar(1.0) / m_inverseMass; } + const btMatrix3x3& getInvInertiaTensorWorld() const + { + return m_invInertiaTensorWorld; + } + + void integrateVelocities(btScalar step); + + void setCenterOfMassTransform(const btTransform& xform); + + void applyCentralForce(const btVector3& force) + { + m_totalForce += force * m_linearFactor; + } + + const btVector3& getTotalForce() const + { + return m_totalForce; + }; + + const btVector3& getTotalTorque() const + { + return m_totalTorque; + }; + + const btVector3& getInvInertiaDiagLocal() const + { + return m_invInertiaLocal; + }; + + void setInvInertiaDiagLocal(const btVector3& diagInvInertia) + { + m_invInertiaLocal = diagInvInertia; + } + + void setSleepingThresholds(btScalar linear, btScalar angular) + { + m_linearSleepingThreshold = linear; + m_angularSleepingThreshold = angular; + } + + void applyTorque(const btVector3& torque) + { + m_totalTorque += torque * m_angularFactor; + #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 + clampVelocity(m_totalTorque); + #endif + } + + void applyForce(const btVector3& force, const btVector3& rel_pos) + { + applyCentralForce(force); + applyTorque(rel_pos.cross(force * m_linearFactor)); + } + + void applyCentralImpulse(const btVector3& impulse) + { + m_linearVelocity += impulse * m_linearFactor * m_inverseMass; + #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 + clampVelocity(m_linearVelocity); + #endif + } + + void applyTorqueImpulse(const btVector3& torque) + { + m_angularVelocity += m_invInertiaTensorWorld * torque * m_angularFactor; + #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 + clampVelocity(m_angularVelocity); + #endif + } + + void applyImpulse(const btVector3& impulse, const btVector3& rel_pos) + { + if (m_inverseMass != btScalar(0.)) + { + applyCentralImpulse(impulse); + if (m_angularFactor) + { + applyTorqueImpulse(rel_pos.cross(impulse * m_linearFactor)); + } + } + } + + void applyPushImpulse(const btVector3& impulse, const btVector3& rel_pos) + { + if (m_inverseMass != btScalar(0.)) + { + applyCentralPushImpulse(impulse); + if (m_angularFactor) + { + applyTorqueTurnImpulse(rel_pos.cross(impulse * m_linearFactor)); + } + } + } + + btVector3 getPushVelocity() const + { + return m_pushVelocity; + } + + btVector3 getTurnVelocity() const + { + return m_turnVelocity; + } + + void setPushVelocity(const btVector3& v) + { + m_pushVelocity = v; + } + + #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 + void clampVelocity(btVector3& v) const { + v.setX( + fmax(-BT_CLAMP_VELOCITY_TO, + fmin(BT_CLAMP_VELOCITY_TO, v.getX())) + ); + v.setY( + fmax(-BT_CLAMP_VELOCITY_TO, + fmin(BT_CLAMP_VELOCITY_TO, v.getY())) + ); + v.setZ( + fmax(-BT_CLAMP_VELOCITY_TO, + fmin(BT_CLAMP_VELOCITY_TO, v.getZ())) + ); + } + #endif + + void setTurnVelocity(const btVector3& v) + { + m_turnVelocity = v; + #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 + clampVelocity(m_turnVelocity); + #endif + } + + void applyCentralPushImpulse(const btVector3& impulse) + { + m_pushVelocity += impulse * m_linearFactor * m_inverseMass; + #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 + clampVelocity(m_pushVelocity); + #endif + } + + void applyTorqueTurnImpulse(const btVector3& torque) + { + m_turnVelocity += m_invInertiaTensorWorld * torque * m_angularFactor; + #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 + clampVelocity(m_turnVelocity); + #endif + } + + void clearForces() + { + m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)); + m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)); + } + + void updateInertiaTensor(); + + const btVector3& getCenterOfMassPosition() const + { + return m_worldTransform.getOrigin(); + } + btQuaternion getOrientation() const; + + const btTransform& getCenterOfMassTransform() const + { + return m_worldTransform; + } + const btVector3& getLinearVelocity() const + { + return m_linearVelocity; + } + const btVector3& getAngularVelocity() const + { + return m_angularVelocity; + } + + inline void setLinearVelocity(const btVector3& lin_vel) + { + m_updateRevision++; + m_linearVelocity = lin_vel; + #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 + clampVelocity(m_linearVelocity); + #endif + } + + inline void setAngularVelocity(const btVector3& ang_vel) + { + m_updateRevision++; + m_angularVelocity = ang_vel; + #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 + clampVelocity(m_angularVelocity); + #endif + } + + btVector3 getVelocityInLocalPoint(const btVector3& rel_pos) const + { + //we also calculate lin/ang velocity for kinematic objects + return m_linearVelocity + m_angularVelocity.cross(rel_pos); + + //for kinematic objects, we could also use use: + // return (m_worldTransform(rel_pos) - m_interpolationWorldTransform(rel_pos)) / m_kinematicTimeStep; + } + + btVector3 getPushVelocityInLocalPoint(const btVector3& rel_pos) const + { + //we also calculate lin/ang velocity for kinematic objects + return m_pushVelocity + m_turnVelocity.cross(rel_pos); + } + + void translate(const btVector3& v) + { + m_worldTransform.getOrigin() += v; + } + + void getAabb(btVector3& aabbMin, btVector3& aabbMax) const; + + SIMD_FORCE_INLINE btScalar computeImpulseDenominator(const btVector3& pos, const btVector3& normal) const + { + btVector3 r0 = pos - getCenterOfMassPosition(); + + btVector3 c0 = (r0).cross(normal); + + btVector3 vec = (c0 * getInvInertiaTensorWorld()).cross(r0); + + return m_inverseMass + normal.dot(vec); + } + + SIMD_FORCE_INLINE btScalar computeAngularImpulseDenominator(const btVector3& axis) const + { + btVector3 vec = axis * getInvInertiaTensorWorld(); + return axis.dot(vec); + } + + SIMD_FORCE_INLINE void updateDeactivation(btScalar timeStep) + { + if ((getActivationState() == ISLAND_SLEEPING) || (getActivationState() == DISABLE_DEACTIVATION)) + return; + + if ((getLinearVelocity().length2() < m_linearSleepingThreshold * m_linearSleepingThreshold) && + (getAngularVelocity().length2() < m_angularSleepingThreshold * m_angularSleepingThreshold)) + { + m_deactivationTime += timeStep; + } + else + { + m_deactivationTime = btScalar(0.); + setActivationState(0); + } + } + + SIMD_FORCE_INLINE bool wantsSleeping() + { + if (getActivationState() == DISABLE_DEACTIVATION) + return false; + + //disable deactivation + if (gDisableDeactivation || (gDeactivationTime == btScalar(0.))) + return false; + + if ((getActivationState() == ISLAND_SLEEPING) || (getActivationState() == WANTS_DEACTIVATION)) + return true; + + if (m_deactivationTime > gDeactivationTime) + { + return true; + } + return false; + } + + const btBroadphaseProxy* getConstBroadphaseProxy() const + { + return m_broadphaseHandle; + } + + btBroadphaseProxy* getBroadphaseProxy() + { + return m_broadphaseHandle; + } + void setNewBroadphaseProxy(btBroadphaseProxy* broadphaseProxy) + { + m_broadphaseHandle = broadphaseProxy; + } + + //btMotionState allows to automatic synchronize the world transform for active objects + btMotionState* getMotionState() + { + return m_optionalMotionState; + } + const btMotionState* getMotionState() const + { + return m_optionalMotionState; + } + void setMotionState(btMotionState* motionState) + { + m_optionalMotionState = motionState; + if (m_optionalMotionState) + motionState->getWorldTransform(m_worldTransform); + } + + //for experimental overriding of friction/contact solver func + int m_contactSolverType; + int m_frictionSolverType; + + void setAngularFactor(const btVector3& angFac) + { + m_updateRevision++; + m_angularFactor = angFac; + } + + void setAngularFactor(btScalar angFac) + { + m_updateRevision++; + m_angularFactor.setValue(angFac, angFac, angFac); + } + const btVector3& getAngularFactor() const + { + return m_angularFactor; + } + + //is this rigidbody added to a btCollisionWorld/btDynamicsWorld/btBroadphase? + bool isInWorld() const + { + return (getConstBroadphaseProxy() != 0); + } + + void addConstraintRef(btTypedConstraint* c); + void removeConstraintRef(btTypedConstraint* c); + + btTypedConstraint* getConstraintRef(int index) + { + return m_constraintRefs[index]; + } + + int getNumConstraintRefs() const + { + return m_constraintRefs.size(); + } + + void setFlags(int flags) + { + m_rigidbodyFlags = flags; + } + + int getFlags() const + { + return m_rigidbodyFlags; + } + + ///perform implicit force computation in world space + btVector3 computeGyroscopicImpulseImplicit_World(btScalar dt) const; + + ///perform implicit force computation in body space (inertial frame) + btVector3 computeGyroscopicImpulseImplicit_Body(btScalar step) const; + + ///explicit version is best avoided, it gains energy + btVector3 computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const; + btVector3 getLocalInertia() const; + + /////////////////////////////////////////////// + + virtual int calculateSerializeBufferSize() const; + + ///fills the dataBuffer and returns the struct name (and 0 on failure) + virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const; + + virtual void serializeSingleObject(class btSerializer* serializer) const; +}; + +//@todo add m_optionalMotionState and m_constraintRefs to btRigidBodyData +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btRigidBodyFloatData +{ + btCollisionObjectFloatData m_collisionObjectData; + btMatrix3x3FloatData m_invInertiaTensorWorld; + btVector3FloatData m_linearVelocity; + btVector3FloatData m_angularVelocity; + btVector3FloatData m_angularFactor; + btVector3FloatData m_linearFactor; + btVector3FloatData m_gravity; + btVector3FloatData m_gravity_acceleration; + btVector3FloatData m_invInertiaLocal; + btVector3FloatData m_totalForce; + btVector3FloatData m_totalTorque; + float m_inverseMass; + float m_linearDamping; + float m_angularDamping; + float m_additionalDampingFactor; + float m_additionalLinearDampingThresholdSqr; + float m_additionalAngularDampingThresholdSqr; + float m_additionalAngularDampingFactor; + float m_linearSleepingThreshold; + float m_angularSleepingThreshold; + int m_additionalDamping; +}; + +///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 +struct btRigidBodyDoubleData +{ + btCollisionObjectDoubleData m_collisionObjectData; + btMatrix3x3DoubleData m_invInertiaTensorWorld; + btVector3DoubleData m_linearVelocity; + btVector3DoubleData m_angularVelocity; + btVector3DoubleData m_angularFactor; + btVector3DoubleData m_linearFactor; + btVector3DoubleData m_gravity; + btVector3DoubleData m_gravity_acceleration; + btVector3DoubleData m_invInertiaLocal; + btVector3DoubleData m_totalForce; + btVector3DoubleData m_totalTorque; + double m_inverseMass; + double m_linearDamping; + double m_angularDamping; + double m_additionalDampingFactor; + double m_additionalLinearDampingThresholdSqr; + double m_additionalAngularDampingThresholdSqr; + double m_additionalAngularDampingFactor; + double m_linearSleepingThreshold; + double m_angularSleepingThreshold; + int m_additionalDamping; + char m_padding[4]; +}; + +#endif //BT_RIGIDBODY_H diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.h.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.h.i new file mode 100644 index 00000000..452197d3 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btRigidBody.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btRigidBody.h ---------------- + +%include "BulletDynamics/Dynamics/btRigidBody.h" + +%{ +#include "BulletDynamics/Dynamics/btRigidBody.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp new file mode 100644 index 00000000..134c482e --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp @@ -0,0 +1,260 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btSimpleDynamicsWorld.h" +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +#include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h" +#include "BulletCollision/CollisionShapes/btCollisionShape.h" +#include "BulletDynamics/Dynamics/btRigidBody.h" +#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h" +#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" + +/* + Make sure this dummy function never changes so that it + can be used by probes that are checking whether the + library is actually installed. +*/ +extern "C" +{ + void btBulletDynamicsProbe(); + void btBulletDynamicsProbe() {} +} + +btSimpleDynamicsWorld::btSimpleDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration) + : btDynamicsWorld(dispatcher, pairCache, collisionConfiguration), + m_constraintSolver(constraintSolver), + m_ownsConstraintSolver(false), + m_gravity(0, 0, -10) +{ +} + +btSimpleDynamicsWorld::~btSimpleDynamicsWorld() +{ + if (m_ownsConstraintSolver) + btAlignedFree(m_constraintSolver); +} + +int btSimpleDynamicsWorld::stepSimulation(btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep) +{ + (void)fixedTimeStep; + (void)maxSubSteps; + + ///apply gravity, predict motion + predictUnconstraintMotion(timeStep); + + btDispatcherInfo& dispatchInfo = getDispatchInfo(); + dispatchInfo.m_timeStep = timeStep; + dispatchInfo.m_stepCount = 0; + dispatchInfo.m_debugDraw = getDebugDrawer(); + + ///perform collision detection + performDiscreteCollisionDetection(); + + ///solve contact constraints + int numManifolds = m_dispatcher1->getNumManifolds(); + if (numManifolds) + { + btPersistentManifold** manifoldPtr = ((btCollisionDispatcher*)m_dispatcher1)->getInternalManifoldPointer(); + + btContactSolverInfo infoGlobal; + infoGlobal.m_timeStep = timeStep; + m_constraintSolver->prepareSolve(0, numManifolds); + m_constraintSolver->solveGroup(&getCollisionObjectArray()[0], getNumCollisionObjects(), manifoldPtr, numManifolds, 0, 0, infoGlobal, m_debugDrawer, m_dispatcher1); + m_constraintSolver->allSolved(infoGlobal, m_debugDrawer); + } + + ///integrate transforms + integrateTransforms(timeStep); + + updateAabbs(); + + synchronizeMotionStates(); + + clearForces(); + + return 1; +} + +void btSimpleDynamicsWorld::clearForces() +{ + ///@todo: iterate over awake simulation islands! + for (int i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + + btRigidBody* body = btRigidBody::upcast(colObj); + if (body) + { + body->clearForces(); + } + } +} + +void btSimpleDynamicsWorld::setGravity(const btVector3& gravity) +{ + m_gravity = gravity; + for (int i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + btRigidBody* body = btRigidBody::upcast(colObj); + if (body) + { + body->setGravity(gravity); + } + } +} + +btVector3 btSimpleDynamicsWorld::getGravity() const +{ + return m_gravity; +} + +void btSimpleDynamicsWorld::removeRigidBody(btRigidBody* body) +{ + btCollisionWorld::removeCollisionObject(body); +} + +void btSimpleDynamicsWorld::removeCollisionObject(btCollisionObject* collisionObject) +{ + btRigidBody* body = btRigidBody::upcast(collisionObject); + if (body) + removeRigidBody(body); + else + btCollisionWorld::removeCollisionObject(collisionObject); +} + +void btSimpleDynamicsWorld::addRigidBody(btRigidBody* body) +{ + body->setGravity(m_gravity); + + if (body->getCollisionShape()) + { + addCollisionObject(body); + } +} + +void btSimpleDynamicsWorld::addRigidBody(btRigidBody* body, int group, int mask) +{ + body->setGravity(m_gravity); + + if (body->getCollisionShape()) + { + addCollisionObject(body, group, mask); + } +} + +void btSimpleDynamicsWorld::debugDrawWorld() +{ +} + +void btSimpleDynamicsWorld::addAction(btActionInterface* action) +{ +} + +void btSimpleDynamicsWorld::removeAction(btActionInterface* action) +{ +} + +void btSimpleDynamicsWorld::updateAabbs() +{ + btTransform predictedTrans; + for (int i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + btRigidBody* body = btRigidBody::upcast(colObj); + if (body) + { + if (body->isActive() && (!body->isStaticObject())) + { + btVector3 minAabb, maxAabb; + colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb, maxAabb); + btBroadphaseInterface* bp = getBroadphase(); + bp->setAabb(body->getBroadphaseHandle(), minAabb, maxAabb, m_dispatcher1); + } + } + } +} + +void btSimpleDynamicsWorld::integrateTransforms(btScalar timeStep) +{ + btTransform predictedTrans; + for (int i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + btRigidBody* body = btRigidBody::upcast(colObj); + if (body) + { + if (body->isActive() && (!body->isStaticObject())) + { + body->predictIntegratedTransform(timeStep, predictedTrans); + body->proceedToTransform(predictedTrans); + } + } + } +} + +void btSimpleDynamicsWorld::predictUnconstraintMotion(btScalar timeStep) +{ + for (int i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + btRigidBody* body = btRigidBody::upcast(colObj); + if (body) + { + if (!body->isStaticObject()) + { + if (body->isActive()) + { + body->applyGravity(); + body->integrateVelocities(timeStep); + body->applyDamping(timeStep); + body->predictIntegratedTransform(timeStep, body->getInterpolationWorldTransform()); + } + } + } + } +} + +void btSimpleDynamicsWorld::synchronizeMotionStates() +{ + ///@todo: iterate over awake simulation islands! + for (int i = 0; i < m_collisionObjects.size(); i++) + { + btCollisionObject* colObj = m_collisionObjects[i]; + btRigidBody* body = btRigidBody::upcast(colObj); + if (body && body->getMotionState()) + { + if (body->getActivationState() != ISLAND_SLEEPING) + { + body->getMotionState()->setWorldTransform(body->getWorldTransform()); + } + } + } +} + +void btSimpleDynamicsWorld::setConstraintSolver(btConstraintSolver* solver) +{ + if (m_ownsConstraintSolver) + { + btAlignedFree(m_constraintSolver); + } + m_ownsConstraintSolver = false; + m_constraintSolver = solver; +} + +btConstraintSolver* btSimpleDynamicsWorld::getConstraintSolver() +{ + return m_constraintSolver; +} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp.i new file mode 100644 index 00000000..025cec74 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp ---------------- + +%include "BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp" + +%{ +#include "BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h new file mode 100644 index 00000000..46bd535f --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h @@ -0,0 +1,84 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SIMPLE_DYNAMICS_WORLD_H +#define BT_SIMPLE_DYNAMICS_WORLD_H + +#include "btDynamicsWorld.h" + +class btDispatcher; +class btOverlappingPairCache; +class btConstraintSolver; + +///The btSimpleDynamicsWorld serves as unit-test and to verify more complicated and optimized dynamics worlds. +///Please use btDiscreteDynamicsWorld instead +class btSimpleDynamicsWorld : public btDynamicsWorld +{ +protected: + btConstraintSolver* m_constraintSolver; + + bool m_ownsConstraintSolver; + + void predictUnconstraintMotion(btScalar timeStep); + + void integrateTransforms(btScalar timeStep); + + btVector3 m_gravity; + +public: + ///this btSimpleDynamicsWorld constructor creates dispatcher, broadphase pairCache and constraintSolver + btSimpleDynamicsWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration); + + virtual ~btSimpleDynamicsWorld(); + + ///maxSubSteps/fixedTimeStep for interpolation is currently ignored for btSimpleDynamicsWorld, use btDiscreteDynamicsWorld instead + virtual int stepSimulation(btScalar timeStep, int maxSubSteps = 1, btScalar fixedTimeStep = btScalar(1.) / btScalar(60.)); + + virtual void setGravity(const btVector3& gravity); + + virtual btVector3 getGravity() const; + + virtual void addRigidBody(btRigidBody* body); + + virtual void addRigidBody(btRigidBody* body, int group, int mask); + + virtual void removeRigidBody(btRigidBody* body); + + virtual void debugDrawWorld(); + + virtual void addAction(btActionInterface* action); + + virtual void removeAction(btActionInterface* action); + + ///removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject + virtual void removeCollisionObject(btCollisionObject* collisionObject); + + virtual void updateAabbs(); + + virtual void synchronizeMotionStates(); + + virtual void setConstraintSolver(btConstraintSolver* solver); + + virtual btConstraintSolver* getConstraintSolver(); + + virtual btDynamicsWorldType getWorldType() const + { + return BT_SIMPLE_DYNAMICS_WORLD; + } + + virtual void clearForces(); +}; + +#endif //BT_SIMPLE_DYNAMICS_WORLD_H diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h.i new file mode 100644 index 00000000..e1b5fa4e --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btSimpleDynamicsWorld.h ---------------- + +%include "BulletDynamics/Dynamics/btSimpleDynamicsWorld.h" + +%{ +#include "BulletDynamics/Dynamics/btSimpleDynamicsWorld.h" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp new file mode 100644 index 00000000..4d62d4f8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp @@ -0,0 +1,696 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "LinearMath/btScalar.h" +#include "LinearMath/btThreads.h" +#include "btSimulationIslandManagerMt.h" +#include "BulletCollision/BroadphaseCollision/btDispatcher.h" +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" +#include "BulletCollision/CollisionDispatch/btCollisionWorld.h" +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h" // for s_minimumContactManifoldsForBatching + +//#include +#include "LinearMath/btQuickprof.h" + +SIMD_FORCE_INLINE int calcBatchCost(int bodies, int manifolds, int constraints) +{ + // rough estimate of the cost of a batch, used for merging + int batchCost = bodies + 8 * manifolds + 4 * constraints; + return batchCost; +} + +SIMD_FORCE_INLINE int calcBatchCost(const btSimulationIslandManagerMt::Island* island) +{ + return calcBatchCost(island->bodyArray.size(), island->manifoldArray.size(), island->constraintArray.size()); +} + +btSimulationIslandManagerMt::btSimulationIslandManagerMt() +{ + m_minimumSolverBatchSize = calcBatchCost(0, 128, 0); + m_batchIslandMinBodyCount = 32; + m_islandDispatch = parallelIslandDispatch; + m_batchIsland = NULL; +} + +btSimulationIslandManagerMt::~btSimulationIslandManagerMt() +{ + for (int i = 0; i < m_allocatedIslands.size(); ++i) + { + delete m_allocatedIslands[i]; + } + m_allocatedIslands.resize(0); + m_activeIslands.resize(0); + m_freeIslands.resize(0); +} + +inline int getIslandId(const btPersistentManifold* lhs) +{ + const btCollisionObject* rcolObj0 = static_cast(lhs->getBody0()); + const btCollisionObject* rcolObj1 = static_cast(lhs->getBody1()); + int islandId = rcolObj0->getIslandTag() >= 0 ? rcolObj0->getIslandTag() : rcolObj1->getIslandTag(); + return islandId; +} + +SIMD_FORCE_INLINE int btGetConstraintIslandId1(const btTypedConstraint* lhs) +{ + const btCollisionObject& rcolObj0 = lhs->getRigidBodyA(); + const btCollisionObject& rcolObj1 = lhs->getRigidBodyB(); + int islandId = rcolObj0.getIslandTag() >= 0 ? rcolObj0.getIslandTag() : rcolObj1.getIslandTag(); + return islandId; +} + +/// function object that routes calls to operator< +class IslandBatchSizeSortPredicate +{ +public: + bool operator()(const btSimulationIslandManagerMt::Island* lhs, const btSimulationIslandManagerMt::Island* rhs) const + { + int lCost = calcBatchCost(lhs); + int rCost = calcBatchCost(rhs); + return lCost > rCost; + } +}; + +class IslandBodyCapacitySortPredicate +{ +public: + bool operator()(const btSimulationIslandManagerMt::Island* lhs, const btSimulationIslandManagerMt::Island* rhs) const + { + return lhs->bodyArray.capacity() > rhs->bodyArray.capacity(); + } +}; + +void btSimulationIslandManagerMt::Island::append(const Island& other) +{ + // append bodies + for (int i = 0; i < other.bodyArray.size(); ++i) + { + bodyArray.push_back(other.bodyArray[i]); + } + // append manifolds + for (int i = 0; i < other.manifoldArray.size(); ++i) + { + manifoldArray.push_back(other.manifoldArray[i]); + } + // append constraints + for (int i = 0; i < other.constraintArray.size(); ++i) + { + constraintArray.push_back(other.constraintArray[i]); + } +} + +bool btIsBodyInIsland(const btSimulationIslandManagerMt::Island& island, const btCollisionObject* obj) +{ + for (int i = 0; i < island.bodyArray.size(); ++i) + { + if (island.bodyArray[i] == obj) + { + return true; + } + } + return false; +} + +void btSimulationIslandManagerMt::initIslandPools() +{ + // reset island pools + int numElem = getUnionFind().getNumElements(); + m_lookupIslandFromId.resize(numElem); + for (int i = 0; i < m_lookupIslandFromId.size(); ++i) + { + m_lookupIslandFromId[i] = NULL; + } + m_activeIslands.resize(0); + m_freeIslands.resize(0); + // check whether allocated islands are sorted by body capacity (largest to smallest) + int lastCapacity = 0; + bool isSorted = true; + for (int i = 0; i < m_allocatedIslands.size(); ++i) + { + Island* island = m_allocatedIslands[i]; + int cap = island->bodyArray.capacity(); + if (cap > lastCapacity) + { + isSorted = false; + break; + } + lastCapacity = cap; + } + if (!isSorted) + { + m_allocatedIslands.quickSort(IslandBodyCapacitySortPredicate()); + } + + m_batchIsland = NULL; + // mark all islands free (but avoid deallocation) + for (int i = 0; i < m_allocatedIslands.size(); ++i) + { + Island* island = m_allocatedIslands[i]; + island->bodyArray.resize(0); + island->manifoldArray.resize(0); + island->constraintArray.resize(0); + island->id = -1; + island->isSleeping = true; + m_freeIslands.push_back(island); + } +} + +btSimulationIslandManagerMt::Island* btSimulationIslandManagerMt::getIsland(int id) +{ + btAssert(id >= 0); + btAssert(id < m_lookupIslandFromId.size()); + Island* island = m_lookupIslandFromId[id]; + if (island == NULL) + { + // search for existing island + for (int i = 0; i < m_activeIslands.size(); ++i) + { + if (m_activeIslands[i]->id == id) + { + island = m_activeIslands[i]; + break; + } + } + m_lookupIslandFromId[id] = island; + } + return island; +} + +btSimulationIslandManagerMt::Island* btSimulationIslandManagerMt::allocateIsland(int id, int numBodies) +{ + Island* island = NULL; + int allocSize = numBodies; + if (numBodies < m_batchIslandMinBodyCount) + { + if (m_batchIsland) + { + island = m_batchIsland; + m_lookupIslandFromId[id] = island; + // if we've made a large enough batch, + if (island->bodyArray.size() + numBodies >= m_batchIslandMinBodyCount) + { + // next time start a new batch + m_batchIsland = NULL; + } + return island; + } + else + { + // need to allocate a batch island + allocSize = m_batchIslandMinBodyCount * 2; + } + } + btAlignedObjectArray& freeIslands = m_freeIslands; + + // search for free island + if (freeIslands.size() > 0) + { + // try to reuse a previously allocated island + int iFound = freeIslands.size(); + // linear search for smallest island that can hold our bodies + for (int i = freeIslands.size() - 1; i >= 0; --i) + { + if (freeIslands[i]->bodyArray.capacity() >= allocSize) + { + iFound = i; + island = freeIslands[i]; + island->id = id; + break; + } + } + // if found, shrink array while maintaining ordering + if (island) + { + int iDest = iFound; + int iSrc = iDest + 1; + while (iSrc < freeIslands.size()) + { + freeIslands[iDest++] = freeIslands[iSrc++]; + } + freeIslands.pop_back(); + } + } + if (island == NULL) + { + // no free island found, allocate + island = new Island(); // TODO: change this to use the pool allocator + island->id = id; + island->bodyArray.reserve(allocSize); + m_allocatedIslands.push_back(island); + } + m_lookupIslandFromId[id] = island; + if (numBodies < m_batchIslandMinBodyCount) + { + m_batchIsland = island; + } + m_activeIslands.push_back(island); + return island; +} + +void btSimulationIslandManagerMt::buildIslands(btDispatcher* dispatcher, btCollisionWorld* collisionWorld) +{ +//\1("buildIslands"); + + btCollisionObjectArray& collisionObjects = collisionWorld->getCollisionObjectArray(); + + //we are going to sort the unionfind array, and store the element id in the size + //afterwards, we clean unionfind, to make sure no-one uses it anymore + + getUnionFind().sortIslands(); + int numElem = getUnionFind().getNumElements(); + + int endIslandIndex = 1; + int startIslandIndex; + + //update the sleeping state for bodies, if all are sleeping + for (startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex) + { + int islandId = getUnionFind().getElement(startIslandIndex).m_id; + for (endIslandIndex = startIslandIndex + 1; (endIslandIndex < numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId); endIslandIndex++) + { + } + + //int numSleeping = 0; + + bool allSleeping = true; + + int idx; + for (idx = startIslandIndex; idx < endIslandIndex; idx++) + { + int i = getUnionFind().getElement(idx).m_sz; + + btCollisionObject* colObj0 = collisionObjects[i]; + if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1)) + { + // printf("error in island management\n"); + } + + btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1)); + if (colObj0->getIslandTag() == islandId) + { + if (colObj0->getActivationState() == ACTIVE_TAG || + colObj0->getActivationState() == DISABLE_DEACTIVATION) + { + allSleeping = false; + break; + } + } + } + + if (allSleeping) + { + int idx; + for (idx = startIslandIndex; idx < endIslandIndex; idx++) + { + int i = getUnionFind().getElement(idx).m_sz; + btCollisionObject* colObj0 = collisionObjects[i]; + if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1)) + { + // printf("error in island management\n"); + } + + btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1)); + + if (colObj0->getIslandTag() == islandId) + { + colObj0->setActivationState(ISLAND_SLEEPING); + } + } + } + else + { + int idx; + for (idx = startIslandIndex; idx < endIslandIndex; idx++) + { + int i = getUnionFind().getElement(idx).m_sz; + + btCollisionObject* colObj0 = collisionObjects[i]; + if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1)) + { + // printf("error in island management\n"); + } + + btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1)); + + if (colObj0->getIslandTag() == islandId) + { + if (colObj0->getActivationState() == ISLAND_SLEEPING) + { + colObj0->setActivationState(WANTS_DEACTIVATION); + colObj0->setDeactivationTime(0.f); + } + } + } + } + } +} + +void btSimulationIslandManagerMt::addBodiesToIslands(btCollisionWorld* collisionWorld) +{ + btCollisionObjectArray& collisionObjects = collisionWorld->getCollisionObjectArray(); + int endIslandIndex = 1; + int startIslandIndex; + int numElem = getUnionFind().getNumElements(); + + // create explicit islands and add bodies to each + for (startIslandIndex = 0; startIslandIndex < numElem; startIslandIndex = endIslandIndex) + { + int islandId = getUnionFind().getElement(startIslandIndex).m_id; + + // find end index + for (endIslandIndex = startIslandIndex; (endIslandIndex < numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId); endIslandIndex++) + { + } + // check if island is sleeping + bool islandSleeping = true; + for (int iElem = startIslandIndex; iElem < endIslandIndex; iElem++) + { + int i = getUnionFind().getElement(iElem).m_sz; + btCollisionObject* colObj = collisionObjects[i]; + if (colObj->isActive()) + { + islandSleeping = false; + } + } + if (!islandSleeping) + { + // want to count the number of bodies before allocating the island to optimize memory usage of the Island structures + int numBodies = endIslandIndex - startIslandIndex; + Island* island = allocateIsland(islandId, numBodies); + island->isSleeping = false; + + // add bodies to island + for (int iElem = startIslandIndex; iElem < endIslandIndex; iElem++) + { + int i = getUnionFind().getElement(iElem).m_sz; + btCollisionObject* colObj = collisionObjects[i]; + island->bodyArray.push_back(colObj); + } + } + } +} + +void btSimulationIslandManagerMt::addManifoldsToIslands(btDispatcher* dispatcher) +{ + // walk all the manifolds, activating bodies touched by kinematic objects, and add each manifold to its Island + int maxNumManifolds = dispatcher->getNumManifolds(); + for (int i = 0; i < maxNumManifolds; i++) + { + btPersistentManifold* manifold = dispatcher->getManifoldByIndexInternal(i); + + const btCollisionObject* colObj0 = static_cast(manifold->getBody0()); + const btCollisionObject* colObj1 = static_cast(manifold->getBody1()); + + ///@todo: check sleeping conditions! + if (((colObj0) && colObj0->getActivationState() != ISLAND_SLEEPING) || + ((colObj1) && colObj1->getActivationState() != ISLAND_SLEEPING)) + { + //kinematic objects don't merge islands, but wake up all connected objects + if (colObj0->isKinematicObject() && colObj0->getActivationState() != ISLAND_SLEEPING) + { + if (colObj0->hasContactResponse()) + colObj1->activate(); + } + if (colObj1->isKinematicObject() && colObj1->getActivationState() != ISLAND_SLEEPING) + { + if (colObj1->hasContactResponse()) + colObj0->activate(); + } + //filtering for response + if (dispatcher->needsResponse(colObj0, colObj1)) + { + // scatter manifolds into various islands + int islandId = getIslandId(manifold); + // if island not sleeping, + if (Island* island = getIsland(islandId)) + { + island->manifoldArray.push_back(manifold); + } + } + } + } +} + +void btSimulationIslandManagerMt::addConstraintsToIslands(btAlignedObjectArray& constraints) +{ + // walk constraints + for (int i = 0; i < constraints.size(); i++) + { + // scatter constraints into various islands + btTypedConstraint* constraint = constraints[i]; + if (constraint->isEnabled()) + { + int islandId = btGetConstraintIslandId1(constraint); + // if island is not sleeping, + if (Island* island = getIsland(islandId)) + { + island->constraintArray.push_back(constraint); + } + } + } +} + +void btSimulationIslandManagerMt::mergeIslands() +{ + // sort islands in order of decreasing batch size + m_activeIslands.quickSort(IslandBatchSizeSortPredicate()); + + // merge small islands to satisfy minimum batch size + // find first small batch island + int destIslandIndex = m_activeIslands.size(); + for (int i = 0; i < m_activeIslands.size(); ++i) + { + Island* island = m_activeIslands[i]; + int batchSize = calcBatchCost(island); + if (batchSize < m_minimumSolverBatchSize) + { + destIslandIndex = i; + break; + } + } + int lastIndex = m_activeIslands.size() - 1; + while (destIslandIndex < lastIndex) + { + // merge islands from the back of the list + Island* island = m_activeIslands[destIslandIndex]; + int numBodies = island->bodyArray.size(); + int numManifolds = island->manifoldArray.size(); + int numConstraints = island->constraintArray.size(); + int firstIndex = lastIndex; + // figure out how many islands we want to merge and find out how many bodies, manifolds and constraints we will have + while (true) + { + Island* src = m_activeIslands[firstIndex]; + numBodies += src->bodyArray.size(); + numManifolds += src->manifoldArray.size(); + numConstraints += src->constraintArray.size(); + int batchCost = calcBatchCost(numBodies, numManifolds, numConstraints); + if (batchCost >= m_minimumSolverBatchSize) + { + break; + } + if (firstIndex - 1 == destIslandIndex) + { + break; + } + firstIndex--; + } + // reserve space for these pointers to minimize reallocation + island->bodyArray.reserve(numBodies); + island->manifoldArray.reserve(numManifolds); + island->constraintArray.reserve(numConstraints); + // merge islands + for (int i = firstIndex; i <= lastIndex; ++i) + { + island->append(*m_activeIslands[i]); + } + // shrink array to exclude the islands that were merged from + m_activeIslands.resize(firstIndex); + lastIndex = firstIndex - 1; + destIslandIndex++; + } +} + +void btSimulationIslandManagerMt::solveIsland(btConstraintSolver* solver, Island& island, const SolverParams& solverParams) +{ + btPersistentManifold** manifolds = island.manifoldArray.size() ? &island.manifoldArray[0] : NULL; + btTypedConstraint** constraintsPtr = island.constraintArray.size() ? &island.constraintArray[0] : NULL; + solver->solveGroup(&island.bodyArray[0], + island.bodyArray.size(), + manifolds, + island.manifoldArray.size(), + constraintsPtr, + island.constraintArray.size(), + *solverParams.m_solverInfo, + solverParams.m_debugDrawer, + solverParams.m_dispatcher); +} + +void btSimulationIslandManagerMt::serialIslandDispatch(btAlignedObjectArray* islandsPtr, const SolverParams& solverParams) +{ +//\1("serialIslandDispatch"); + // serial dispatch + btAlignedObjectArray& islands = *islandsPtr; + btConstraintSolver* solver = solverParams.m_solverMt ? solverParams.m_solverMt : solverParams.m_solverPool; + for (int i = 0; i < islands.size(); ++i) + { + solveIsland(solver, *islands[i], solverParams); + } +} + +struct UpdateIslandDispatcher : public btIParallelForBody +{ + btAlignedObjectArray& m_islandsPtr; + const btSimulationIslandManagerMt::SolverParams& m_solverParams; + + UpdateIslandDispatcher(btAlignedObjectArray& islandsPtr, const btSimulationIslandManagerMt::SolverParams& solverParams) + : m_islandsPtr(islandsPtr), m_solverParams(solverParams) + { + } + + void forLoop(int iBegin, int iEnd) const BT_OVERRIDE + { + btConstraintSolver* solver = m_solverParams.m_solverPool; + for (int i = iBegin; i < iEnd; ++i) + { + btSimulationIslandManagerMt::Island* island = m_islandsPtr[i]; + btSimulationIslandManagerMt::solveIsland(solver, *island, m_solverParams); + } + } +}; + +void btSimulationIslandManagerMt::parallelIslandDispatch(btAlignedObjectArray* islandsPtr, const SolverParams& solverParams) +{ +//\1("parallelIslandDispatch"); + // + // if there are islands with many contacts, it may be faster to submit these + // large islands *serially* to a single parallel constraint solver, and then later + // submit the remaining smaller islands in parallel to multiple sequential solvers. + // + // Some task schedulers do not deal well with nested parallelFor loops. One implementation + // of OpenMP was actually slower than doing everything single-threaded. Intel TBB + // on the other hand, seems to do a pretty respectable job with it. + // + // When solving islands in parallel, the worst case performance happens when there + // is one very large island and then perhaps a smattering of very small + // islands -- one worker thread takes the large island and the remaining workers + // tear through the smaller islands and then sit idle waiting for the first worker + // to finish. Solving islands in parallel works best when there are numerous small + // islands, roughly equal in size. + // + // By contrast, the other approach -- the parallel constraint solver -- is only + // able to deliver a worthwhile speedup when the island is large. For smaller islands, + // it is difficult to extract a useful amount of parallelism -- the overhead of grouping + // the constraints into batches and sending the batches to worker threads can nullify + // any gains from parallelism. + // + + UpdateIslandDispatcher dispatcher(*islandsPtr, solverParams); + // We take advantage of the fact the islands are sorted in order of decreasing size + int iBegin = 0; + if (solverParams.m_solverMt) + { + while (iBegin < islandsPtr->size()) + { + btSimulationIslandManagerMt::Island* island = (*islandsPtr)[iBegin]; + if (island->manifoldArray.size() < btSequentialImpulseConstraintSolverMt::s_minimumContactManifoldsForBatching) + { + // OK to submit the rest of the array in parallel + break; + } + // serial dispatch to parallel solver for large islands (if any) + solveIsland(solverParams.m_solverMt, *island, solverParams); + ++iBegin; + } + } + // parallel dispatch to sequential solvers for rest + btParallelFor(iBegin, islandsPtr->size(), 1, dispatcher); +} + +///@todo: this is random access, it can be walked 'cache friendly'! +void btSimulationIslandManagerMt::buildAndProcessIslands(btDispatcher* dispatcher, + btCollisionWorld* collisionWorld, + btAlignedObjectArray& constraints, + const SolverParams& solverParams) +{ +//\1("buildAndProcessIslands"); + btCollisionObjectArray& collisionObjects = collisionWorld->getCollisionObjectArray(); + + buildIslands(dispatcher, collisionWorld); + + if (!getSplitIslands()) + { + btPersistentManifold** manifolds = dispatcher->getInternalManifoldPointer(); + int maxNumManifolds = dispatcher->getNumManifolds(); + + for (int i = 0; i < maxNumManifolds; i++) + { + btPersistentManifold* manifold = manifolds[i]; + + const btCollisionObject* colObj0 = static_cast(manifold->getBody0()); + const btCollisionObject* colObj1 = static_cast(manifold->getBody1()); + + ///@todo: check sleeping conditions! + if (((colObj0) && colObj0->getActivationState() != ISLAND_SLEEPING) || + ((colObj1) && colObj1->getActivationState() != ISLAND_SLEEPING)) + { + //kinematic objects don't merge islands, but wake up all connected objects + if (colObj0->isKinematicObject() && colObj0->getActivationState() != ISLAND_SLEEPING) + { + if (colObj0->hasContactResponse()) + colObj1->activate(); + } + if (colObj1->isKinematicObject() && colObj1->getActivationState() != ISLAND_SLEEPING) + { + if (colObj1->hasContactResponse()) + colObj0->activate(); + } + } + } + btTypedConstraint** constraintsPtr = constraints.size() ? &constraints[0] : NULL; + btConstraintSolver* solver = solverParams.m_solverMt ? solverParams.m_solverMt : solverParams.m_solverPool; + solver->solveGroup(&collisionObjects[0], + collisionObjects.size(), + manifolds, + maxNumManifolds, + constraintsPtr, + constraints.size(), + *solverParams.m_solverInfo, + solverParams.m_debugDrawer, + solverParams.m_dispatcher); + } + else + { + initIslandPools(); + + //traverse the simulation islands, and call the solver, unless all objects are sleeping/deactivated + addBodiesToIslands(collisionWorld); + addManifoldsToIslands(dispatcher); + addConstraintsToIslands(constraints); + + // m_activeIslands array should now contain all non-sleeping Islands, and each Island should + // have all the necessary bodies, manifolds and constraints. + + // if we want to merge islands with small batch counts, + if (m_minimumSolverBatchSize > 1) + { + mergeIslands(); + } + // dispatch islands to solver + m_islandDispatch(&m_activeIslands, solverParams); + } +} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp.i new file mode 100644 index 00000000..a5076e1e --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp ---------------- + +%include "BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp" + +%{ +#include "BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp" +%} diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.h b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.h new file mode 100644 index 00000000..dcc04cd8 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.h @@ -0,0 +1,112 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SIMULATION_ISLAND_MANAGER_MT_H +#define BT_SIMULATION_ISLAND_MANAGER_MT_H + +#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" + +class btTypedConstraint; +class btConstraintSolver; +struct btContactSolverInfo; +class btIDebugDraw; + +/// +/// SimulationIslandManagerMt -- Multithread capable version of SimulationIslandManager +/// Splits the world up into islands which can be solved in parallel. +/// In order to solve islands in parallel, an IslandDispatch function +/// must be provided which will dispatch calls to multiple threads. +/// The amount of parallelism that can be achieved depends on the number +/// of islands. If only a single island exists, then no parallelism is +/// possible. +/// +class btSimulationIslandManagerMt : public btSimulationIslandManager +{ +public: + struct Island + { + // a simulation island consisting of bodies, manifolds and constraints, + // to be passed into a constraint solver. + btAlignedObjectArray bodyArray; + btAlignedObjectArray manifoldArray; + btAlignedObjectArray constraintArray; + int id; // island id + bool isSleeping; + + void append(const Island& other); // add bodies, manifolds, constraints to my own + }; + struct SolverParams + { + btConstraintSolver* m_solverPool; + btConstraintSolver* m_solverMt; + btContactSolverInfo* m_solverInfo; + btIDebugDraw* m_debugDrawer; + btDispatcher* m_dispatcher; + }; + static void solveIsland(btConstraintSolver* solver, Island& island, const SolverParams& solverParams); + + typedef void (*IslandDispatchFunc)(btAlignedObjectArray* islands, const SolverParams& solverParams); + static void serialIslandDispatch(btAlignedObjectArray* islandsPtr, const SolverParams& solverParams); + static void parallelIslandDispatch(btAlignedObjectArray* islandsPtr, const SolverParams& solverParams); + +protected: + btAlignedObjectArray m_allocatedIslands; // owner of all Islands + btAlignedObjectArray m_activeIslands; // islands actively in use + btAlignedObjectArray m_freeIslands; // islands ready to be reused + btAlignedObjectArray m_lookupIslandFromId; // big lookup table to map islandId to Island pointer + Island* m_batchIsland; + int m_minimumSolverBatchSize; + int m_batchIslandMinBodyCount; + IslandDispatchFunc m_islandDispatch; + + Island* getIsland(int id); + virtual Island* allocateIsland(int id, int numBodies); + virtual void initIslandPools(); + virtual void addBodiesToIslands(btCollisionWorld* collisionWorld); + virtual void addManifoldsToIslands(btDispatcher* dispatcher); + virtual void addConstraintsToIslands(btAlignedObjectArray& constraints); + virtual void mergeIslands(); + +public: + btSimulationIslandManagerMt(); + virtual ~btSimulationIslandManagerMt(); + + virtual void buildAndProcessIslands(btDispatcher* dispatcher, + btCollisionWorld* collisionWorld, + btAlignedObjectArray& constraints, + const SolverParams& solverParams); + + virtual void buildIslands(btDispatcher* dispatcher, btCollisionWorld* colWorld); + + int getMinimumSolverBatchSize() const + { + return m_minimumSolverBatchSize; + } + void setMinimumSolverBatchSize(int sz) + { + m_minimumSolverBatchSize = sz; + } + IslandDispatchFunc getIslandDispatchFunction() const + { + return m_islandDispatch; + } + // allow users to set their own dispatch function for multithreaded dispatch + void setIslandDispatchFunction(IslandDispatchFunc func) + { + m_islandDispatch = func; + } +}; + +#endif //BT_SIMULATION_ISLAND_MANAGER_H diff --git a/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.h.i b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.h.i new file mode 100644 index 00000000..b7178e52 --- /dev/null +++ b/pkg/mphysics/mbt/BulletDynamics/Dynamics/btSimulationIslandManagerMt.h.i @@ -0,0 +1,7 @@ +////// BulletDynamics/Dynamics/btSimulationIslandManagerMt.h ---------------- + +%include "BulletDynamics/Dynamics/btSimulationIslandManagerMt.h" + +%{ +#include "BulletDynamics/Dynamics/btSimulationIslandManagerMt.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btAabbUtil2.h b/pkg/mphysics/mbt/LinearMath/btAabbUtil2.h new file mode 100644 index 00000000..67ff479c --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btAabbUtil2.h @@ -0,0 +1,217 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_AABB_UTIL2 +#define BT_AABB_UTIL2 + +#include "btTransform.h" +#include "btVector3.h" +#include "btMinMax.h" + +SIMD_FORCE_INLINE void AabbExpand(btVector3& aabbMin, + btVector3& aabbMax, + const btVector3& expansionMin, + const btVector3& expansionMax) +{ + aabbMin = aabbMin + expansionMin; + aabbMax = aabbMax + expansionMax; +} + +/// conservative test for overlap between two aabbs +SIMD_FORCE_INLINE bool TestPointAgainstAabb2(const btVector3& aabbMin1, const btVector3& aabbMax1, + const btVector3& point) +{ + bool overlap = true; + overlap = (aabbMin1.getX() > point.getX() || aabbMax1.getX() < point.getX()) ? false : overlap; + overlap = (aabbMin1.getZ() > point.getZ() || aabbMax1.getZ() < point.getZ()) ? false : overlap; + overlap = (aabbMin1.getY() > point.getY() || aabbMax1.getY() < point.getY()) ? false : overlap; + return overlap; +} + +/// conservative test for overlap between two aabbs +SIMD_FORCE_INLINE bool TestAabbAgainstAabb2(const btVector3& aabbMin1, const btVector3& aabbMax1, + const btVector3& aabbMin2, const btVector3& aabbMax2) +{ + bool overlap = true; + overlap = (aabbMin1.getX() > aabbMax2.getX() || aabbMax1.getX() < aabbMin2.getX()) ? false : overlap; + overlap = (aabbMin1.getZ() > aabbMax2.getZ() || aabbMax1.getZ() < aabbMin2.getZ()) ? false : overlap; + overlap = (aabbMin1.getY() > aabbMax2.getY() || aabbMax1.getY() < aabbMin2.getY()) ? false : overlap; + return overlap; +} + +/// conservative test for overlap between triangle and aabb +SIMD_FORCE_INLINE bool TestTriangleAgainstAabb2(const btVector3* vertices, + const btVector3& aabbMin, const btVector3& aabbMax) +{ + const btVector3& p1 = vertices[0]; + const btVector3& p2 = vertices[1]; + const btVector3& p3 = vertices[2]; + + if (btMin(btMin(p1[0], p2[0]), p3[0]) > aabbMax[0]) return false; + if (btMax(btMax(p1[0], p2[0]), p3[0]) < aabbMin[0]) return false; + + if (btMin(btMin(p1[2], p2[2]), p3[2]) > aabbMax[2]) return false; + if (btMax(btMax(p1[2], p2[2]), p3[2]) < aabbMin[2]) return false; + + if (btMin(btMin(p1[1], p2[1]), p3[1]) > aabbMax[1]) return false; + if (btMax(btMax(p1[1], p2[1]), p3[1]) < aabbMin[1]) return false; + return true; +} + +SIMD_FORCE_INLINE int btOutcode(const btVector3& p, const btVector3& halfExtent) +{ + return (p.getX() < -halfExtent.getX() ? 0x01 : 0x0) | + (p.getX() > halfExtent.getX() ? 0x08 : 0x0) | + (p.getY() < -halfExtent.getY() ? 0x02 : 0x0) | + (p.getY() > halfExtent.getY() ? 0x10 : 0x0) | + (p.getZ() < -halfExtent.getZ() ? 0x4 : 0x0) | + (p.getZ() > halfExtent.getZ() ? 0x20 : 0x0); +} + +SIMD_FORCE_INLINE bool btRayAabb2(const btVector3& rayFrom, + const btVector3& rayInvDirection, + const unsigned int raySign[3], + const btVector3 bounds[2], + btScalar& tmin, + btScalar lambda_min, + btScalar lambda_max) +{ + btScalar tmax, tymin, tymax, tzmin, tzmax; + tmin = (bounds[raySign[0]].getX() - rayFrom.getX()) * rayInvDirection.getX(); + tmax = (bounds[1 - raySign[0]].getX() - rayFrom.getX()) * rayInvDirection.getX(); + tymin = (bounds[raySign[1]].getY() - rayFrom.getY()) * rayInvDirection.getY(); + tymax = (bounds[1 - raySign[1]].getY() - rayFrom.getY()) * rayInvDirection.getY(); + + if ((tmin > tymax) || (tymin > tmax)) + return false; + + if (tymin > tmin) + tmin = tymin; + + if (tymax < tmax) + tmax = tymax; + + tzmin = (bounds[raySign[2]].getZ() - rayFrom.getZ()) * rayInvDirection.getZ(); + tzmax = (bounds[1 - raySign[2]].getZ() - rayFrom.getZ()) * rayInvDirection.getZ(); + + if ((tmin > tzmax) || (tzmin > tmax)) + return false; + if (tzmin > tmin) + tmin = tzmin; + if (tzmax < tmax) + tmax = tzmax; + return ((tmin < lambda_max) && (tmax > lambda_min)); +} + +SIMD_FORCE_INLINE bool btRayAabb(const btVector3& rayFrom, + const btVector3& rayTo, + const btVector3& aabbMin, + const btVector3& aabbMax, + btScalar& param, btVector3& normal) +{ + btVector3 aabbHalfExtent = (aabbMax - aabbMin) * btScalar(0.5); + btVector3 aabbCenter = (aabbMax + aabbMin) * btScalar(0.5); + btVector3 source = rayFrom - aabbCenter; + btVector3 target = rayTo - aabbCenter; + int sourceOutcode = btOutcode(source, aabbHalfExtent); + int targetOutcode = btOutcode(target, aabbHalfExtent); + if ((sourceOutcode & targetOutcode) == 0x0) + { + btScalar lambda_enter = btScalar(0.0); + btScalar lambda_exit = param; + btVector3 r = target - source; + int i; + btScalar normSign = 1; + btVector3 hitNormal(0, 0, 0); + int bit = 1; + + for (int j = 0; j < 2; j++) + { + for (i = 0; i != 3; ++i) + { + if (sourceOutcode & bit) + { + btScalar lambda = (-source[i] - aabbHalfExtent[i] * normSign) / r[i]; + if (lambda_enter <= lambda) + { + lambda_enter = lambda; + hitNormal.setValue(0, 0, 0); + hitNormal[i] = normSign; + } + } + else if (targetOutcode & bit) + { + btScalar lambda = (-source[i] - aabbHalfExtent[i] * normSign) / r[i]; + btSetMin(lambda_exit, lambda); + } + bit <<= 1; + } + normSign = btScalar(-1.); + } + if (lambda_enter <= lambda_exit) + { + param = lambda_enter; + normal = hitNormal; + return true; + } + } + return false; +} + +SIMD_FORCE_INLINE void btTransformAabb(const btVector3& halfExtents, btScalar margin, const btTransform& t, btVector3& aabbMinOut, btVector3& aabbMaxOut) +{ + btVector3 halfExtentsWithMargin = halfExtents + btVector3(margin, margin, margin); + btMatrix3x3 abs_b = t.getBasis().absolute(); + btVector3 center = t.getOrigin(); + btVector3 extent = halfExtentsWithMargin.dot3(abs_b[0], abs_b[1], abs_b[2]); + aabbMinOut = center - extent; + aabbMaxOut = center + extent; +} + +SIMD_FORCE_INLINE void btTransformAabb(const btVector3& localAabbMin, const btVector3& localAabbMax, btScalar margin, const btTransform& trans, btVector3& aabbMinOut, btVector3& aabbMaxOut) +{ + btAssert(localAabbMin.getX() <= localAabbMax.getX()); + btAssert(localAabbMin.getY() <= localAabbMax.getY()); + btAssert(localAabbMin.getZ() <= localAabbMax.getZ()); + btVector3 localHalfExtents = btScalar(0.5) * (localAabbMax - localAabbMin); + localHalfExtents += btVector3(margin, margin, margin); + + btVector3 localCenter = btScalar(0.5) * (localAabbMax + localAabbMin); + btMatrix3x3 abs_b = trans.getBasis().absolute(); + btVector3 center = trans(localCenter); + btVector3 extent = localHalfExtents.dot3(abs_b[0], abs_b[1], abs_b[2]); + aabbMinOut = center - extent; + aabbMaxOut = center + extent; +} + +#define USE_BANCHLESS 1 +#ifdef USE_BANCHLESS +//This block replaces the block below and uses no branches, and replaces the 8 bit return with a 32 bit return for improved performance (~3x on XBox 360) +SIMD_FORCE_INLINE unsigned testQuantizedAabbAgainstQuantizedAabb(const unsigned short int* aabbMin1, const unsigned short int* aabbMax1, const unsigned short int* aabbMin2, const unsigned short int* aabbMax2) +{ + return static_cast(btSelect((unsigned)((aabbMin1[0] <= aabbMax2[0]) & (aabbMax1[0] >= aabbMin2[0]) & (aabbMin1[2] <= aabbMax2[2]) & (aabbMax1[2] >= aabbMin2[2]) & (aabbMin1[1] <= aabbMax2[1]) & (aabbMax1[1] >= aabbMin2[1])), + 1, 0)); +} +#else +SIMD_FORCE_INLINE bool testQuantizedAabbAgainstQuantizedAabb(const unsigned short int* aabbMin1, const unsigned short int* aabbMax1, const unsigned short int* aabbMin2, const unsigned short int* aabbMax2) +{ + bool overlap = true; + overlap = (aabbMin1[0] > aabbMax2[0] || aabbMax1[0] < aabbMin2[0]) ? false : overlap; + overlap = (aabbMin1[2] > aabbMax2[2] || aabbMax1[2] < aabbMin2[2]) ? false : overlap; + overlap = (aabbMin1[1] > aabbMax2[1] || aabbMax1[1] < aabbMin2[1]) ? false : overlap; + return overlap; +} +#endif //USE_BANCHLESS + +#endif //BT_AABB_UTIL2 diff --git a/pkg/mphysics/mbt/LinearMath/btAabbUtil2.h.i b/pkg/mphysics/mbt/LinearMath/btAabbUtil2.h.i new file mode 100644 index 00000000..b2b3c2e9 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btAabbUtil2.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btAabbUtil2.h ---------------- + +%include "LinearMath/btAabbUtil2.h" + +%{ +#include "LinearMath/btAabbUtil2.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.cpp b/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.cpp new file mode 100644 index 00000000..c8f436fb --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.cpp @@ -0,0 +1,268 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btAlignedAllocator.h" +#include + +#ifdef BT_DEBUG_MEMORY_ALLOCATIONS +int gNumAlignedAllocs = 0; +int gNumAlignedFree = 0; +int gTotalBytesAlignedAllocs = 0; //detect memory leaks +#endif //BT_DEBUG_MEMORY_ALLOCATIONST_DEBUG_ALLOCATIONS + +static void *btAllocDefault(size_t size) +{ + char* data = (char*) malloc(size); + memset(data,0,size);//keep msan happy + return data; +} + +static void btFreeDefault(void *ptr) +{ + free(ptr); +} + +static btAllocFunc *sAllocFunc = btAllocDefault; +static btFreeFunc *sFreeFunc = btFreeDefault; + +#if defined(BT_HAS_ALIGNED_ALLOCATOR) +#include +static void *btAlignedAllocDefault(size_t size, int alignment) +{ + return _aligned_malloc(size, (size_t)alignment); +} + +static void btAlignedFreeDefault(void *ptr) +{ + _aligned_free(ptr); +} +#elif defined(__CELLOS_LV2__) +#include + +static inline void *btAlignedAllocDefault(size_t size, int alignment) +{ + return memalign(alignment, size); +} + +static inline void btAlignedFreeDefault(void *ptr) +{ + free(ptr); +} +#else + +static inline void *btAlignedAllocDefault(size_t size, int alignment) +{ + void *ret; + char *real; + real = (char *)sAllocFunc(size + sizeof(void *) + (alignment - 1)); + if (real) + { + ret = btAlignPointer(real + sizeof(void *), alignment); + *((void **)(ret)-1) = (void *)(real); + } + else + { + ret = (void *)(real); + } + //keep msan happy + memset((char*) ret, 0, size); + return (ret); +} + +static inline void btAlignedFreeDefault(void *ptr) +{ + void *real; + + if (ptr) + { + real = *((void **)(ptr)-1); + sFreeFunc(real); + } +} +#endif + +static btAlignedAllocFunc *sAlignedAllocFunc = btAlignedAllocDefault; +static btAlignedFreeFunc *sAlignedFreeFunc = btAlignedFreeDefault; + +void btAlignedAllocSetCustomAligned(btAlignedAllocFunc *allocFunc, btAlignedFreeFunc *freeFunc) +{ + sAlignedAllocFunc = allocFunc ? allocFunc : btAlignedAllocDefault; + sAlignedFreeFunc = freeFunc ? freeFunc : btAlignedFreeDefault; +} + +void btAlignedAllocSetCustom(btAllocFunc *allocFunc, btFreeFunc *freeFunc) +{ + sAllocFunc = allocFunc ? allocFunc : btAllocDefault; + sFreeFunc = freeFunc ? freeFunc : btFreeDefault; +} + +#ifdef BT_DEBUG_MEMORY_ALLOCATIONS + +static int allocations_id[10241024]; +static int allocations_bytes[10241024]; +static int mynumallocs = 0; +#include + +int btDumpMemoryLeaks() +{ + int totalLeak = 0; + + for (int i = 0; i < mynumallocs; i++) + { + printf("Error: leaked memory of allocation #%d (%d bytes)\n", allocations_id[i], allocations_bytes[i]); + totalLeak += allocations_bytes[i]; + } + if (totalLeak) + { + printf("Error: memory leaks: %d allocations were not freed and leaked together %d bytes\n", mynumallocs, totalLeak); + } + return totalLeak; +} +//this generic allocator provides the total allocated number of bytes +#include + +struct btDebugPtrMagic +{ + union { + void **vptrptr; + void *vptr; + int *iptr; + char *cptr; + }; +}; + +void *btAlignedAllocInternal(size_t size, int alignment, int line, const char *filename) +{ + if (size == 0) + { + printf("Whaat? size==0"); + return 0; + } + static int allocId = 0; + + void *ret; + char *real; + + // to find some particular memory leak, you could do something like this: + // if (allocId==172) + // { + // printf("catch me!\n"); + // } + // if (size>1024*1024) + // { + // printf("big alloc!%d\n", size); + // } + + gTotalBytesAlignedAllocs += size; + gNumAlignedAllocs++; + + int sz4prt = 4 * sizeof(void *); + + real = (char *)sAllocFunc(size + sz4prt + (alignment - 1)); + if (real) + { + ret = (void *)btAlignPointer(real + sz4prt, alignment); + btDebugPtrMagic p; + p.vptr = ret; + p.cptr -= sizeof(void *); + *p.vptrptr = (void *)real; + p.cptr -= sizeof(void *); + *p.iptr = size; + p.cptr -= sizeof(void *); + *p.iptr = allocId; + + allocations_id[mynumallocs] = allocId; + allocations_bytes[mynumallocs] = size; + mynumallocs++; + } + else + { + ret = (void *)(real); //?? + } + + printf("allocation %d at address %x, from %s,line %d, size %d (total allocated = %d)\n", allocId, real, filename, line, size, gTotalBytesAlignedAllocs); + allocId++; + + int *ptr = (int *)ret; + *ptr = 12; + return (ret); +} + +void btAlignedFreeInternal(void *ptr, int line, const char *filename) +{ + void *real; + + if (ptr) + { + gNumAlignedFree++; + + btDebugPtrMagic p; + p.vptr = ptr; + p.cptr -= sizeof(void *); + real = *p.vptrptr; + p.cptr -= sizeof(void *); + int size = *p.iptr; + p.cptr -= sizeof(void *); + int allocId = *p.iptr; + + bool found = false; + + for (int i = 0; i < mynumallocs; i++) + { + if (allocations_id[i] == allocId) + { + allocations_id[i] = allocations_id[mynumallocs - 1]; + allocations_bytes[i] = allocations_bytes[mynumallocs - 1]; + mynumallocs--; + found = true; + break; + } + } + + gTotalBytesAlignedAllocs -= size; + + int diff = gNumAlignedAllocs - gNumAlignedFree; + printf("free %d at address %x, from %s,line %d, size %d (total remain = %d in %d non-freed allocations)\n", allocId, real, filename, line, size, gTotalBytesAlignedAllocs, diff); + + sFreeFunc(real); + } + else + { + //printf("deleting a NULL ptr, no effect\n"); + } +} + +#else //BT_DEBUG_MEMORY_ALLOCATIONS + +void *btAlignedAllocInternal(size_t size, int alignment) +{ + void *ptr; + ptr = sAlignedAllocFunc(size, alignment); + // printf("btAlignedAllocInternal %d, %x\n",size,ptr); + return ptr; +} + +void btAlignedFreeInternal(void *ptr) +{ + if (!ptr) + { + return; + } + + // printf("btAlignedFreeInternal %x\n",ptr); + sAlignedFreeFunc(ptr); +} + +#endif //BT_DEBUG_MEMORY_ALLOCATIONS diff --git a/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.cpp.i b/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.cpp.i new file mode 100644 index 00000000..4f09c0fc --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btAlignedAllocator.cpp ---------------- + +%include "LinearMath/btAlignedAllocator.cpp" + +%{ +#include "LinearMath/btAlignedAllocator.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.h b/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.h new file mode 100644 index 00000000..f6bbcdbb --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.h @@ -0,0 +1,115 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_ALIGNED_ALLOCATOR +#define BT_ALIGNED_ALLOCATOR + +///we probably replace this with our own aligned memory allocator +///so we replace _aligned_malloc and _aligned_free with our own +///that is better portable and more predictable + +#include "btScalar.h" + +///BT_DEBUG_MEMORY_ALLOCATIONS preprocessor can be set in build system +///for regression tests to detect memory leaks +///#define BT_DEBUG_MEMORY_ALLOCATIONS 1 +#ifdef BT_DEBUG_MEMORY_ALLOCATIONS + +int btDumpMemoryLeaks(); + +#define btAlignedAlloc(a, b) \ + btAlignedAllocInternal(a, b, __LINE__, __FILE__) + +#define btAlignedFree(ptr) \ + btAlignedFreeInternal(ptr, __LINE__, __FILE__) + +void* btAlignedAllocInternal(size_t size, int alignment, int line, const char* filename); + +void btAlignedFreeInternal(void* ptr, int line, const char* filename); + +#else +void* btAlignedAllocInternal(size_t size, int alignment); +void btAlignedFreeInternal(void* ptr); + +#define btAlignedAlloc(size, alignment) btAlignedAllocInternal(size, alignment) +#define btAlignedFree(ptr) btAlignedFreeInternal(ptr) + +#endif +typedef int size_type; + +typedef void*(btAlignedAllocFunc)(size_t size, int alignment); +typedef void(btAlignedFreeFunc)(void* memblock); +typedef void*(btAllocFunc)(size_t size); +typedef void(btFreeFunc)(void* memblock); + +///The developer can let all Bullet memory allocations go through a custom memory allocator, using btAlignedAllocSetCustom +void btAlignedAllocSetCustom(btAllocFunc* allocFunc, btFreeFunc* freeFunc); +///If the developer has already an custom aligned allocator, then btAlignedAllocSetCustomAligned can be used. The default aligned allocator pre-allocates extra memory using the non-aligned allocator, and instruments it. +void btAlignedAllocSetCustomAligned(btAlignedAllocFunc* allocFunc, btAlignedFreeFunc* freeFunc); + +///The btAlignedAllocator is a portable class for aligned memory allocations. +///Default implementations for unaligned and aligned allocations can be overridden by a custom allocator using btAlignedAllocSetCustom and btAlignedAllocSetCustomAligned. +template +class btAlignedAllocator +{ + typedef btAlignedAllocator self_type; + +public: + //just going down a list: + btAlignedAllocator() {} + /* + btAlignedAllocator( const self_type & ) {} + */ + + template + btAlignedAllocator(const btAlignedAllocator&) + { + } + + typedef const T* const_pointer; + typedef const T& const_reference; + typedef T* pointer; + typedef T& reference; + typedef T value_type; + + pointer address(reference ref) const { return &ref; } + const_pointer address(const_reference ref) const { return &ref; } + pointer allocate(size_type n, const_pointer* hint = 0) + { + (void)hint; + return reinterpret_cast(btAlignedAlloc(sizeof(value_type) * n, Alignment)); + } + void construct(pointer ptr, const value_type& value) { new (ptr) value_type(value); } + void deallocate(pointer ptr) + { + btAlignedFree(reinterpret_cast(ptr)); + } + void destroy(pointer ptr) { ptr->~value_type(); } + + template + struct rebind + { + typedef btAlignedAllocator other; + }; + template + self_type& operator=(const btAlignedAllocator&) + { + return *this; + } + + friend bool operator==(const self_type&, const self_type&) { return true; } +}; + +#endif //BT_ALIGNED_ALLOCATOR diff --git a/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.h.i b/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.h.i new file mode 100644 index 00000000..e6ab675d --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btAlignedAllocator.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btAlignedAllocator.h ---------------- + +%include "LinearMath/btAlignedAllocator.h" + +%{ +#include "LinearMath/btAlignedAllocator.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btAlignedObjectArray.h b/pkg/mphysics/mbt/LinearMath/btAlignedObjectArray.h new file mode 100644 index 00000000..ac3e189e --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btAlignedObjectArray.h @@ -0,0 +1,504 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_OBJECT_ARRAY__ +#define BT_OBJECT_ARRAY__ + +#include "btScalar.h" // has definitions like SIMD_FORCE_INLINE +#include "btAlignedAllocator.h" + +///If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW +///then the btAlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors +///You can enable BT_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= +///see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and +///http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 + +#define BT_USE_PLACEMENT_NEW 1 +//#define BT_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +#define BT_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +#ifdef BT_USE_MEMCPY +#include +#include +#endif //BT_USE_MEMCPY + +#ifdef BT_USE_PLACEMENT_NEW +#include //for placement new +#endif //BT_USE_PLACEMENT_NEW + +///The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods +///It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data +template +//template +class btAlignedObjectArray +{ + btAlignedAllocator m_allocator; + + int m_size; + int m_capacity; + T* m_data; + //PCK: added this line + bool m_ownsMemory; + +#ifdef BT_ALLOW_ARRAY_COPY_OPERATOR +public: + SIMD_FORCE_INLINE btAlignedObjectArray& operator=(const btAlignedObjectArray& other) + { + copyFromArray(other); + return *this; + } +#else //BT_ALLOW_ARRAY_COPY_OPERATOR +private: + SIMD_FORCE_INLINE btAlignedObjectArray& operator=(const btAlignedObjectArray& other); +#endif //BT_ALLOW_ARRAY_COPY_OPERATOR + +protected: + SIMD_FORCE_INLINE int allocSize(int size) + { + return (size ? size * 2 : 1); + } + SIMD_FORCE_INLINE void copy(int start, int end, T* dest) const + { + int i; + for (i = start; i < end; ++i) +#ifdef BT_USE_PLACEMENT_NEW + new (&dest[i]) T(m_data[i]); +#else + dest[i] = m_data[i]; +#endif //BT_USE_PLACEMENT_NEW + } + + SIMD_FORCE_INLINE void init() + { + //PCK: added this line + m_ownsMemory = true; + m_data = 0; + m_size = 0; + m_capacity = 0; + } + SIMD_FORCE_INLINE void destroy(int first, int last) + { + int i; + for (i = first; i < last; i++) + { + m_data[i].~T(); + } + } + + SIMD_FORCE_INLINE void* allocate(int size) + { + if (size) + return m_allocator.allocate(size); + return 0; + } + + SIMD_FORCE_INLINE void deallocate() + { + if (m_data) + { + //PCK: enclosed the deallocation in this block + if (m_ownsMemory) + { + m_allocator.deallocate(m_data); + } + m_data = 0; + } + } + +public: + btAlignedObjectArray() + { + init(); + } + + ~btAlignedObjectArray() + { + clear(); + } + + ///Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. + btAlignedObjectArray(const btAlignedObjectArray& otherArray) + { + init(); + + int otherSize = otherArray.size(); + resize(otherSize); + otherArray.copy(0, otherSize, m_data); + } + + /// return the number of elements in the array + SIMD_FORCE_INLINE int size() const + { + return m_size; + } + + SIMD_FORCE_INLINE const T& at(int n) const + { + btAssert(n >= 0); + btAssert(n < size()); + return m_data[n]; + } + + SIMD_FORCE_INLINE T& at(int n) + { + btAssert(n >= 0); + btAssert(n < size()); + return m_data[n]; + } + + SIMD_FORCE_INLINE const T& operator[](int n) const + { + btAssert(n >= 0); + btAssert(n < size()); + return m_data[n]; + } + + SIMD_FORCE_INLINE T& operator[](int n) + { + btAssert(n >= 0); + btAssert(n < size()); + return m_data[n]; + } + + ///clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. + SIMD_FORCE_INLINE void clear() + { + destroy(0, size()); + + deallocate(); + + init(); + } + + SIMD_FORCE_INLINE void pop_back() + { + btAssert(m_size > 0); + m_size--; + m_data[m_size].~T(); + } + + ///resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + ///when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. + SIMD_FORCE_INLINE void resizeNoInitialize(int newsize) + { + if (newsize > size()) + { + reserve(newsize); + } + m_size = newsize; + } + + SIMD_FORCE_INLINE void resize(int newsize, const T& fillData = T()) + { + const int curSize = size(); + + if (newsize < curSize) + { + for (int i = newsize; i < curSize; i++) + { + m_data[i].~T(); + } + } + else + { + if (newsize > curSize) + { + reserve(newsize); + } +#ifdef BT_USE_PLACEMENT_NEW + for (int i = curSize; i < newsize; i++) + { + new (&m_data[i]) T(fillData); + } +#endif //BT_USE_PLACEMENT_NEW + } + + m_size = newsize; + } + SIMD_FORCE_INLINE T& expandNonInitializing() + { + const int sz = size(); + if (sz == capacity()) + { + reserve(allocSize(size())); + } + m_size++; + + return m_data[sz]; + } + + SIMD_FORCE_INLINE T& expand(const T& fillValue = T()) + { + const int sz = size(); + if (sz == capacity()) + { + reserve(allocSize(size())); + } + m_size++; +#ifdef BT_USE_PLACEMENT_NEW + new (&m_data[sz]) T(fillValue); //use the in-place new (not really allocating heap memory) +#endif + + return m_data[sz]; + } + + SIMD_FORCE_INLINE void push_back(const T& _Val) + { + const int sz = size(); + if (sz == capacity()) + { + reserve(allocSize(size())); + } + +#ifdef BT_USE_PLACEMENT_NEW + new (&m_data[m_size]) T(_Val); +#else + m_data[size()] = _Val; +#endif //BT_USE_PLACEMENT_NEW + + m_size++; + } + + /// return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() + SIMD_FORCE_INLINE int capacity() const + { + return m_capacity; + } + + SIMD_FORCE_INLINE void reserve(int _Count) + { // determine new minimum length of allocated storage + if (capacity() < _Count) + { // not enough room, reallocate + T* s = (T*)allocate(_Count); + + copy(0, size(), s); + + destroy(0, size()); + + deallocate(); + + //PCK: added this line + m_ownsMemory = true; + + m_data = s; + + m_capacity = _Count; + } + } + + class less + { + public: + bool operator()(const T& a, const T& b) const + { + return (a < b); + } + }; + + template + void quickSortInternal(const L& CompareFunc, int lo, int hi) + { + // lo is the lower index, hi is the upper index + // of the region of array a that is to be sorted + int i = lo, j = hi; + T x = m_data[(lo + hi) / 2]; + + // partition + do + { + while (CompareFunc(m_data[i], x)) + i++; + while (CompareFunc(x, m_data[j])) + j--; + if (i <= j) + { + swap(i, j); + i++; + j--; + } + } while (i <= j); + + // recursion + if (lo < j) + quickSortInternal(CompareFunc, lo, j); + if (i < hi) + quickSortInternal(CompareFunc, i, hi); + } + + template + void quickSort(const L& CompareFunc) + { + //don't sort 0 or 1 elements + if (size() > 1) + { + quickSortInternal(CompareFunc, 0, size() - 1); + } + } + + ///heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ + template + void downHeap(T* pArr, int k, int n, const L& CompareFunc) + { + /* PRE: a[k+1..N] is a heap */ + /* POST: a[k..N] is a heap */ + + T temp = pArr[k - 1]; + /* k has child(s) */ + while (k <= n / 2) + { + int child = 2 * k; + + if ((child < n) && CompareFunc(pArr[child - 1], pArr[child])) + { + child++; + } + /* pick larger child */ + if (CompareFunc(temp, pArr[child - 1])) + { + /* move child up */ + pArr[k - 1] = pArr[child - 1]; + k = child; + } + else + { + break; + } + } + pArr[k - 1] = temp; + } /*downHeap*/ + + void swap(int index0, int index1) + { +#ifdef BT_USE_MEMCPY + char temp[sizeof(T)]; + memcpy(temp, &m_data[index0], sizeof(T)); + memcpy(&m_data[index0], &m_data[index1], sizeof(T)); + memcpy(&m_data[index1], temp, sizeof(T)); +#else + T temp = m_data[index0]; + m_data[index0] = m_data[index1]; + m_data[index1] = temp; +#endif //BT_USE_PLACEMENT_NEW + } + + template + void heapSort(const L& CompareFunc) + { + /* sort a[0..N-1], N.B. 0 to N-1 */ + int k; + int n = m_size; + for (k = n / 2; k > 0; k--) + { + downHeap(m_data, k, n, CompareFunc); + } + + /* a[1..N] is now a heap */ + while (n >= 1) + { + swap(0, n - 1); /* largest of a[0..n-1] */ + + n = n - 1; + /* restore a[1..i-1] heap */ + downHeap(m_data, 1, n, CompareFunc); + } + } + + ///non-recursive binary search, assumes sorted array + int findBinarySearch(const T& key) const + { + int first = 0; + int last = size() - 1; + + //assume sorted array + while (first <= last) + { + int mid = (first + last) / 2; // compute mid point. + if (key > m_data[mid]) + first = mid + 1; // repeat search in top half. + else if (key < m_data[mid]) + last = mid - 1; // repeat search in bottom half. + else + return mid; // found it. return position ///// + } + return size(); // failed to find key + } + + int findLinearSearch(const T& key) const + { + int index = size(); + int i; + + for (i = 0; i < size(); i++) + { + if (m_data[i] == key) + { + index = i; + break; + } + } + return index; + } + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + int findLinearSearch2(const T& key) const + { + int index = -1; + int i; + + for (i = 0; i < size(); i++) + { + if (m_data[i] == key) + { + index = i; + break; + } + } + return index; + } + + void removeAtIndex(int index) + { + if (index < size()) + { + swap(index, size() - 1); + pop_back(); + } + } + void remove(const T& key) + { + int findIndex = findLinearSearch(key); + removeAtIndex(findIndex); + } + + //PCK: whole function + void initializeFromBuffer(void* buffer, int size, int capacity) + { + clear(); + m_ownsMemory = false; + m_data = (T*)buffer; + m_size = size; + m_capacity = capacity; + } + + void copyFromArray(const btAlignedObjectArray& otherArray) + { + int otherSize = otherArray.size(); + resize(otherSize); + otherArray.copy(0, otherSize, m_data); + } +}; + +#endif //BT_OBJECT_ARRAY__ diff --git a/pkg/mphysics/mbt/LinearMath/btAlignedObjectArray.h.i b/pkg/mphysics/mbt/LinearMath/btAlignedObjectArray.h.i new file mode 100644 index 00000000..443cd426 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btAlignedObjectArray.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btAlignedObjectArray.h ---------------- + +%include "LinearMath/btAlignedObjectArray.h" + +%{ +#include "LinearMath/btAlignedObjectArray.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btConvexHull.cpp b/pkg/mphysics/mbt/LinearMath/btConvexHull.cpp new file mode 100644 index 00000000..94b68baf --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btConvexHull.cpp @@ -0,0 +1,1122 @@ +/* +Stan Melax Convex Hull Computation +Copyright (c) 2003-2006 Stan Melax http://www.melax.com/ + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include + +#include "btConvexHull.h" +#include "btAlignedObjectArray.h" +#include "btMinMax.h" +#include "btVector3.h" + +//---------------------------------- + +class int3 +{ +public: + int x, y, z; + int3(){}; + int3(int _x, int _y, int _z) + { + x = _x; + y = _y; + z = _z; + } + const int &operator[](int i) const { return (&x)[i]; } + int &operator[](int i) { return (&x)[i]; } +}; + +//------- btPlane ---------- + +inline btPlane PlaneFlip(const btPlane &plane) { return btPlane(-plane.normal, -plane.dist); } +inline int operator==(const btPlane &a, const btPlane &b) { return (a.normal == b.normal && a.dist == b.dist); } +inline int coplanar(const btPlane &a, const btPlane &b) { return (a == b || a == PlaneFlip(b)); } + +//--------- Utility Functions ------ + +btVector3 PlaneLineIntersection(const btPlane &plane, const btVector3 &p0, const btVector3 &p1); +btVector3 PlaneProject(const btPlane &plane, const btVector3 &point); + +btVector3 ThreePlaneIntersection(const btPlane &p0, const btPlane &p1, const btPlane &p2); +btVector3 ThreePlaneIntersection(const btPlane &p0, const btPlane &p1, const btPlane &p2) +{ + btVector3 N1 = p0.normal; + btVector3 N2 = p1.normal; + btVector3 N3 = p2.normal; + + btVector3 n2n3; + n2n3 = N2.cross(N3); + btVector3 n3n1; + n3n1 = N3.cross(N1); + btVector3 n1n2; + n1n2 = N1.cross(N2); + + btScalar quotient = (N1.dot(n2n3)); + + btAssert(btFabs(quotient) > btScalar(0.000001)); + + quotient = btScalar(-1.) / quotient; + n2n3 *= p0.dist; + n3n1 *= p1.dist; + n1n2 *= p2.dist; + btVector3 potentialVertex = n2n3; + potentialVertex += n3n1; + potentialVertex += n1n2; + potentialVertex *= quotient; + + btVector3 result(potentialVertex.getX(), potentialVertex.getY(), potentialVertex.getZ()); + return result; +} + +btScalar DistanceBetweenLines(const btVector3 &ustart, const btVector3 &udir, const btVector3 &vstart, const btVector3 &vdir, btVector3 *upoint = NULL, btVector3 *vpoint = NULL); +btVector3 TriNormal(const btVector3 &v0, const btVector3 &v1, const btVector3 &v2); +btVector3 NormalOf(const btVector3 *vert, const int n); + +btVector3 PlaneLineIntersection(const btPlane &plane, const btVector3 &p0, const btVector3 &p1) +{ + // returns the point where the line p0-p1 intersects the plane n&d + btVector3 dif; + dif = p1 - p0; + btScalar dn = btDot(plane.normal, dif); + btScalar t = -(plane.dist + btDot(plane.normal, p0)) / dn; + return p0 + (dif * t); +} + +btVector3 PlaneProject(const btPlane &plane, const btVector3 &point) +{ + return point - plane.normal * (btDot(point, plane.normal) + plane.dist); +} + +btVector3 TriNormal(const btVector3 &v0, const btVector3 &v1, const btVector3 &v2) +{ + // return the normal of the triangle + // inscribed by v0, v1, and v2 + btVector3 cp = btCross(v1 - v0, v2 - v1); + btScalar m = cp.length(); + if (m == 0) return btVector3(1, 0, 0); + return cp * (btScalar(1.0) / m); +} + +btScalar DistanceBetweenLines(const btVector3 &ustart, const btVector3 &udir, const btVector3 &vstart, const btVector3 &vdir, btVector3 *upoint, btVector3 *vpoint) +{ + btVector3 cp; + cp = btCross(udir, vdir).normalized(); + + btScalar distu = -btDot(cp, ustart); + btScalar distv = -btDot(cp, vstart); + btScalar dist = (btScalar)fabs(distu - distv); + if (upoint) + { + btPlane plane; + plane.normal = btCross(vdir, cp).normalized(); + plane.dist = -btDot(plane.normal, vstart); + *upoint = PlaneLineIntersection(plane, ustart, ustart + udir); + } + if (vpoint) + { + btPlane plane; + plane.normal = btCross(udir, cp).normalized(); + plane.dist = -btDot(plane.normal, ustart); + *vpoint = PlaneLineIntersection(plane, vstart, vstart + vdir); + } + return dist; +} + +#define COPLANAR (0) +#define UNDER (1) +#define OVER (2) +#define SPLIT (OVER | UNDER) +#define PAPERWIDTH (btScalar(0.001)) + +btScalar planetestepsilon = PAPERWIDTH; + +typedef ConvexH::HalfEdge HalfEdge; + +ConvexH::ConvexH(int vertices_size, int edges_size, int facets_size) +{ + vertices.resize(vertices_size); + edges.resize(edges_size); + facets.resize(facets_size); +} + +int PlaneTest(const btPlane &p, const btVector3 &v); +int PlaneTest(const btPlane &p, const btVector3 &v) +{ + btScalar a = btDot(v, p.normal) + p.dist; + int flag = (a > planetestepsilon) ? OVER : ((a < -planetestepsilon) ? UNDER : COPLANAR); + return flag; +} + +int SplitTest(ConvexH &convex, const btPlane &plane); +int SplitTest(ConvexH &convex, const btPlane &plane) +{ + int flag = 0; + for (int i = 0; i < convex.vertices.size(); i++) + { + flag |= PlaneTest(plane, convex.vertices[i]); + } + return flag; +} + +class VertFlag +{ +public: + unsigned char planetest; + unsigned char junk; + unsigned char undermap; + unsigned char overmap; +}; +class EdgeFlag +{ +public: + unsigned char planetest; + unsigned char fixes; + short undermap; + short overmap; +}; +class PlaneFlag +{ +public: + unsigned char undermap; + unsigned char overmap; +}; +class Coplanar +{ +public: + unsigned short ea; + unsigned char v0; + unsigned char v1; +}; + +template +int maxdirfiltered(const T *p, int count, const T &dir, btAlignedObjectArray &allow) +{ + btAssert(count); + int m = -1; + for (int i = 0; i < count; i++) + if (allow[i]) + { + if (m == -1 || btDot(p[i], dir) > btDot(p[m], dir)) + m = i; + } + btAssert(m != -1); + return m; +} + +btVector3 orth(const btVector3 &v); +btVector3 orth(const btVector3 &v) +{ + btVector3 a = btCross(v, btVector3(0, 0, 1)); + btVector3 b = btCross(v, btVector3(0, 1, 0)); + if (a.length() > b.length()) + { + return a.normalized(); + } + else + { + return b.normalized(); + } +} + +template +int maxdirsterid(const T *p, int count, const T &dir, btAlignedObjectArray &allow) +{ + int m = -1; + while (m == -1) + { + m = maxdirfiltered(p, count, dir, allow); + if (allow[m] == 3) return m; + T u = orth(dir); + T v = btCross(u, dir); + int ma = -1; + for (btScalar x = btScalar(0.0); x <= btScalar(360.0); x += btScalar(45.0)) + { + btScalar s = btSin(SIMD_RADS_PER_DEG * (x)); + btScalar c = btCos(SIMD_RADS_PER_DEG * (x)); + int mb = maxdirfiltered(p, count, dir + (u * s + v * c) * btScalar(0.025), allow); + if (ma == m && mb == m) + { + allow[m] = 3; + return m; + } + if (ma != -1 && ma != mb) // Yuck - this is really ugly + { + int mc = ma; + for (btScalar xx = x - btScalar(40.0); xx <= x; xx += btScalar(5.0)) + { + btScalar s = btSin(SIMD_RADS_PER_DEG * (xx)); + btScalar c = btCos(SIMD_RADS_PER_DEG * (xx)); + int md = maxdirfiltered(p, count, dir + (u * s + v * c) * btScalar(0.025), allow); + if (mc == m && md == m) + { + allow[m] = 3; + return m; + } + mc = md; + } + } + ma = mb; + } + allow[m] = 0; + m = -1; + } + btAssert(0); + return m; +} + +int operator==(const int3 &a, const int3 &b); +int operator==(const int3 &a, const int3 &b) +{ + for (int i = 0; i < 3; i++) + { + if (a[i] != b[i]) return 0; + } + return 1; +} + +int above(btVector3 *vertices, const int3 &t, const btVector3 &p, btScalar epsilon); +int above(btVector3 *vertices, const int3 &t, const btVector3 &p, btScalar epsilon) +{ + btVector3 n = TriNormal(vertices[t[0]], vertices[t[1]], vertices[t[2]]); + return (btDot(n, p - vertices[t[0]]) > epsilon); // EPSILON??? +} +int hasedge(const int3 &t, int a, int b); +int hasedge(const int3 &t, int a, int b) +{ + for (int i = 0; i < 3; i++) + { + int i1 = (i + 1) % 3; + if (t[i] == a && t[i1] == b) return 1; + } + return 0; +} +int hasvert(const int3 &t, int v); +int hasvert(const int3 &t, int v) +{ + return (t[0] == v || t[1] == v || t[2] == v); +} +int shareedge(const int3 &a, const int3 &b); +int shareedge(const int3 &a, const int3 &b) +{ + int i; + for (i = 0; i < 3; i++) + { + int i1 = (i + 1) % 3; + if (hasedge(a, b[i1], b[i])) return 1; + } + return 0; +} + +class btHullTriangle; + +class btHullTriangle : public int3 +{ +public: + int3 n; + int id; + int vmax; + btScalar rise; + btHullTriangle(int a, int b, int c) : int3(a, b, c), n(-1, -1, -1) + { + vmax = -1; + rise = btScalar(0.0); + } + ~btHullTriangle() + { + } + int &neib(int a, int b); +}; + +int &btHullTriangle::neib(int a, int b) +{ + static int er = -1; + int i; + for (i = 0; i < 3; i++) + { + int i1 = (i + 1) % 3; + int i2 = (i + 2) % 3; + if ((*this)[i] == a && (*this)[i1] == b) return n[i2]; + if ((*this)[i] == b && (*this)[i1] == a) return n[i2]; + } + btAssert(0); + return er; +} +void HullLibrary::b2bfix(btHullTriangle *s, btHullTriangle *t) +{ + int i; + for (i = 0; i < 3; i++) + { + int i1 = (i + 1) % 3; + int i2 = (i + 2) % 3; + int a = (*s)[i1]; + int b = (*s)[i2]; + btAssert(m_tris[s->neib(a, b)]->neib(b, a) == s->id); + btAssert(m_tris[t->neib(a, b)]->neib(b, a) == t->id); + m_tris[s->neib(a, b)]->neib(b, a) = t->neib(b, a); + m_tris[t->neib(b, a)]->neib(a, b) = s->neib(a, b); + } +} + +void HullLibrary::removeb2b(btHullTriangle *s, btHullTriangle *t) +{ + b2bfix(s, t); + deAllocateTriangle(s); + + deAllocateTriangle(t); +} + +void HullLibrary::checkit(btHullTriangle *t) +{ + (void)t; + + int i; + btAssert(m_tris[t->id] == t); + for (i = 0; i < 3; i++) + { + int i1 = (i + 1) % 3; + int i2 = (i + 2) % 3; + int a = (*t)[i1]; + int b = (*t)[i2]; + + // release compile fix + (void)i1; + (void)i2; + (void)a; + (void)b; + + btAssert(a != b); + btAssert(m_tris[t->n[i]]->neib(b, a) == t->id); + } +} + +btHullTriangle *HullLibrary::allocateTriangle(int a, int b, int c) +{ + void *mem = btAlignedAlloc(sizeof(btHullTriangle), 16); + btHullTriangle *tr = new (mem) btHullTriangle(a, b, c); + tr->id = m_tris.size(); + m_tris.push_back(tr); + + return tr; +} + +void HullLibrary::deAllocateTriangle(btHullTriangle *tri) +{ + btAssert(m_tris[tri->id] == tri); + m_tris[tri->id] = NULL; + tri->~btHullTriangle(); + btAlignedFree(tri); +} + +void HullLibrary::extrude(btHullTriangle *t0, int v) +{ + int3 t = *t0; + int n = m_tris.size(); + btHullTriangle *ta = allocateTriangle(v, t[1], t[2]); + ta->n = int3(t0->n[0], n + 1, n + 2); + m_tris[t0->n[0]]->neib(t[1], t[2]) = n + 0; + btHullTriangle *tb = allocateTriangle(v, t[2], t[0]); + tb->n = int3(t0->n[1], n + 2, n + 0); + m_tris[t0->n[1]]->neib(t[2], t[0]) = n + 1; + btHullTriangle *tc = allocateTriangle(v, t[0], t[1]); + tc->n = int3(t0->n[2], n + 0, n + 1); + m_tris[t0->n[2]]->neib(t[0], t[1]) = n + 2; + checkit(ta); + checkit(tb); + checkit(tc); + if (hasvert(*m_tris[ta->n[0]], v)) removeb2b(ta, m_tris[ta->n[0]]); + if (hasvert(*m_tris[tb->n[0]], v)) removeb2b(tb, m_tris[tb->n[0]]); + if (hasvert(*m_tris[tc->n[0]], v)) removeb2b(tc, m_tris[tc->n[0]]); + deAllocateTriangle(t0); +} + +btHullTriangle *HullLibrary::extrudable(btScalar epsilon) +{ + int i; + btHullTriangle *t = NULL; + for (i = 0; i < m_tris.size(); i++) + { + if (!t || (m_tris[i] && t->rise < m_tris[i]->rise)) + { + t = m_tris[i]; + } + } + return (t->rise > epsilon) ? t : NULL; +} + +int4 HullLibrary::FindSimplex(btVector3 *verts, int verts_count, btAlignedObjectArray &allow) +{ + btVector3 basis[3]; + basis[0] = btVector3(btScalar(0.01), btScalar(0.02), btScalar(1.0)); + int p0 = maxdirsterid(verts, verts_count, basis[0], allow); + int p1 = maxdirsterid(verts, verts_count, -basis[0], allow); + basis[0] = verts[p0] - verts[p1]; + if (p0 == p1 || basis[0] == btVector3(0, 0, 0)) + return int4(-1, -1, -1, -1); + basis[1] = btCross(btVector3(btScalar(1), btScalar(0.02), btScalar(0)), basis[0]); + basis[2] = btCross(btVector3(btScalar(-0.02), btScalar(1), btScalar(0)), basis[0]); + if (basis[1].length() > basis[2].length()) + { + basis[1].normalize(); + } + else + { + basis[1] = basis[2]; + basis[1].normalize(); + } + int p2 = maxdirsterid(verts, verts_count, basis[1], allow); + if (p2 == p0 || p2 == p1) + { + p2 = maxdirsterid(verts, verts_count, -basis[1], allow); + } + if (p2 == p0 || p2 == p1) + return int4(-1, -1, -1, -1); + basis[1] = verts[p2] - verts[p0]; + basis[2] = btCross(basis[1], basis[0]).normalized(); + int p3 = maxdirsterid(verts, verts_count, basis[2], allow); + if (p3 == p0 || p3 == p1 || p3 == p2) p3 = maxdirsterid(verts, verts_count, -basis[2], allow); + if (p3 == p0 || p3 == p1 || p3 == p2) + return int4(-1, -1, -1, -1); + btAssert(!(p0 == p1 || p0 == p2 || p0 == p3 || p1 == p2 || p1 == p3 || p2 == p3)); + if (btDot(verts[p3] - verts[p0], btCross(verts[p1] - verts[p0], verts[p2] - verts[p0])) < 0) + { + btSwap(p2, p3); + } + return int4(p0, p1, p2, p3); +} + +int HullLibrary::calchullgen(btVector3 *verts, int verts_count, int vlimit) +{ + if (verts_count < 4) return 0; + if (vlimit == 0) vlimit = 1000000000; + int j; + btVector3 bmin(*verts), bmax(*verts); + btAlignedObjectArray isextreme; + isextreme.reserve(verts_count); + btAlignedObjectArray allow; + allow.reserve(verts_count); + + for (j = 0; j < verts_count; j++) + { + allow.push_back(1); + isextreme.push_back(0); + bmin.setMin(verts[j]); + bmax.setMax(verts[j]); + } + btScalar epsilon = (bmax - bmin).length() * btScalar(0.001); + btAssert(epsilon != 0.0); + + int4 p = FindSimplex(verts, verts_count, allow); + if (p.x == -1) return 0; // simplex failed + + btVector3 center = (verts[p[0]] + verts[p[1]] + verts[p[2]] + verts[p[3]]) / btScalar(4.0); // a valid interior point + btHullTriangle *t0 = allocateTriangle(p[2], p[3], p[1]); + t0->n = int3(2, 3, 1); + btHullTriangle *t1 = allocateTriangle(p[3], p[2], p[0]); + t1->n = int3(3, 2, 0); + btHullTriangle *t2 = allocateTriangle(p[0], p[1], p[3]); + t2->n = int3(0, 1, 3); + btHullTriangle *t3 = allocateTriangle(p[1], p[0], p[2]); + t3->n = int3(1, 0, 2); + isextreme[p[0]] = isextreme[p[1]] = isextreme[p[2]] = isextreme[p[3]] = 1; + checkit(t0); + checkit(t1); + checkit(t2); + checkit(t3); + + for (j = 0; j < m_tris.size(); j++) + { + btHullTriangle *t = m_tris[j]; + btAssert(t); + btAssert(t->vmax < 0); + btVector3 n = TriNormal(verts[(*t)[0]], verts[(*t)[1]], verts[(*t)[2]]); + t->vmax = maxdirsterid(verts, verts_count, n, allow); + t->rise = btDot(n, verts[t->vmax] - verts[(*t)[0]]); + } + btHullTriangle *te; + vlimit -= 4; + while (vlimit > 0 && ((te = extrudable(epsilon)) != 0)) + { + //int3 ti=*te; + int v = te->vmax; + btAssert(v != -1); + btAssert(!isextreme[v]); // wtf we've already done this vertex + isextreme[v] = 1; + //if(v==p0 || v==p1 || v==p2 || v==p3) continue; // done these already + j = m_tris.size(); + while (j--) + { + if (!m_tris[j]) continue; + int3 t = *m_tris[j]; + if (above(verts, t, verts[v], btScalar(0.01) * epsilon)) + { + extrude(m_tris[j], v); + } + } + // now check for those degenerate cases where we have a flipped triangle or a really skinny triangle + j = m_tris.size(); + while (j--) + { + if (!m_tris[j]) continue; + if (!hasvert(*m_tris[j], v)) break; + int3 nt = *m_tris[j]; + if (above(verts, nt, center, btScalar(0.01) * epsilon) || btCross(verts[nt[1]] - verts[nt[0]], verts[nt[2]] - verts[nt[1]]).length() < epsilon * epsilon * btScalar(0.1)) + { + btHullTriangle *nb = m_tris[m_tris[j]->n[0]]; + btAssert(nb); + btAssert(!hasvert(*nb, v)); + btAssert(nb->id < j); + extrude(nb, v); + j = m_tris.size(); + } + } + j = m_tris.size(); + while (j--) + { + btHullTriangle *t = m_tris[j]; + if (!t) continue; + if (t->vmax >= 0) break; + btVector3 n = TriNormal(verts[(*t)[0]], verts[(*t)[1]], verts[(*t)[2]]); + t->vmax = maxdirsterid(verts, verts_count, n, allow); + if (isextreme[t->vmax]) + { + t->vmax = -1; // already done that vertex - algorithm needs to be able to terminate. + } + else + { + t->rise = btDot(n, verts[t->vmax] - verts[(*t)[0]]); + } + } + vlimit--; + } + return 1; +} + +int HullLibrary::calchull(btVector3 *verts, int verts_count, TUIntArray &tris_out, int &tris_count, int vlimit) +{ + int rc = calchullgen(verts, verts_count, vlimit); + if (!rc) return 0; + btAlignedObjectArray ts; + int i; + + for (i = 0; i < m_tris.size(); i++) + { + if (m_tris[i]) + { + for (int j = 0; j < 3; j++) + ts.push_back((*m_tris[i])[j]); + deAllocateTriangle(m_tris[i]); + } + } + tris_count = ts.size() / 3; + tris_out.resize(ts.size()); + + for (i = 0; i < ts.size(); i++) + { + tris_out[i] = static_cast(ts[i]); + } + m_tris.resize(0); + + return 1; +} + +bool HullLibrary::ComputeHull(unsigned int vcount, const btVector3 *vertices, PHullResult &result, unsigned int vlimit) +{ + int tris_count; + int ret = calchull((btVector3 *)vertices, (int)vcount, result.m_Indices, tris_count, static_cast(vlimit)); + if (!ret) return false; + result.mIndexCount = (unsigned int)(tris_count * 3); + result.mFaceCount = (unsigned int)tris_count; + result.mVertices = (btVector3 *)vertices; + result.mVcount = (unsigned int)vcount; + return true; +} + +void ReleaseHull(PHullResult &result); +void ReleaseHull(PHullResult &result) +{ + if (result.m_Indices.size()) + { + result.m_Indices.clear(); + } + + result.mVcount = 0; + result.mIndexCount = 0; + result.mVertices = 0; +} + +//********************************************************************* +//********************************************************************* +//******** HullLib header +//********************************************************************* +//********************************************************************* + +//********************************************************************* +//********************************************************************* +//******** HullLib implementation +//********************************************************************* +//********************************************************************* + +HullError HullLibrary::CreateConvexHull(const HullDesc &desc, // describes the input request + HullResult &result) // contains the resulst +{ + HullError ret = QE_FAIL; + + PHullResult hr; + + unsigned int vcount = desc.mVcount; + if (vcount < 8) vcount = 8; + + btAlignedObjectArray vertexSource; + btVector3 zero; + zero.setZero(); + vertexSource.resize(static_cast(vcount), zero); + + btVector3 scale; + + unsigned int ovcount; + + bool ok = CleanupVertices(desc.mVcount, desc.mVertices, desc.mVertexStride, ovcount, &vertexSource[0], desc.mNormalEpsilon, scale); // normalize point cloud, remove duplicates! + + if (ok) + { + // if ( 1 ) // scale vertices back to their original size. + { + for (unsigned int i = 0; i < ovcount; i++) + { + btVector3 &v = vertexSource[static_cast(i)]; + v[0] *= scale[0]; + v[1] *= scale[1]; + v[2] *= scale[2]; + } + } + + ok = ComputeHull(ovcount, &vertexSource[0], hr, desc.mMaxVertices); + + if (ok) + { + // re-index triangle mesh so it refers to only used vertices, rebuild a new vertex table. + btAlignedObjectArray vertexScratch; + vertexScratch.resize(static_cast(hr.mVcount)); + + BringOutYourDead(hr.mVertices, hr.mVcount, &vertexScratch[0], ovcount, &hr.m_Indices[0], hr.mIndexCount); + + ret = QE_OK; + + if (desc.HasHullFlag(QF_TRIANGLES)) // if he wants the results as triangle! + { + result.mPolygons = false; + result.mNumOutputVertices = ovcount; + result.m_OutputVertices.resize(static_cast(ovcount)); + result.mNumFaces = hr.mFaceCount; + result.mNumIndices = hr.mIndexCount; + + result.m_Indices.resize(static_cast(hr.mIndexCount)); + + memcpy(&result.m_OutputVertices[0], &vertexScratch[0], sizeof(btVector3) * ovcount); + + if (desc.HasHullFlag(QF_REVERSE_ORDER)) + { + const unsigned int *source = &hr.m_Indices[0]; + unsigned int *dest = &result.m_Indices[0]; + + for (unsigned int i = 0; i < hr.mFaceCount; i++) + { + dest[0] = source[2]; + dest[1] = source[1]; + dest[2] = source[0]; + dest += 3; + source += 3; + } + } + else + { + memcpy(&result.m_Indices[0], &hr.m_Indices[0], sizeof(unsigned int) * hr.mIndexCount); + } + } + else + { + result.mPolygons = true; + result.mNumOutputVertices = ovcount; + result.m_OutputVertices.resize(static_cast(ovcount)); + result.mNumFaces = hr.mFaceCount; + result.mNumIndices = hr.mIndexCount + hr.mFaceCount; + result.m_Indices.resize(static_cast(result.mNumIndices)); + memcpy(&result.m_OutputVertices[0], &vertexScratch[0], sizeof(btVector3) * ovcount); + + // if ( 1 ) + { + const unsigned int *source = &hr.m_Indices[0]; + unsigned int *dest = &result.m_Indices[0]; + for (unsigned int i = 0; i < hr.mFaceCount; i++) + { + dest[0] = 3; + if (desc.HasHullFlag(QF_REVERSE_ORDER)) + { + dest[1] = source[2]; + dest[2] = source[1]; + dest[3] = source[0]; + } + else + { + dest[1] = source[0]; + dest[2] = source[1]; + dest[3] = source[2]; + } + + dest += 4; + source += 3; + } + } + } + ReleaseHull(hr); + } + } + + return ret; +} + +HullError HullLibrary::ReleaseResult(HullResult &result) // release memory allocated for this result, we are done with it. +{ + if (result.m_OutputVertices.size()) + { + result.mNumOutputVertices = 0; + result.m_OutputVertices.clear(); + } + if (result.m_Indices.size()) + { + result.mNumIndices = 0; + result.m_Indices.clear(); + } + return QE_OK; +} + +static void addPoint(unsigned int &vcount, btVector3 *p, btScalar x, btScalar y, btScalar z) +{ + // XXX, might be broken + btVector3 &dest = p[vcount]; + dest[0] = x; + dest[1] = y; + dest[2] = z; + vcount++; +} + +btScalar GetDist(btScalar px, btScalar py, btScalar pz, const btScalar *p2); +btScalar GetDist(btScalar px, btScalar py, btScalar pz, const btScalar *p2) +{ + btScalar dx = px - p2[0]; + btScalar dy = py - p2[1]; + btScalar dz = pz - p2[2]; + + return dx * dx + dy * dy + dz * dz; +} + +bool HullLibrary::CleanupVertices(unsigned int svcount, + const btVector3 *svertices, + unsigned int stride, + unsigned int &vcount, // output number of vertices + btVector3 *vertices, // location to store the results. + btScalar normalepsilon, + btVector3 &scale) +{ + if (svcount == 0) return false; + + m_vertexIndexMapping.resize(0); + +#define EPSILON btScalar(0.000001) /* close enough to consider two btScalaring point numbers to be 'the same'. */ + + vcount = 0; + + btScalar recip[3] = {0.f, 0.f, 0.f}; + + if (scale) + { + scale[0] = 1; + scale[1] = 1; + scale[2] = 1; + } + + btScalar bmin[3] = {FLT_MAX, FLT_MAX, FLT_MAX}; + btScalar bmax[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX}; + + const char *vtx = (const char *)svertices; + + // if ( 1 ) + { + for (unsigned int i = 0; i < svcount; i++) + { + const btScalar *p = (const btScalar *)vtx; + + vtx += stride; + + for (int j = 0; j < 3; j++) + { + if (p[j] < bmin[j]) bmin[j] = p[j]; + if (p[j] > bmax[j]) bmax[j] = p[j]; + } + } + } + + btScalar dx = bmax[0] - bmin[0]; + btScalar dy = bmax[1] - bmin[1]; + btScalar dz = bmax[2] - bmin[2]; + + btVector3 center; + + center[0] = dx * btScalar(0.5) + bmin[0]; + center[1] = dy * btScalar(0.5) + bmin[1]; + center[2] = dz * btScalar(0.5) + bmin[2]; + + if (dx < EPSILON || dy < EPSILON || dz < EPSILON || svcount < 3) + { + btScalar len = FLT_MAX; + + if (dx > EPSILON && dx < len) len = dx; + if (dy > EPSILON && dy < len) len = dy; + if (dz > EPSILON && dz < len) len = dz; + + if (len == FLT_MAX) + { + dx = dy = dz = btScalar(0.01); // one centimeter + } + else + { + if (dx < EPSILON) dx = len * btScalar(0.05); // 1/5th the shortest non-zero edge. + if (dy < EPSILON) dy = len * btScalar(0.05); + if (dz < EPSILON) dz = len * btScalar(0.05); + } + + btScalar x1 = center[0] - dx; + btScalar x2 = center[0] + dx; + + btScalar y1 = center[1] - dy; + btScalar y2 = center[1] + dy; + + btScalar z1 = center[2] - dz; + btScalar z2 = center[2] + dz; + + addPoint(vcount, vertices, x1, y1, z1); + addPoint(vcount, vertices, x2, y1, z1); + addPoint(vcount, vertices, x2, y2, z1); + addPoint(vcount, vertices, x1, y2, z1); + addPoint(vcount, vertices, x1, y1, z2); + addPoint(vcount, vertices, x2, y1, z2); + addPoint(vcount, vertices, x2, y2, z2); + addPoint(vcount, vertices, x1, y2, z2); + + return true; // return cube + } + else + { + if (scale) + { + scale[0] = dx; + scale[1] = dy; + scale[2] = dz; + + recip[0] = 1 / dx; + recip[1] = 1 / dy; + recip[2] = 1 / dz; + + center[0] *= recip[0]; + center[1] *= recip[1]; + center[2] *= recip[2]; + } + } + + vtx = (const char *)svertices; + + for (unsigned int i = 0; i < svcount; i++) + { + const btVector3 *p = (const btVector3 *)vtx; + vtx += stride; + + btScalar px = p->getX(); + btScalar py = p->getY(); + btScalar pz = p->getZ(); + + if (scale) + { + px = px * recip[0]; // normalize + py = py * recip[1]; // normalize + pz = pz * recip[2]; // normalize + } + + // if ( 1 ) + { + unsigned int j; + + for (j = 0; j < vcount; j++) + { + /// XXX might be broken + btVector3 &v = vertices[j]; + + btScalar x = v[0]; + btScalar y = v[1]; + btScalar z = v[2]; + + btScalar dx = btFabs(x - px); + btScalar dy = btFabs(y - py); + btScalar dz = btFabs(z - pz); + + if (dx < normalepsilon && dy < normalepsilon && dz < normalepsilon) + { + // ok, it is close enough to the old one + // now let us see if it is further from the center of the point cloud than the one we already recorded. + // in which case we keep this one instead. + + btScalar dist1 = GetDist(px, py, pz, center); + btScalar dist2 = GetDist(v[0], v[1], v[2], center); + + if (dist1 > dist2) + { + v[0] = px; + v[1] = py; + v[2] = pz; + } + + break; + } + } + + if (j == vcount) + { + btVector3 &dest = vertices[vcount]; + dest[0] = px; + dest[1] = py; + dest[2] = pz; + vcount++; + } + m_vertexIndexMapping.push_back(j); + } + } + + // ok..now make sure we didn't prune so many vertices it is now invalid. + // if ( 1 ) + { + btScalar bmin[3] = {FLT_MAX, FLT_MAX, FLT_MAX}; + btScalar bmax[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX}; + + for (unsigned int i = 0; i < vcount; i++) + { + const btVector3 &p = vertices[i]; + for (int j = 0; j < 3; j++) + { + if (p[j] < bmin[j]) bmin[j] = p[j]; + if (p[j] > bmax[j]) bmax[j] = p[j]; + } + } + + btScalar dx = bmax[0] - bmin[0]; + btScalar dy = bmax[1] - bmin[1]; + btScalar dz = bmax[2] - bmin[2]; + + if (dx < EPSILON || dy < EPSILON || dz < EPSILON || vcount < 3) + { + btScalar cx = dx * btScalar(0.5) + bmin[0]; + btScalar cy = dy * btScalar(0.5) + bmin[1]; + btScalar cz = dz * btScalar(0.5) + bmin[2]; + + btScalar len = FLT_MAX; + + if (dx >= EPSILON && dx < len) len = dx; + if (dy >= EPSILON && dy < len) len = dy; + if (dz >= EPSILON && dz < len) len = dz; + + if (len == FLT_MAX) + { + dx = dy = dz = btScalar(0.01); // one centimeter + } + else + { + if (dx < EPSILON) dx = len * btScalar(0.05); // 1/5th the shortest non-zero edge. + if (dy < EPSILON) dy = len * btScalar(0.05); + if (dz < EPSILON) dz = len * btScalar(0.05); + } + + btScalar x1 = cx - dx; + btScalar x2 = cx + dx; + + btScalar y1 = cy - dy; + btScalar y2 = cy + dy; + + btScalar z1 = cz - dz; + btScalar z2 = cz + dz; + + vcount = 0; // add box + + addPoint(vcount, vertices, x1, y1, z1); + addPoint(vcount, vertices, x2, y1, z1); + addPoint(vcount, vertices, x2, y2, z1); + addPoint(vcount, vertices, x1, y2, z1); + addPoint(vcount, vertices, x1, y1, z2); + addPoint(vcount, vertices, x2, y1, z2); + addPoint(vcount, vertices, x2, y2, z2); + addPoint(vcount, vertices, x1, y2, z2); + + return true; + } + } + + return true; +} + +void HullLibrary::BringOutYourDead(const btVector3 *verts, unsigned int vcount, btVector3 *overts, unsigned int &ocount, unsigned int *indices, unsigned indexcount) +{ + btAlignedObjectArray tmpIndices; + tmpIndices.resize(m_vertexIndexMapping.size()); + int i; + + for (i = 0; i < m_vertexIndexMapping.size(); i++) + { + tmpIndices[i] = m_vertexIndexMapping[i]; + } + + TUIntArray usedIndices; + usedIndices.resize(static_cast(vcount)); + memset(&usedIndices[0], 0, sizeof(unsigned int) * vcount); + + ocount = 0; + + for (i = 0; i < int(indexcount); i++) + { + unsigned int v = indices[i]; // original array index + + btAssert(v >= 0 && v < vcount); + + if (usedIndices[static_cast(v)]) // if already remapped + { + indices[i] = usedIndices[static_cast(v)] - 1; // index to new array + } + else + { + indices[i] = ocount; // new index mapping + + overts[ocount][0] = verts[v][0]; // copy old vert to new vert array + overts[ocount][1] = verts[v][1]; + overts[ocount][2] = verts[v][2]; + + for (int k = 0; k < m_vertexIndexMapping.size(); k++) + { + if (tmpIndices[k] == int(v)) + m_vertexIndexMapping[k] = ocount; + } + + ocount++; // increment output vert count + + btAssert(ocount >= 0 && ocount <= vcount); + + usedIndices[static_cast(v)] = ocount; // assign new index remapping + } + } +} diff --git a/pkg/mphysics/mbt/LinearMath/btConvexHull.cpp.i b/pkg/mphysics/mbt/LinearMath/btConvexHull.cpp.i new file mode 100644 index 00000000..46956324 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btConvexHull.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btConvexHull.cpp ---------------- + +%include "LinearMath/btConvexHull.cpp" + +%{ +#include "LinearMath/btConvexHull.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btConvexHull.h b/pkg/mphysics/mbt/LinearMath/btConvexHull.h new file mode 100644 index 00000000..f890d75e --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btConvexHull.h @@ -0,0 +1,233 @@ + +/* +Stan Melax Convex Hull Computation +Copyright (c) 2008 Stan Melax http://www.melax.com/ + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +///includes modifications/improvements by John Ratcliff, see BringOutYourDead below. + +#ifndef BT_CD_HULL_H +#define BT_CD_HULL_H + +#include "btVector3.h" +#include "btAlignedObjectArray.h" + +typedef btAlignedObjectArray TUIntArray; + +class HullResult +{ +public: + HullResult(void) + { + mPolygons = true; + mNumOutputVertices = 0; + mNumFaces = 0; + mNumIndices = 0; + } + bool mPolygons; // true if indices represents polygons, false indices are triangles + unsigned int mNumOutputVertices; // number of vertices in the output hull + btAlignedObjectArray m_OutputVertices; // array of vertices + unsigned int mNumFaces; // the number of faces produced + unsigned int mNumIndices; // the total number of indices + btAlignedObjectArray m_Indices; // pointer to indices. + + // If triangles, then indices are array indexes into the vertex list. + // If polygons, indices are in the form (number of points in face) (p1, p2, p3, ..) etc.. +}; + +enum HullFlag +{ + QF_TRIANGLES = (1 << 0), // report results as triangles, not polygons. + QF_REVERSE_ORDER = (1 << 1), // reverse order of the triangle indices. + QF_DEFAULT = QF_TRIANGLES +}; + +class HullDesc +{ +public: + HullDesc(void) + { + mFlags = QF_DEFAULT; + mVcount = 0; + mVertices = 0; + mVertexStride = sizeof(btVector3); + mNormalEpsilon = 0.001f; + mMaxVertices = 4096; // maximum number of points to be considered for a convex hull. + mMaxFaces = 4096; + }; + + HullDesc(HullFlag flag, + unsigned int vcount, + const btVector3* vertices, + unsigned int stride = sizeof(btVector3)) + { + mFlags = flag; + mVcount = vcount; + mVertices = vertices; + mVertexStride = stride; + mNormalEpsilon = btScalar(0.001); + mMaxVertices = 4096; + } + + bool HasHullFlag(HullFlag flag) const + { + if (mFlags & flag) return true; + return false; + } + + void SetHullFlag(HullFlag flag) + { + mFlags |= flag; + } + + void ClearHullFlag(HullFlag flag) + { + mFlags &= ~flag; + } + + unsigned int mFlags; // flags to use when generating the convex hull. + unsigned int mVcount; // number of vertices in the input point cloud + const btVector3* mVertices; // the array of vertices. + unsigned int mVertexStride; // the stride of each vertex, in bytes. + btScalar mNormalEpsilon; // the epsilon for removing duplicates. This is a normalized value, if normalized bit is on. + unsigned int mMaxVertices; // maximum number of vertices to be considered for the hull! + unsigned int mMaxFaces; +}; + +enum HullError +{ + QE_OK, // success! + QE_FAIL // failed. +}; + +class btPlane +{ +public: + btVector3 normal; + btScalar dist; // distance below origin - the D from plane equasion Ax+By+Cz+D=0 + btPlane(const btVector3& n, btScalar d) : normal(n), dist(d) {} + btPlane() : normal(), dist(0) {} +}; + +class ConvexH +{ +public: + class HalfEdge + { + public: + short ea; // the other half of the edge (index into edges list) + unsigned char v; // the vertex at the start of this edge (index into vertices list) + unsigned char p; // the facet on which this edge lies (index into facets list) + HalfEdge() {} + HalfEdge(short _ea, unsigned char _v, unsigned char _p) : ea(_ea), v(_v), p(_p) {} + }; + ConvexH() + { + } + ~ConvexH() + { + } + btAlignedObjectArray vertices; + btAlignedObjectArray edges; + btAlignedObjectArray facets; + ConvexH(int vertices_size, int edges_size, int facets_size); +}; + +class int4 +{ +public: + int x, y, z, w; + int4(){}; + int4(int _x, int _y, int _z, int _w) + { + x = _x; + y = _y; + z = _z; + w = _w; + } + const int& operator[](int i) const { return (&x)[i]; } + int& operator[](int i) { return (&x)[i]; } +}; + +class PHullResult +{ +public: + PHullResult(void) + { + mVcount = 0; + mIndexCount = 0; + mFaceCount = 0; + mVertices = 0; + } + + unsigned int mVcount; + unsigned int mIndexCount; + unsigned int mFaceCount; + btVector3* mVertices; + TUIntArray m_Indices; +}; + +///The HullLibrary class can create a convex hull from a collection of vertices, using the ComputeHull method. +///The btShapeHull class uses this HullLibrary to create a approximate convex mesh given a general (non-polyhedral) convex shape. +class HullLibrary +{ + btAlignedObjectArray m_tris; + +public: + btAlignedObjectArray m_vertexIndexMapping; + + HullError CreateConvexHull(const HullDesc& desc, // describes the input request + HullResult& result); // contains the resulst + HullError ReleaseResult(HullResult& result); // release memory allocated for this result, we are done with it. + +private: + bool ComputeHull(unsigned int vcount, const btVector3* vertices, PHullResult& result, unsigned int vlimit); + + class btHullTriangle* allocateTriangle(int a, int b, int c); + void deAllocateTriangle(btHullTriangle*); + void b2bfix(btHullTriangle* s, btHullTriangle* t); + + void removeb2b(btHullTriangle* s, btHullTriangle* t); + + void checkit(btHullTriangle* t); + + btHullTriangle* extrudable(btScalar epsilon); + + int calchull(btVector3* verts, int verts_count, TUIntArray& tris_out, int& tris_count, int vlimit); + + int calchullgen(btVector3* verts, int verts_count, int vlimit); + + int4 FindSimplex(btVector3* verts, int verts_count, btAlignedObjectArray& allow); + + class ConvexH* ConvexHCrop(ConvexH& convex, const btPlane& slice); + + void extrude(class btHullTriangle* t0, int v); + + ConvexH* test_cube(); + + //BringOutYourDead (John Ratcliff): When you create a convex hull you hand it a large input set of vertices forming a 'point cloud'. + //After the hull is generated it give you back a set of polygon faces which index the *original* point cloud. + //The thing is, often times, there are many 'dead vertices' in the point cloud that are on longer referenced by the hull. + //The routine 'BringOutYourDead' find only the referenced vertices, copies them to an new buffer, and re-indexes the hull so that it is a minimal representation. + void BringOutYourDead(const btVector3* verts, unsigned int vcount, btVector3* overts, unsigned int& ocount, unsigned int* indices, unsigned indexcount); + + bool CleanupVertices(unsigned int svcount, + const btVector3* svertices, + unsigned int stride, + unsigned int& vcount, // output number of vertices + btVector3* vertices, // location to store the results. + btScalar normalepsilon, + btVector3& scale); +}; + +#endif //BT_CD_HULL_H diff --git a/pkg/mphysics/mbt/LinearMath/btConvexHull.h.i b/pkg/mphysics/mbt/LinearMath/btConvexHull.h.i new file mode 100644 index 00000000..b4ecd25b --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btConvexHull.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btConvexHull.h ---------------- + +%include "LinearMath/btConvexHull.h" + +%{ +#include "LinearMath/btConvexHull.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.cpp b/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.cpp new file mode 100644 index 00000000..12125fd2 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.cpp @@ -0,0 +1,2760 @@ +/* +Copyright (c) 2011 Ole Kniemeyer, MAXON, www.maxon.net + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include + +#include "btConvexHullComputer.h" +#include "btAlignedObjectArray.h" +#include "btMinMax.h" +#include "btVector3.h" + +#ifdef __GNUC__ +#include +#elif defined(_MSC_VER) +typedef __int32 int32_t; +typedef __int64 int64_t; +typedef unsigned __int32 uint32_t; +typedef unsigned __int64 uint64_t; +#else +typedef int int32_t; +typedef long long int int64_t; +typedef unsigned int uint32_t; +typedef unsigned long long int uint64_t; +#endif + +//The definition of USE_X86_64_ASM is moved into the build system. You can enable it manually by commenting out the following lines +//#if (defined(__GNUC__) && defined(__x86_64__) && !defined(__ICL)) // || (defined(__ICL) && defined(_M_X64)) bug in Intel compiler, disable inline assembly +// #define USE_X86_64_ASM +//#endif + +//#define DEBUG_CONVEX_HULL +//#define SHOW_ITERATIONS + +#if defined(DEBUG_CONVEX_HULL) || defined(SHOW_ITERATIONS) +#include +#endif + +// Convex hull implementation based on Preparata and Hong +// Ole Kniemeyer, MAXON Computer GmbH +class btConvexHullInternal +{ +public: + class Point64 + { + public: + int64_t x; + int64_t y; + int64_t z; + + Point64(int64_t x, int64_t y, int64_t z) : x(x), y(y), z(z) + { + } + + bool isZero() + { + return (x == 0) && (y == 0) && (z == 0); + } + + int64_t dot(const Point64& b) const + { + return x * b.x + y * b.y + z * b.z; + } + }; + + class Point32 + { + public: + int32_t x; + int32_t y; + int32_t z; + int index; + + Point32() + { + } + + Point32(int32_t x, int32_t y, int32_t z) : x(x), y(y), z(z), index(-1) + { + } + + bool operator==(const Point32& b) const + { + return (x == b.x) && (y == b.y) && (z == b.z); + } + + bool operator!=(const Point32& b) const + { + return (x != b.x) || (y != b.y) || (z != b.z); + } + + bool isZero() + { + return (x == 0) && (y == 0) && (z == 0); + } + + Point64 cross(const Point32& b) const + { + return Point64(((int64_t)y) * b.z - ((int64_t)z) * b.y, ((int64_t)z) * b.x - ((int64_t)x) * b.z, ((int64_t)x) * b.y - ((int64_t)y) * b.x); + } + + Point64 cross(const Point64& b) const + { + return Point64(y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x); + } + + int64_t dot(const Point32& b) const + { + return ((int64_t)x) * b.x + ((int64_t)y) * b.y + ((int64_t)z) * b.z; + } + + int64_t dot(const Point64& b) const + { + return x * b.x + y * b.y + z * b.z; + } + + Point32 operator+(const Point32& b) const + { + return Point32(x + b.x, y + b.y, z + b.z); + } + + Point32 operator-(const Point32& b) const + { + return Point32(x - b.x, y - b.y, z - b.z); + } + }; + + class Int128 + { + public: + uint64_t low; + uint64_t high; + + Int128() + { + } + + Int128(uint64_t low, uint64_t high) : low(low), high(high) + { + } + + Int128(uint64_t low) : low(low), high(0) + { + } + + Int128(int64_t value) : low(value), high((value >= 0) ? 0 : (uint64_t)-1LL) + { + } + + static Int128 mul(int64_t a, int64_t b); + + static Int128 mul(uint64_t a, uint64_t b); + + Int128 operator-() const + { + return Int128((uint64_t) - (int64_t)low, ~high + (low == 0)); + } + + Int128 operator+(const Int128& b) const + { +#ifdef USE_X86_64_ASM + Int128 result; + __asm__( + "addq %[bl], %[rl]\n\t" + "adcq %[bh], %[rh]\n\t" + : [rl] "=r"(result.low), [rh] "=r"(result.high) + : "0"(low), "1"(high), [bl] "g"(b.low), [bh] "g"(b.high) + : "cc"); + return result; +#else + uint64_t lo = low + b.low; + return Int128(lo, high + b.high + (lo < low)); +#endif + } + + Int128 operator-(const Int128& b) const + { +#ifdef USE_X86_64_ASM + Int128 result; + __asm__( + "subq %[bl], %[rl]\n\t" + "sbbq %[bh], %[rh]\n\t" + : [rl] "=r"(result.low), [rh] "=r"(result.high) + : "0"(low), "1"(high), [bl] "g"(b.low), [bh] "g"(b.high) + : "cc"); + return result; +#else + return *this + -b; +#endif + } + + Int128& operator+=(const Int128& b) + { +#ifdef USE_X86_64_ASM + __asm__( + "addq %[bl], %[rl]\n\t" + "adcq %[bh], %[rh]\n\t" + : [rl] "=r"(low), [rh] "=r"(high) + : "0"(low), "1"(high), [bl] "g"(b.low), [bh] "g"(b.high) + : "cc"); +#else + uint64_t lo = low + b.low; + if (lo < low) + { + ++high; + } + low = lo; + high += b.high; +#endif + return *this; + } + + Int128& operator++() + { + if (++low == 0) + { + ++high; + } + return *this; + } + + Int128 operator*(int64_t b) const; + + btScalar toScalar() const + { + return ((int64_t)high >= 0) ? btScalar(high) * (btScalar(0x100000000LL) * btScalar(0x100000000LL)) + btScalar(low) + : -(-*this).toScalar(); + } + + int getSign() const + { + return ((int64_t)high < 0) ? -1 : (high || low) ? 1 : 0; + } + + bool operator<(const Int128& b) const + { + return (high < b.high) || ((high == b.high) && (low < b.low)); + } + + int ucmp(const Int128& b) const + { + if (high < b.high) + { + return -1; + } + if (high > b.high) + { + return 1; + } + if (low < b.low) + { + return -1; + } + if (low > b.low) + { + return 1; + } + return 0; + } + }; + + class Rational64 + { + private: + uint64_t m_numerator; + uint64_t m_denominator; + int sign; + + public: + Rational64(int64_t numerator, int64_t denominator) + { + if (numerator > 0) + { + sign = 1; + m_numerator = (uint64_t)numerator; + } + else if (numerator < 0) + { + sign = -1; + m_numerator = (uint64_t)-numerator; + } + else + { + sign = 0; + m_numerator = 0; + } + if (denominator > 0) + { + m_denominator = (uint64_t)denominator; + } + else if (denominator < 0) + { + sign = -sign; + m_denominator = (uint64_t)-denominator; + } + else + { + m_denominator = 0; + } + } + + bool isNegativeInfinity() const + { + return (sign < 0) && (m_denominator == 0); + } + + bool isNaN() const + { + return (sign == 0) && (m_denominator == 0); + } + + int compare(const Rational64& b) const; + + btScalar toScalar() const + { + return sign * ((m_denominator == 0) ? SIMD_INFINITY : (btScalar)m_numerator / m_denominator); + } + }; + + class Rational128 + { + private: + Int128 numerator; + Int128 denominator; + int sign; + bool isInt64; + + public: + Rational128(int64_t value) + { + if (value > 0) + { + sign = 1; + this->numerator = value; + } + else if (value < 0) + { + sign = -1; + this->numerator = -value; + } + else + { + sign = 0; + this->numerator = (uint64_t)0; + } + this->denominator = (uint64_t)1; + isInt64 = true; + } + + Rational128(const Int128& numerator, const Int128& denominator) + { + sign = numerator.getSign(); + if (sign >= 0) + { + this->numerator = numerator; + } + else + { + this->numerator = -numerator; + } + int dsign = denominator.getSign(); + if (dsign >= 0) + { + this->denominator = denominator; + } + else + { + sign = -sign; + this->denominator = -denominator; + } + isInt64 = false; + } + + int compare(const Rational128& b) const; + + int compare(int64_t b) const; + + btScalar toScalar() const + { + return sign * ((denominator.getSign() == 0) ? SIMD_INFINITY : numerator.toScalar() / denominator.toScalar()); + } + }; + + class PointR128 + { + public: + Int128 x; + Int128 y; + Int128 z; + Int128 denominator; + + PointR128() + { + } + + PointR128(Int128 x, Int128 y, Int128 z, Int128 denominator) : x(x), y(y), z(z), denominator(denominator) + { + } + + btScalar xvalue() const + { + return x.toScalar() / denominator.toScalar(); + } + + btScalar yvalue() const + { + return y.toScalar() / denominator.toScalar(); + } + + btScalar zvalue() const + { + return z.toScalar() / denominator.toScalar(); + } + }; + + class Edge; + class Face; + + class Vertex + { + public: + Vertex* next; + Vertex* prev; + Edge* edges; + Face* firstNearbyFace; + Face* lastNearbyFace; + PointR128 point128; + Point32 point; + int copy; + + Vertex() : next(NULL), prev(NULL), edges(NULL), firstNearbyFace(NULL), lastNearbyFace(NULL), copy(-1) + { + } + +#ifdef DEBUG_CONVEX_HULL + void print() + { + printf("V%d (%d, %d, %d)", point.index, point.x, point.y, point.z); + } + + void printGraph(); +#endif + + Point32 operator-(const Vertex& b) const + { + return point - b.point; + } + + Rational128 dot(const Point64& b) const + { + return (point.index >= 0) ? Rational128(point.dot(b)) + : Rational128(point128.x * b.x + point128.y * b.y + point128.z * b.z, point128.denominator); + } + + btScalar xvalue() const + { + return (point.index >= 0) ? btScalar(point.x) : point128.xvalue(); + } + + btScalar yvalue() const + { + return (point.index >= 0) ? btScalar(point.y) : point128.yvalue(); + } + + btScalar zvalue() const + { + return (point.index >= 0) ? btScalar(point.z) : point128.zvalue(); + } + + void receiveNearbyFaces(Vertex* src) + { + if (lastNearbyFace) + { + lastNearbyFace->nextWithSameNearbyVertex = src->firstNearbyFace; + } + else + { + firstNearbyFace = src->firstNearbyFace; + } + if (src->lastNearbyFace) + { + lastNearbyFace = src->lastNearbyFace; + } + for (Face* f = src->firstNearbyFace; f; f = f->nextWithSameNearbyVertex) + { + btAssert(f->nearbyVertex == src); + f->nearbyVertex = this; + } + src->firstNearbyFace = NULL; + src->lastNearbyFace = NULL; + } + }; + + class Edge + { + public: + Edge* next; + Edge* prev; + Edge* reverse; + Vertex* target; + Face* face; + int copy; + + ~Edge() + { + next = NULL; + prev = NULL; + reverse = NULL; + target = NULL; + face = NULL; + } + + void link(Edge* n) + { + btAssert(reverse->target == n->reverse->target); + next = n; + n->prev = this; + } + +#ifdef DEBUG_CONVEX_HULL + void print() + { + printf("E%p : %d -> %d, n=%p p=%p (0 %d\t%d\t%d) -> (%d %d %d)", this, reverse->target->point.index, target->point.index, next, prev, + reverse->target->point.x, reverse->target->point.y, reverse->target->point.z, target->point.x, target->point.y, target->point.z); + } +#endif + }; + + class Face + { + public: + Face* next; + Vertex* nearbyVertex; + Face* nextWithSameNearbyVertex; + Point32 origin; + Point32 dir0; + Point32 dir1; + + Face() : next(NULL), nearbyVertex(NULL), nextWithSameNearbyVertex(NULL) + { + } + + void init(Vertex* a, Vertex* b, Vertex* c) + { + nearbyVertex = a; + origin = a->point; + dir0 = *b - *a; + dir1 = *c - *a; + if (a->lastNearbyFace) + { + a->lastNearbyFace->nextWithSameNearbyVertex = this; + } + else + { + a->firstNearbyFace = this; + } + a->lastNearbyFace = this; + } + + Point64 getNormal() + { + return dir0.cross(dir1); + } + }; + + template + class DMul + { + private: + static uint32_t high(uint64_t value) + { + return (uint32_t)(value >> 32); + } + + static uint32_t low(uint64_t value) + { + return (uint32_t)value; + } + + static uint64_t mul(uint32_t a, uint32_t b) + { + return (uint64_t)a * (uint64_t)b; + } + + static void shlHalf(uint64_t& value) + { + value <<= 32; + } + + static uint64_t high(Int128 value) + { + return value.high; + } + + static uint64_t low(Int128 value) + { + return value.low; + } + + static Int128 mul(uint64_t a, uint64_t b) + { + return Int128::mul(a, b); + } + + static void shlHalf(Int128& value) + { + value.high = value.low; + value.low = 0; + } + + public: + static void mul(UWord a, UWord b, UWord& resLow, UWord& resHigh) + { + UWord p00 = mul(low(a), low(b)); + UWord p01 = mul(low(a), high(b)); + UWord p10 = mul(high(a), low(b)); + UWord p11 = mul(high(a), high(b)); + UWord p0110 = UWord(low(p01)) + UWord(low(p10)); + p11 += high(p01); + p11 += high(p10); + p11 += high(p0110); + shlHalf(p0110); + p00 += p0110; + if (p00 < p0110) + { + ++p11; + } + resLow = p00; + resHigh = p11; + } + }; + +private: + class IntermediateHull + { + public: + Vertex* minXy; + Vertex* maxXy; + Vertex* minYx; + Vertex* maxYx; + + IntermediateHull() : minXy(NULL), maxXy(NULL), minYx(NULL), maxYx(NULL) + { + } + + void print(); + }; + + enum Orientation + { + NONE, + CLOCKWISE, + COUNTER_CLOCKWISE + }; + + template + class PoolArray + { + private: + T* array; + int size; + + public: + PoolArray* next; + + PoolArray(int size) : size(size), next(NULL) + { + array = (T*)btAlignedAlloc(sizeof(T) * size, 16); + } + + ~PoolArray() + { + btAlignedFree(array); + } + + T* init() + { + T* o = array; + for (int i = 0; i < size; i++, o++) + { + o->next = (i + 1 < size) ? o + 1 : NULL; + } + return array; + } + }; + + template + class Pool + { + private: + PoolArray* arrays; + PoolArray* nextArray; + T* freeObjects; + int arraySize; + + public: + Pool() : arrays(NULL), nextArray(NULL), freeObjects(NULL), arraySize(256) + { + } + + ~Pool() + { + while (arrays) + { + PoolArray* p = arrays; + arrays = p->next; + p->~PoolArray(); + btAlignedFree(p); + } + } + + void reset() + { + nextArray = arrays; + freeObjects = NULL; + } + + void setArraySize(int arraySize) + { + this->arraySize = arraySize; + } + + T* newObject() + { + T* o = freeObjects; + if (!o) + { + PoolArray* p = nextArray; + if (p) + { + nextArray = p->next; + } + else + { + p = new (btAlignedAlloc(sizeof(PoolArray), 16)) PoolArray(arraySize); + p->next = arrays; + arrays = p; + } + o = p->init(); + } + freeObjects = o->next; + return new (o) T(); + }; + + void freeObject(T* object) + { + object->~T(); + object->next = freeObjects; + freeObjects = object; + } + }; + + btVector3 scaling; + btVector3 center; + Pool vertexPool; + Pool edgePool; + Pool facePool; + btAlignedObjectArray originalVertices; + int mergeStamp; + int minAxis; + int medAxis; + int maxAxis; + int usedEdgePairs; + int maxUsedEdgePairs; + + static Orientation getOrientation(const Edge* prev, const Edge* next, const Point32& s, const Point32& t); + Edge* findMaxAngle(bool ccw, const Vertex* start, const Point32& s, const Point64& rxs, const Point64& sxrxs, Rational64& minCot); + void findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge*& e0, Edge*& e1, Vertex* stop0, Vertex* stop1); + + Edge* newEdgePair(Vertex* from, Vertex* to); + + void removeEdgePair(Edge* edge) + { + Edge* n = edge->next; + Edge* r = edge->reverse; + + btAssert(edge->target && r->target); + + if (n != edge) + { + n->prev = edge->prev; + edge->prev->next = n; + r->target->edges = n; + } + else + { + r->target->edges = NULL; + } + + n = r->next; + + if (n != r) + { + n->prev = r->prev; + r->prev->next = n; + edge->target->edges = n; + } + else + { + edge->target->edges = NULL; + } + + edgePool.freeObject(edge); + edgePool.freeObject(r); + usedEdgePairs--; + } + + void computeInternal(int start, int end, IntermediateHull& result); + + bool mergeProjection(IntermediateHull& h0, IntermediateHull& h1, Vertex*& c0, Vertex*& c1); + + void merge(IntermediateHull& h0, IntermediateHull& h1); + + btVector3 toBtVector(const Point32& v); + + btVector3 getBtNormal(Face* face); + + bool shiftFace(Face* face, btScalar amount, btAlignedObjectArray stack); + +public: + Vertex* vertexList; + + void compute(const void* coords, bool doubleCoords, int stride, int count); + + btVector3 getCoordinates(const Vertex* v); + + btScalar shrink(btScalar amount, btScalar clampAmount); +}; + +btConvexHullInternal::Int128 btConvexHullInternal::Int128::operator*(int64_t b) const +{ + bool negative = (int64_t)high < 0; + Int128 a = negative ? -*this : *this; + if (b < 0) + { + negative = !negative; + b = -b; + } + Int128 result = mul(a.low, (uint64_t)b); + result.high += a.high * (uint64_t)b; + return negative ? -result : result; +} + +btConvexHullInternal::Int128 btConvexHullInternal::Int128::mul(int64_t a, int64_t b) +{ + Int128 result; + +#ifdef USE_X86_64_ASM + __asm__("imulq %[b]" + : "=a"(result.low), "=d"(result.high) + : "0"(a), [b] "r"(b) + : "cc"); + return result; + +#else + bool negative = a < 0; + if (negative) + { + a = -a; + } + if (b < 0) + { + negative = !negative; + b = -b; + } + DMul::mul((uint64_t)a, (uint64_t)b, result.low, result.high); + return negative ? -result : result; +#endif +} + +btConvexHullInternal::Int128 btConvexHullInternal::Int128::mul(uint64_t a, uint64_t b) +{ + Int128 result; + +#ifdef USE_X86_64_ASM + __asm__("mulq %[b]" + : "=a"(result.low), "=d"(result.high) + : "0"(a), [b] "r"(b) + : "cc"); + +#else + DMul::mul(a, b, result.low, result.high); +#endif + + return result; +} + +int btConvexHullInternal::Rational64::compare(const Rational64& b) const +{ + if (sign != b.sign) + { + return sign - b.sign; + } + else if (sign == 0) + { + return 0; + } + + // return (numerator * b.denominator > b.numerator * denominator) ? sign : (numerator * b.denominator < b.numerator * denominator) ? -sign : 0; + +#ifdef USE_X86_64_ASM + + int result; + int64_t tmp; + int64_t dummy; + __asm__( + "mulq %[bn]\n\t" + "movq %%rax, %[tmp]\n\t" + "movq %%rdx, %%rbx\n\t" + "movq %[tn], %%rax\n\t" + "mulq %[bd]\n\t" + "subq %[tmp], %%rax\n\t" + "sbbq %%rbx, %%rdx\n\t" // rdx:rax contains 128-bit-difference "numerator*b.denominator - b.numerator*denominator" + "setnsb %%bh\n\t" // bh=1 if difference is non-negative, bh=0 otherwise + "orq %%rdx, %%rax\n\t" + "setnzb %%bl\n\t" // bl=1 if difference if non-zero, bl=0 if it is zero + "decb %%bh\n\t" // now bx=0x0000 if difference is zero, 0xff01 if it is negative, 0x0001 if it is positive (i.e., same sign as difference) + "shll $16, %%ebx\n\t" // ebx has same sign as difference + : "=&b"(result), [tmp] "=&r"(tmp), "=a"(dummy) + : "a"(m_denominator), [bn] "g"(b.m_numerator), [tn] "g"(m_numerator), [bd] "g"(b.m_denominator) + : "%rdx", "cc"); + return result ? result ^ sign // if sign is +1, only bit 0 of result is inverted, which does not change the sign of result (and cannot result in zero) + // if sign is -1, all bits of result are inverted, which changes the sign of result (and again cannot result in zero) + : 0; + +#else + + return sign * Int128::mul(m_numerator, b.m_denominator).ucmp(Int128::mul(m_denominator, b.m_numerator)); + +#endif +} + +int btConvexHullInternal::Rational128::compare(const Rational128& b) const +{ + if (sign != b.sign) + { + return sign - b.sign; + } + else if (sign == 0) + { + return 0; + } + if (isInt64) + { + return -b.compare(sign * (int64_t)numerator.low); + } + + Int128 nbdLow, nbdHigh, dbnLow, dbnHigh; + DMul::mul(numerator, b.denominator, nbdLow, nbdHigh); + DMul::mul(denominator, b.numerator, dbnLow, dbnHigh); + + int cmp = nbdHigh.ucmp(dbnHigh); + if (cmp) + { + return cmp * sign; + } + return nbdLow.ucmp(dbnLow) * sign; +} + +int btConvexHullInternal::Rational128::compare(int64_t b) const +{ + if (isInt64) + { + int64_t a = sign * (int64_t)numerator.low; + return (a > b) ? 1 : (a < b) ? -1 : 0; + } + if (b > 0) + { + if (sign <= 0) + { + return -1; + } + } + else if (b < 0) + { + if (sign >= 0) + { + return 1; + } + b = -b; + } + else + { + return sign; + } + + return numerator.ucmp(denominator * b) * sign; +} + +btConvexHullInternal::Edge* btConvexHullInternal::newEdgePair(Vertex* from, Vertex* to) +{ + btAssert(from && to); + Edge* e = edgePool.newObject(); + Edge* r = edgePool.newObject(); + e->reverse = r; + r->reverse = e; + e->copy = mergeStamp; + r->copy = mergeStamp; + e->target = to; + r->target = from; + e->face = NULL; + r->face = NULL; + usedEdgePairs++; + if (usedEdgePairs > maxUsedEdgePairs) + { + maxUsedEdgePairs = usedEdgePairs; + } + return e; +} + +bool btConvexHullInternal::mergeProjection(IntermediateHull& h0, IntermediateHull& h1, Vertex*& c0, Vertex*& c1) +{ + Vertex* v0 = h0.maxYx; + Vertex* v1 = h1.minYx; + if ((v0->point.x == v1->point.x) && (v0->point.y == v1->point.y)) + { + btAssert(v0->point.z < v1->point.z); + Vertex* v1p = v1->prev; + if (v1p == v1) + { + c0 = v0; + if (v1->edges) + { + btAssert(v1->edges->next == v1->edges); + v1 = v1->edges->target; + btAssert(v1->edges->next == v1->edges); + } + c1 = v1; + return false; + } + Vertex* v1n = v1->next; + v1p->next = v1n; + v1n->prev = v1p; + if (v1 == h1.minXy) + { + if ((v1n->point.x < v1p->point.x) || ((v1n->point.x == v1p->point.x) && (v1n->point.y < v1p->point.y))) + { + h1.minXy = v1n; + } + else + { + h1.minXy = v1p; + } + } + if (v1 == h1.maxXy) + { + if ((v1n->point.x > v1p->point.x) || ((v1n->point.x == v1p->point.x) && (v1n->point.y > v1p->point.y))) + { + h1.maxXy = v1n; + } + else + { + h1.maxXy = v1p; + } + } + } + + v0 = h0.maxXy; + v1 = h1.maxXy; + Vertex* v00 = NULL; + Vertex* v10 = NULL; + int32_t sign = 1; + + for (int side = 0; side <= 1; side++) + { + int32_t dx = (v1->point.x - v0->point.x) * sign; + if (dx > 0) + { + while (true) + { + int32_t dy = v1->point.y - v0->point.y; + + Vertex* w0 = side ? v0->next : v0->prev; + if (w0 != v0) + { + int32_t dx0 = (w0->point.x - v0->point.x) * sign; + int32_t dy0 = w0->point.y - v0->point.y; + if ((dy0 <= 0) && ((dx0 == 0) || ((dx0 < 0) && (dy0 * dx <= dy * dx0)))) + { + v0 = w0; + dx = (v1->point.x - v0->point.x) * sign; + continue; + } + } + + Vertex* w1 = side ? v1->next : v1->prev; + if (w1 != v1) + { + int32_t dx1 = (w1->point.x - v1->point.x) * sign; + int32_t dy1 = w1->point.y - v1->point.y; + int32_t dxn = (w1->point.x - v0->point.x) * sign; + if ((dxn > 0) && (dy1 < 0) && ((dx1 == 0) || ((dx1 < 0) && (dy1 * dx < dy * dx1)))) + { + v1 = w1; + dx = dxn; + continue; + } + } + + break; + } + } + else if (dx < 0) + { + while (true) + { + int32_t dy = v1->point.y - v0->point.y; + + Vertex* w1 = side ? v1->prev : v1->next; + if (w1 != v1) + { + int32_t dx1 = (w1->point.x - v1->point.x) * sign; + int32_t dy1 = w1->point.y - v1->point.y; + if ((dy1 >= 0) && ((dx1 == 0) || ((dx1 < 0) && (dy1 * dx <= dy * dx1)))) + { + v1 = w1; + dx = (v1->point.x - v0->point.x) * sign; + continue; + } + } + + Vertex* w0 = side ? v0->prev : v0->next; + if (w0 != v0) + { + int32_t dx0 = (w0->point.x - v0->point.x) * sign; + int32_t dy0 = w0->point.y - v0->point.y; + int32_t dxn = (v1->point.x - w0->point.x) * sign; + if ((dxn < 0) && (dy0 > 0) && ((dx0 == 0) || ((dx0 < 0) && (dy0 * dx < dy * dx0)))) + { + v0 = w0; + dx = dxn; + continue; + } + } + + break; + } + } + else + { + int32_t x = v0->point.x; + int32_t y0 = v0->point.y; + Vertex* w0 = v0; + Vertex* t; + while (((t = side ? w0->next : w0->prev) != v0) && (t->point.x == x) && (t->point.y <= y0)) + { + w0 = t; + y0 = t->point.y; + } + v0 = w0; + + int32_t y1 = v1->point.y; + Vertex* w1 = v1; + while (((t = side ? w1->prev : w1->next) != v1) && (t->point.x == x) && (t->point.y >= y1)) + { + w1 = t; + y1 = t->point.y; + } + v1 = w1; + } + + if (side == 0) + { + v00 = v0; + v10 = v1; + + v0 = h0.minXy; + v1 = h1.minXy; + sign = -1; + } + } + + v0->prev = v1; + v1->next = v0; + + v00->next = v10; + v10->prev = v00; + + if (h1.minXy->point.x < h0.minXy->point.x) + { + h0.minXy = h1.minXy; + } + if (h1.maxXy->point.x >= h0.maxXy->point.x) + { + h0.maxXy = h1.maxXy; + } + + h0.maxYx = h1.maxYx; + + c0 = v00; + c1 = v10; + + return true; +} + +void btConvexHullInternal::computeInternal(int start, int end, IntermediateHull& result) +{ + int n = end - start; + switch (n) + { + case 0: + result.minXy = NULL; + result.maxXy = NULL; + result.minYx = NULL; + result.maxYx = NULL; + return; + case 2: + { + Vertex* v = originalVertices[start]; + Vertex* w = v + 1; + if (v->point != w->point) + { + int32_t dx = v->point.x - w->point.x; + int32_t dy = v->point.y - w->point.y; + + if ((dx == 0) && (dy == 0)) + { + if (v->point.z > w->point.z) + { + Vertex* t = w; + w = v; + v = t; + } + btAssert(v->point.z < w->point.z); + v->next = v; + v->prev = v; + result.minXy = v; + result.maxXy = v; + result.minYx = v; + result.maxYx = v; + } + else + { + v->next = w; + v->prev = w; + w->next = v; + w->prev = v; + + if ((dx < 0) || ((dx == 0) && (dy < 0))) + { + result.minXy = v; + result.maxXy = w; + } + else + { + result.minXy = w; + result.maxXy = v; + } + + if ((dy < 0) || ((dy == 0) && (dx < 0))) + { + result.minYx = v; + result.maxYx = w; + } + else + { + result.minYx = w; + result.maxYx = v; + } + } + + Edge* e = newEdgePair(v, w); + e->link(e); + v->edges = e; + + e = e->reverse; + e->link(e); + w->edges = e; + + return; + } + { + Vertex* v = originalVertices[start]; + v->edges = NULL; + v->next = v; + v->prev = v; + + result.minXy = v; + result.maxXy = v; + result.minYx = v; + result.maxYx = v; + } + + return; + } + + case 1: + { + Vertex* v = originalVertices[start]; + v->edges = NULL; + v->next = v; + v->prev = v; + + result.minXy = v; + result.maxXy = v; + result.minYx = v; + result.maxYx = v; + + return; + } + } + + int split0 = start + n / 2; + Point32 p = originalVertices[split0 - 1]->point; + int split1 = split0; + while ((split1 < end) && (originalVertices[split1]->point == p)) + { + split1++; + } + computeInternal(start, split0, result); + IntermediateHull hull1; + computeInternal(split1, end, hull1); +#ifdef DEBUG_CONVEX_HULL + printf("\n\nMerge\n"); + result.print(); + hull1.print(); +#endif + merge(result, hull1); +#ifdef DEBUG_CONVEX_HULL + printf("\n Result\n"); + result.print(); +#endif +} + +#ifdef DEBUG_CONVEX_HULL +void btConvexHullInternal::IntermediateHull::print() +{ + printf(" Hull\n"); + for (Vertex* v = minXy; v;) + { + printf(" "); + v->print(); + if (v == maxXy) + { + printf(" maxXy"); + } + if (v == minYx) + { + printf(" minYx"); + } + if (v == maxYx) + { + printf(" maxYx"); + } + if (v->next->prev != v) + { + printf(" Inconsistency"); + } + printf("\n"); + v = v->next; + if (v == minXy) + { + break; + } + } + if (minXy) + { + minXy->copy = (minXy->copy == -1) ? -2 : -1; + minXy->printGraph(); + } +} + +void btConvexHullInternal::Vertex::printGraph() +{ + print(); + printf("\nEdges\n"); + Edge* e = edges; + if (e) + { + do + { + e->print(); + printf("\n"); + e = e->next; + } while (e != edges); + do + { + Vertex* v = e->target; + if (v->copy != copy) + { + v->copy = copy; + v->printGraph(); + } + e = e->next; + } while (e != edges); + } +} +#endif + +btConvexHullInternal::Orientation btConvexHullInternal::getOrientation(const Edge* prev, const Edge* next, const Point32& s, const Point32& t) +{ + btAssert(prev->reverse->target == next->reverse->target); + if (prev->next == next) + { + if (prev->prev == next) + { + Point64 n = t.cross(s); + Point64 m = (*prev->target - *next->reverse->target).cross(*next->target - *next->reverse->target); + btAssert(!m.isZero()); + int64_t dot = n.dot(m); + btAssert(dot != 0); + return (dot > 0) ? COUNTER_CLOCKWISE : CLOCKWISE; + } + return COUNTER_CLOCKWISE; + } + else if (prev->prev == next) + { + return CLOCKWISE; + } + else + { + return NONE; + } +} + +btConvexHullInternal::Edge* btConvexHullInternal::findMaxAngle(bool ccw, const Vertex* start, const Point32& s, const Point64& rxs, const Point64& sxrxs, Rational64& minCot) +{ + Edge* minEdge = NULL; + +#ifdef DEBUG_CONVEX_HULL + printf("find max edge for %d\n", start->point.index); +#endif + Edge* e = start->edges; + if (e) + { + do + { + if (e->copy > mergeStamp) + { + Point32 t = *e->target - *start; + Rational64 cot(t.dot(sxrxs), t.dot(rxs)); +#ifdef DEBUG_CONVEX_HULL + printf(" Angle is %f (%d) for ", (float)btAtan(cot.toScalar()), (int)cot.isNaN()); + e->print(); +#endif + if (cot.isNaN()) + { + btAssert(ccw ? (t.dot(s) < 0) : (t.dot(s) > 0)); + } + else + { + int cmp; + if (minEdge == NULL) + { + minCot = cot; + minEdge = e; + } + else if ((cmp = cot.compare(minCot)) < 0) + { + minCot = cot; + minEdge = e; + } + else if ((cmp == 0) && (ccw == (getOrientation(minEdge, e, s, t) == COUNTER_CLOCKWISE))) + { + minEdge = e; + } + } +#ifdef DEBUG_CONVEX_HULL + printf("\n"); +#endif + } + e = e->next; + } while (e != start->edges); + } + return minEdge; +} + +void btConvexHullInternal::findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge*& e0, Edge*& e1, Vertex* stop0, Vertex* stop1) +{ + Edge* start0 = e0; + Edge* start1 = e1; + Point32 et0 = start0 ? start0->target->point : c0->point; + Point32 et1 = start1 ? start1->target->point : c1->point; + Point32 s = c1->point - c0->point; + Point64 normal = ((start0 ? start0 : start1)->target->point - c0->point).cross(s); + int64_t dist = c0->point.dot(normal); + btAssert(!start1 || (start1->target->point.dot(normal) == dist)); + Point64 perp = s.cross(normal); + btAssert(!perp.isZero()); + +#ifdef DEBUG_CONVEX_HULL + printf(" Advancing %d %d (%p %p, %d %d)\n", c0->point.index, c1->point.index, start0, start1, start0 ? start0->target->point.index : -1, start1 ? start1->target->point.index : -1); +#endif + + int64_t maxDot0 = et0.dot(perp); + if (e0) + { + while (e0->target != stop0) + { + Edge* e = e0->reverse->prev; + if (e->target->point.dot(normal) < dist) + { + break; + } + btAssert(e->target->point.dot(normal) == dist); + if (e->copy == mergeStamp) + { + break; + } + int64_t dot = e->target->point.dot(perp); + if (dot <= maxDot0) + { + break; + } + maxDot0 = dot; + e0 = e; + et0 = e->target->point; + } + } + + int64_t maxDot1 = et1.dot(perp); + if (e1) + { + while (e1->target != stop1) + { + Edge* e = e1->reverse->next; + if (e->target->point.dot(normal) < dist) + { + break; + } + btAssert(e->target->point.dot(normal) == dist); + if (e->copy == mergeStamp) + { + break; + } + int64_t dot = e->target->point.dot(perp); + if (dot <= maxDot1) + { + break; + } + maxDot1 = dot; + e1 = e; + et1 = e->target->point; + } + } + +#ifdef DEBUG_CONVEX_HULL + printf(" Starting at %d %d\n", et0.index, et1.index); +#endif + + int64_t dx = maxDot1 - maxDot0; + if (dx > 0) + { + while (true) + { + int64_t dy = (et1 - et0).dot(s); + + if (e0 && (e0->target != stop0)) + { + Edge* f0 = e0->next->reverse; + if (f0->copy > mergeStamp) + { + int64_t dx0 = (f0->target->point - et0).dot(perp); + int64_t dy0 = (f0->target->point - et0).dot(s); + if ((dx0 == 0) ? (dy0 < 0) : ((dx0 < 0) && (Rational64(dy0, dx0).compare(Rational64(dy, dx)) >= 0))) + { + et0 = f0->target->point; + dx = (et1 - et0).dot(perp); + e0 = (e0 == start0) ? NULL : f0; + continue; + } + } + } + + if (e1 && (e1->target != stop1)) + { + Edge* f1 = e1->reverse->next; + if (f1->copy > mergeStamp) + { + Point32 d1 = f1->target->point - et1; + if (d1.dot(normal) == 0) + { + int64_t dx1 = d1.dot(perp); + int64_t dy1 = d1.dot(s); + int64_t dxn = (f1->target->point - et0).dot(perp); + if ((dxn > 0) && ((dx1 == 0) ? (dy1 < 0) : ((dx1 < 0) && (Rational64(dy1, dx1).compare(Rational64(dy, dx)) > 0)))) + { + e1 = f1; + et1 = e1->target->point; + dx = dxn; + continue; + } + } + else + { + btAssert((e1 == start1) && (d1.dot(normal) < 0)); + } + } + } + + break; + } + } + else if (dx < 0) + { + while (true) + { + int64_t dy = (et1 - et0).dot(s); + + if (e1 && (e1->target != stop1)) + { + Edge* f1 = e1->prev->reverse; + if (f1->copy > mergeStamp) + { + int64_t dx1 = (f1->target->point - et1).dot(perp); + int64_t dy1 = (f1->target->point - et1).dot(s); + if ((dx1 == 0) ? (dy1 > 0) : ((dx1 < 0) && (Rational64(dy1, dx1).compare(Rational64(dy, dx)) <= 0))) + { + et1 = f1->target->point; + dx = (et1 - et0).dot(perp); + e1 = (e1 == start1) ? NULL : f1; + continue; + } + } + } + + if (e0 && (e0->target != stop0)) + { + Edge* f0 = e0->reverse->prev; + if (f0->copy > mergeStamp) + { + Point32 d0 = f0->target->point - et0; + if (d0.dot(normal) == 0) + { + int64_t dx0 = d0.dot(perp); + int64_t dy0 = d0.dot(s); + int64_t dxn = (et1 - f0->target->point).dot(perp); + if ((dxn < 0) && ((dx0 == 0) ? (dy0 > 0) : ((dx0 < 0) && (Rational64(dy0, dx0).compare(Rational64(dy, dx)) < 0)))) + { + e0 = f0; + et0 = e0->target->point; + dx = dxn; + continue; + } + } + else + { + btAssert((e0 == start0) && (d0.dot(normal) < 0)); + } + } + } + + break; + } + } +#ifdef DEBUG_CONVEX_HULL + printf(" Advanced edges to %d %d\n", et0.index, et1.index); +#endif +} + +void btConvexHullInternal::merge(IntermediateHull& h0, IntermediateHull& h1) +{ + if (!h1.maxXy) + { + return; + } + if (!h0.maxXy) + { + h0 = h1; + return; + } + + mergeStamp--; + + Vertex* c0 = NULL; + Edge* toPrev0 = NULL; + Edge* firstNew0 = NULL; + Edge* pendingHead0 = NULL; + Edge* pendingTail0 = NULL; + Vertex* c1 = NULL; + Edge* toPrev1 = NULL; + Edge* firstNew1 = NULL; + Edge* pendingHead1 = NULL; + Edge* pendingTail1 = NULL; + Point32 prevPoint; + + if (mergeProjection(h0, h1, c0, c1)) + { + Point32 s = *c1 - *c0; + Point64 normal = Point32(0, 0, -1).cross(s); + Point64 t = s.cross(normal); + btAssert(!t.isZero()); + + Edge* e = c0->edges; + Edge* start0 = NULL; + if (e) + { + do + { + int64_t dot = (*e->target - *c0).dot(normal); + btAssert(dot <= 0); + if ((dot == 0) && ((*e->target - *c0).dot(t) > 0)) + { + if (!start0 || (getOrientation(start0, e, s, Point32(0, 0, -1)) == CLOCKWISE)) + { + start0 = e; + } + } + e = e->next; + } while (e != c0->edges); + } + + e = c1->edges; + Edge* start1 = NULL; + if (e) + { + do + { + int64_t dot = (*e->target - *c1).dot(normal); + btAssert(dot <= 0); + if ((dot == 0) && ((*e->target - *c1).dot(t) > 0)) + { + if (!start1 || (getOrientation(start1, e, s, Point32(0, 0, -1)) == COUNTER_CLOCKWISE)) + { + start1 = e; + } + } + e = e->next; + } while (e != c1->edges); + } + + if (start0 || start1) + { + findEdgeForCoplanarFaces(c0, c1, start0, start1, NULL, NULL); + if (start0) + { + c0 = start0->target; + } + if (start1) + { + c1 = start1->target; + } + } + + prevPoint = c1->point; + prevPoint.z++; + } + else + { + prevPoint = c1->point; + prevPoint.x++; + } + + Vertex* first0 = c0; + Vertex* first1 = c1; + bool firstRun = true; + + while (true) + { + Point32 s = *c1 - *c0; + Point32 r = prevPoint - c0->point; + Point64 rxs = r.cross(s); + Point64 sxrxs = s.cross(rxs); + +#ifdef DEBUG_CONVEX_HULL + printf("\n Checking %d %d\n", c0->point.index, c1->point.index); +#endif + Rational64 minCot0(0, 0); + Edge* min0 = findMaxAngle(false, c0, s, rxs, sxrxs, minCot0); + Rational64 minCot1(0, 0); + Edge* min1 = findMaxAngle(true, c1, s, rxs, sxrxs, minCot1); + if (!min0 && !min1) + { + Edge* e = newEdgePair(c0, c1); + e->link(e); + c0->edges = e; + + e = e->reverse; + e->link(e); + c1->edges = e; + return; + } + else + { + int cmp = !min0 ? 1 : !min1 ? -1 : minCot0.compare(minCot1); +#ifdef DEBUG_CONVEX_HULL + printf(" -> Result %d\n", cmp); +#endif + if (firstRun || ((cmp >= 0) ? !minCot1.isNegativeInfinity() : !minCot0.isNegativeInfinity())) + { + Edge* e = newEdgePair(c0, c1); + if (pendingTail0) + { + pendingTail0->prev = e; + } + else + { + pendingHead0 = e; + } + e->next = pendingTail0; + pendingTail0 = e; + + e = e->reverse; + if (pendingTail1) + { + pendingTail1->next = e; + } + else + { + pendingHead1 = e; + } + e->prev = pendingTail1; + pendingTail1 = e; + } + + Edge* e0 = min0; + Edge* e1 = min1; + +#ifdef DEBUG_CONVEX_HULL + printf(" Found min edges to %d %d\n", e0 ? e0->target->point.index : -1, e1 ? e1->target->point.index : -1); +#endif + + if (cmp == 0) + { + findEdgeForCoplanarFaces(c0, c1, e0, e1, NULL, NULL); + } + + if ((cmp >= 0) && e1) + { + if (toPrev1) + { + for (Edge *e = toPrev1->next, *n = NULL; e != min1; e = n) + { + n = e->next; + removeEdgePair(e); + } + } + + if (pendingTail1) + { + if (toPrev1) + { + toPrev1->link(pendingHead1); + } + else + { + min1->prev->link(pendingHead1); + firstNew1 = pendingHead1; + } + pendingTail1->link(min1); + pendingHead1 = NULL; + pendingTail1 = NULL; + } + else if (!toPrev1) + { + firstNew1 = min1; + } + + prevPoint = c1->point; + c1 = e1->target; + toPrev1 = e1->reverse; + } + + if ((cmp <= 0) && e0) + { + if (toPrev0) + { + for (Edge *e = toPrev0->prev, *n = NULL; e != min0; e = n) + { + n = e->prev; + removeEdgePair(e); + } + } + + if (pendingTail0) + { + if (toPrev0) + { + pendingHead0->link(toPrev0); + } + else + { + pendingHead0->link(min0->next); + firstNew0 = pendingHead0; + } + min0->link(pendingTail0); + pendingHead0 = NULL; + pendingTail0 = NULL; + } + else if (!toPrev0) + { + firstNew0 = min0; + } + + prevPoint = c0->point; + c0 = e0->target; + toPrev0 = e0->reverse; + } + } + + if ((c0 == first0) && (c1 == first1)) + { + if (toPrev0 == NULL) + { + pendingHead0->link(pendingTail0); + c0->edges = pendingTail0; + } + else + { + for (Edge *e = toPrev0->prev, *n = NULL; e != firstNew0; e = n) + { + n = e->prev; + removeEdgePair(e); + } + if (pendingTail0) + { + pendingHead0->link(toPrev0); + firstNew0->link(pendingTail0); + } + } + + if (toPrev1 == NULL) + { + pendingTail1->link(pendingHead1); + c1->edges = pendingTail1; + } + else + { + for (Edge *e = toPrev1->next, *n = NULL; e != firstNew1; e = n) + { + n = e->next; + removeEdgePair(e); + } + if (pendingTail1) + { + toPrev1->link(pendingHead1); + pendingTail1->link(firstNew1); + } + } + + return; + } + + firstRun = false; + } +} + +class pointCmp +{ +public: + bool operator()(const btConvexHullInternal::Point32& p, const btConvexHullInternal::Point32& q) const + { + return (p.y < q.y) || ((p.y == q.y) && ((p.x < q.x) || ((p.x == q.x) && (p.z < q.z)))); + } +}; + +void btConvexHullInternal::compute(const void* coords, bool doubleCoords, int stride, int count) +{ + btVector3 min(btScalar(1e30), btScalar(1e30), btScalar(1e30)), max(btScalar(-1e30), btScalar(-1e30), btScalar(-1e30)); + const char* ptr = (const char*)coords; + if (doubleCoords) + { + for (int i = 0; i < count; i++) + { + const double* v = (const double*)ptr; + btVector3 p((btScalar)v[0], (btScalar)v[1], (btScalar)v[2]); + ptr += stride; + min.setMin(p); + max.setMax(p); + } + } + else + { + for (int i = 0; i < count; i++) + { + const float* v = (const float*)ptr; + btVector3 p(v[0], v[1], v[2]); + ptr += stride; + min.setMin(p); + max.setMax(p); + } + } + + btVector3 s = max - min; + maxAxis = s.maxAxis(); + minAxis = s.minAxis(); + if (minAxis == maxAxis) + { + minAxis = (maxAxis + 1) % 3; + } + medAxis = 3 - maxAxis - minAxis; + + s /= btScalar(10216); + if (((medAxis + 1) % 3) != maxAxis) + { + s *= -1; + } + scaling = s; + + if (s[0] != 0) + { + s[0] = btScalar(1) / s[0]; + } + if (s[1] != 0) + { + s[1] = btScalar(1) / s[1]; + } + if (s[2] != 0) + { + s[2] = btScalar(1) / s[2]; + } + + center = (min + max) * btScalar(0.5); + + btAlignedObjectArray points; + points.resize(count); + ptr = (const char*)coords; + if (doubleCoords) + { + for (int i = 0; i < count; i++) + { + const double* v = (const double*)ptr; + btVector3 p((btScalar)v[0], (btScalar)v[1], (btScalar)v[2]); + ptr += stride; + p = (p - center) * s; + points[i].x = (int32_t)p[medAxis]; + points[i].y = (int32_t)p[maxAxis]; + points[i].z = (int32_t)p[minAxis]; + points[i].index = i; + } + } + else + { + for (int i = 0; i < count; i++) + { + const float* v = (const float*)ptr; + btVector3 p(v[0], v[1], v[2]); + ptr += stride; + p = (p - center) * s; + points[i].x = (int32_t)p[medAxis]; + points[i].y = (int32_t)p[maxAxis]; + points[i].z = (int32_t)p[minAxis]; + points[i].index = i; + } + } + points.quickSort(pointCmp()); + + vertexPool.reset(); + vertexPool.setArraySize(count); + originalVertices.resize(count); + for (int i = 0; i < count; i++) + { + Vertex* v = vertexPool.newObject(); + v->edges = NULL; + v->point = points[i]; + v->copy = -1; + originalVertices[i] = v; + } + + points.clear(); + + edgePool.reset(); + edgePool.setArraySize(6 * count); + + usedEdgePairs = 0; + maxUsedEdgePairs = 0; + + mergeStamp = -3; + + IntermediateHull hull; + computeInternal(0, count, hull); + vertexList = hull.minXy; +#ifdef DEBUG_CONVEX_HULL + printf("max. edges %d (3v = %d)", maxUsedEdgePairs, 3 * count); +#endif +} + +btVector3 btConvexHullInternal::toBtVector(const Point32& v) +{ + btVector3 p; + p[medAxis] = btScalar(v.x); + p[maxAxis] = btScalar(v.y); + p[minAxis] = btScalar(v.z); + return p * scaling; +} + +btVector3 btConvexHullInternal::getBtNormal(Face* face) +{ + return toBtVector(face->dir0).cross(toBtVector(face->dir1)).normalized(); +} + +btVector3 btConvexHullInternal::getCoordinates(const Vertex* v) +{ + btVector3 p; + p[medAxis] = v->xvalue(); + p[maxAxis] = v->yvalue(); + p[minAxis] = v->zvalue(); + return p * scaling + center; +} + +btScalar btConvexHullInternal::shrink(btScalar amount, btScalar clampAmount) +{ + if (!vertexList) + { + return 0; + } + int stamp = --mergeStamp; + btAlignedObjectArray stack; + vertexList->copy = stamp; + stack.push_back(vertexList); + btAlignedObjectArray faces; + + Point32 ref = vertexList->point; + Int128 hullCenterX(0, 0); + Int128 hullCenterY(0, 0); + Int128 hullCenterZ(0, 0); + Int128 volume(0, 0); + + while (stack.size() > 0) + { + Vertex* v = stack[stack.size() - 1]; + stack.pop_back(); + Edge* e = v->edges; + if (e) + { + do + { + if (e->target->copy != stamp) + { + e->target->copy = stamp; + stack.push_back(e->target); + } + if (e->copy != stamp) + { + Face* face = facePool.newObject(); + face->init(e->target, e->reverse->prev->target, v); + faces.push_back(face); + Edge* f = e; + + Vertex* a = NULL; + Vertex* b = NULL; + do + { + if (a && b) + { + int64_t vol = (v->point - ref).dot((a->point - ref).cross(b->point - ref)); + btAssert(vol >= 0); + Point32 c = v->point + a->point + b->point + ref; + hullCenterX += vol * c.x; + hullCenterY += vol * c.y; + hullCenterZ += vol * c.z; + volume += vol; + } + + btAssert(f->copy != stamp); + f->copy = stamp; + f->face = face; + + a = b; + b = f->target; + + f = f->reverse->prev; + } while (f != e); + } + e = e->next; + } while (e != v->edges); + } + } + + if (volume.getSign() <= 0) + { + return 0; + } + + btVector3 hullCenter; + hullCenter[medAxis] = hullCenterX.toScalar(); + hullCenter[maxAxis] = hullCenterY.toScalar(); + hullCenter[minAxis] = hullCenterZ.toScalar(); + hullCenter /= 4 * volume.toScalar(); + hullCenter *= scaling; + + int faceCount = faces.size(); + + if (clampAmount > 0) + { + btScalar minDist = SIMD_INFINITY; + for (int i = 0; i < faceCount; i++) + { + btVector3 normal = getBtNormal(faces[i]); + btScalar dist = normal.dot(toBtVector(faces[i]->origin) - hullCenter); + if (dist < minDist) + { + minDist = dist; + } + } + + if (minDist <= 0) + { + return 0; + } + + amount = btMin(amount, minDist * clampAmount); + } + + unsigned int seed = 243703; + for (int i = 0; i < faceCount; i++, seed = 1664525 * seed + 1013904223) + { + btSwap(faces[i], faces[seed % faceCount]); + } + + for (int i = 0; i < faceCount; i++) + { + if (!shiftFace(faces[i], amount, stack)) + { + return -amount; + } + } + + return amount; +} + +bool btConvexHullInternal::shiftFace(Face* face, btScalar amount, btAlignedObjectArray stack) +{ + btVector3 origShift = getBtNormal(face) * -amount; + if (scaling[0] != 0) + { + origShift[0] /= scaling[0]; + } + if (scaling[1] != 0) + { + origShift[1] /= scaling[1]; + } + if (scaling[2] != 0) + { + origShift[2] /= scaling[2]; + } + Point32 shift((int32_t)origShift[medAxis], (int32_t)origShift[maxAxis], (int32_t)origShift[minAxis]); + if (shift.isZero()) + { + return true; + } + Point64 normal = face->getNormal(); +#ifdef DEBUG_CONVEX_HULL + printf("\nShrinking face (%d %d %d) (%d %d %d) (%d %d %d) by (%d %d %d)\n", + face->origin.x, face->origin.y, face->origin.z, face->dir0.x, face->dir0.y, face->dir0.z, face->dir1.x, face->dir1.y, face->dir1.z, shift.x, shift.y, shift.z); +#endif + int64_t origDot = face->origin.dot(normal); + Point32 shiftedOrigin = face->origin + shift; + int64_t shiftedDot = shiftedOrigin.dot(normal); + btAssert(shiftedDot <= origDot); + if (shiftedDot >= origDot) + { + return false; + } + + Edge* intersection = NULL; + + Edge* startEdge = face->nearbyVertex->edges; +#ifdef DEBUG_CONVEX_HULL + printf("Start edge is "); + startEdge->print(); + printf(", normal is (%lld %lld %lld), shifted dot is %lld\n", normal.x, normal.y, normal.z, shiftedDot); +#endif + Rational128 optDot = face->nearbyVertex->dot(normal); + int cmp = optDot.compare(shiftedDot); +#ifdef SHOW_ITERATIONS + int n = 0; +#endif + if (cmp >= 0) + { + Edge* e = startEdge; + do + { +#ifdef SHOW_ITERATIONS + n++; +#endif + Rational128 dot = e->target->dot(normal); + btAssert(dot.compare(origDot) <= 0); +#ifdef DEBUG_CONVEX_HULL + printf("Moving downwards, edge is "); + e->print(); + printf(", dot is %f (%f %lld)\n", (float)dot.toScalar(), (float)optDot.toScalar(), shiftedDot); +#endif + if (dot.compare(optDot) < 0) + { + int c = dot.compare(shiftedDot); + optDot = dot; + e = e->reverse; + startEdge = e; + if (c < 0) + { + intersection = e; + break; + } + cmp = c; + } + e = e->prev; + } while (e != startEdge); + + if (!intersection) + { + return false; + } + } + else + { + Edge* e = startEdge; + do + { +#ifdef SHOW_ITERATIONS + n++; +#endif + Rational128 dot = e->target->dot(normal); + btAssert(dot.compare(origDot) <= 0); +#ifdef DEBUG_CONVEX_HULL + printf("Moving upwards, edge is "); + e->print(); + printf(", dot is %f (%f %lld)\n", (float)dot.toScalar(), (float)optDot.toScalar(), shiftedDot); +#endif + if (dot.compare(optDot) > 0) + { + cmp = dot.compare(shiftedDot); + if (cmp >= 0) + { + intersection = e; + break; + } + optDot = dot; + e = e->reverse; + startEdge = e; + } + e = e->prev; + } while (e != startEdge); + + if (!intersection) + { + return true; + } + } + +#ifdef SHOW_ITERATIONS + printf("Needed %d iterations to find initial intersection\n", n); +#endif + + if (cmp == 0) + { + Edge* e = intersection->reverse->next; +#ifdef SHOW_ITERATIONS + n = 0; +#endif + while (e->target->dot(normal).compare(shiftedDot) <= 0) + { +#ifdef SHOW_ITERATIONS + n++; +#endif + e = e->next; + if (e == intersection->reverse) + { + return true; + } +#ifdef DEBUG_CONVEX_HULL + printf("Checking for outwards edge, current edge is "); + e->print(); + printf("\n"); +#endif + } +#ifdef SHOW_ITERATIONS + printf("Needed %d iterations to check for complete containment\n", n); +#endif + } + + Edge* firstIntersection = NULL; + Edge* faceEdge = NULL; + Edge* firstFaceEdge = NULL; + +#ifdef SHOW_ITERATIONS + int m = 0; +#endif + while (true) + { +#ifdef SHOW_ITERATIONS + m++; +#endif +#ifdef DEBUG_CONVEX_HULL + printf("Intersecting edge is "); + intersection->print(); + printf("\n"); +#endif + if (cmp == 0) + { + Edge* e = intersection->reverse->next; + startEdge = e; +#ifdef SHOW_ITERATIONS + n = 0; +#endif + while (true) + { +#ifdef SHOW_ITERATIONS + n++; +#endif + if (e->target->dot(normal).compare(shiftedDot) >= 0) + { + break; + } + intersection = e->reverse; + e = e->next; + if (e == startEdge) + { + return true; + } + } +#ifdef SHOW_ITERATIONS + printf("Needed %d iterations to advance intersection\n", n); +#endif + } + +#ifdef DEBUG_CONVEX_HULL + printf("Advanced intersecting edge to "); + intersection->print(); + printf(", cmp = %d\n", cmp); +#endif + + if (!firstIntersection) + { + firstIntersection = intersection; + } + else if (intersection == firstIntersection) + { + break; + } + + int prevCmp = cmp; + Edge* prevIntersection = intersection; + Edge* prevFaceEdge = faceEdge; + + Edge* e = intersection->reverse; +#ifdef SHOW_ITERATIONS + n = 0; +#endif + while (true) + { +#ifdef SHOW_ITERATIONS + n++; +#endif + e = e->reverse->prev; + btAssert(e != intersection->reverse); + cmp = e->target->dot(normal).compare(shiftedDot); +#ifdef DEBUG_CONVEX_HULL + printf("Testing edge "); + e->print(); + printf(" -> cmp = %d\n", cmp); +#endif + if (cmp >= 0) + { + intersection = e; + break; + } + } +#ifdef SHOW_ITERATIONS + printf("Needed %d iterations to find other intersection of face\n", n); +#endif + + if (cmp > 0) + { + Vertex* removed = intersection->target; + e = intersection->reverse; + if (e->prev == e) + { + removed->edges = NULL; + } + else + { + removed->edges = e->prev; + e->prev->link(e->next); + e->link(e); + } +#ifdef DEBUG_CONVEX_HULL + printf("1: Removed part contains (%d %d %d)\n", removed->point.x, removed->point.y, removed->point.z); +#endif + + Point64 n0 = intersection->face->getNormal(); + Point64 n1 = intersection->reverse->face->getNormal(); + int64_t m00 = face->dir0.dot(n0); + int64_t m01 = face->dir1.dot(n0); + int64_t m10 = face->dir0.dot(n1); + int64_t m11 = face->dir1.dot(n1); + int64_t r0 = (intersection->face->origin - shiftedOrigin).dot(n0); + int64_t r1 = (intersection->reverse->face->origin - shiftedOrigin).dot(n1); + Int128 det = Int128::mul(m00, m11) - Int128::mul(m01, m10); + btAssert(det.getSign() != 0); + Vertex* v = vertexPool.newObject(); + v->point.index = -1; + v->copy = -1; + v->point128 = PointR128(Int128::mul(face->dir0.x * r0, m11) - Int128::mul(face->dir0.x * r1, m01) + Int128::mul(face->dir1.x * r1, m00) - Int128::mul(face->dir1.x * r0, m10) + det * shiftedOrigin.x, + Int128::mul(face->dir0.y * r0, m11) - Int128::mul(face->dir0.y * r1, m01) + Int128::mul(face->dir1.y * r1, m00) - Int128::mul(face->dir1.y * r0, m10) + det * shiftedOrigin.y, + Int128::mul(face->dir0.z * r0, m11) - Int128::mul(face->dir0.z * r1, m01) + Int128::mul(face->dir1.z * r1, m00) - Int128::mul(face->dir1.z * r0, m10) + det * shiftedOrigin.z, + det); + v->point.x = (int32_t)v->point128.xvalue(); + v->point.y = (int32_t)v->point128.yvalue(); + v->point.z = (int32_t)v->point128.zvalue(); + intersection->target = v; + v->edges = e; + + stack.push_back(v); + stack.push_back(removed); + stack.push_back(NULL); + } + + if (cmp || prevCmp || (prevIntersection->reverse->next->target != intersection->target)) + { + faceEdge = newEdgePair(prevIntersection->target, intersection->target); + if (prevCmp == 0) + { + faceEdge->link(prevIntersection->reverse->next); + } + if ((prevCmp == 0) || prevFaceEdge) + { + prevIntersection->reverse->link(faceEdge); + } + if (cmp == 0) + { + intersection->reverse->prev->link(faceEdge->reverse); + } + faceEdge->reverse->link(intersection->reverse); + } + else + { + faceEdge = prevIntersection->reverse->next; + } + + if (prevFaceEdge) + { + if (prevCmp > 0) + { + faceEdge->link(prevFaceEdge->reverse); + } + else if (faceEdge != prevFaceEdge->reverse) + { + stack.push_back(prevFaceEdge->target); + while (faceEdge->next != prevFaceEdge->reverse) + { + Vertex* removed = faceEdge->next->target; + removeEdgePair(faceEdge->next); + stack.push_back(removed); +#ifdef DEBUG_CONVEX_HULL + printf("2: Removed part contains (%d %d %d)\n", removed->point.x, removed->point.y, removed->point.z); +#endif + } + stack.push_back(NULL); + } + } + faceEdge->face = face; + faceEdge->reverse->face = intersection->face; + + if (!firstFaceEdge) + { + firstFaceEdge = faceEdge; + } + } +#ifdef SHOW_ITERATIONS + printf("Needed %d iterations to process all intersections\n", m); +#endif + + if (cmp > 0) + { + firstFaceEdge->reverse->target = faceEdge->target; + firstIntersection->reverse->link(firstFaceEdge); + firstFaceEdge->link(faceEdge->reverse); + } + else if (firstFaceEdge != faceEdge->reverse) + { + stack.push_back(faceEdge->target); + while (firstFaceEdge->next != faceEdge->reverse) + { + Vertex* removed = firstFaceEdge->next->target; + removeEdgePair(firstFaceEdge->next); + stack.push_back(removed); +#ifdef DEBUG_CONVEX_HULL + printf("3: Removed part contains (%d %d %d)\n", removed->point.x, removed->point.y, removed->point.z); +#endif + } + stack.push_back(NULL); + } + + btAssert(stack.size() > 0); + vertexList = stack[0]; + +#ifdef DEBUG_CONVEX_HULL + printf("Removing part\n"); +#endif +#ifdef SHOW_ITERATIONS + n = 0; +#endif + int pos = 0; + while (pos < stack.size()) + { + int end = stack.size(); + while (pos < end) + { + Vertex* kept = stack[pos++]; +#ifdef DEBUG_CONVEX_HULL + kept->print(); +#endif + bool deeper = false; + Vertex* removed; + while ((removed = stack[pos++]) != NULL) + { +#ifdef SHOW_ITERATIONS + n++; +#endif + kept->receiveNearbyFaces(removed); + while (removed->edges) + { + if (!deeper) + { + deeper = true; + stack.push_back(kept); + } + stack.push_back(removed->edges->target); + removeEdgePair(removed->edges); + } + } + if (deeper) + { + stack.push_back(NULL); + } + } + } +#ifdef SHOW_ITERATIONS + printf("Needed %d iterations to remove part\n", n); +#endif + + stack.resize(0); + face->origin = shiftedOrigin; + + return true; +} + +static int getVertexCopy(btConvexHullInternal::Vertex* vertex, btAlignedObjectArray& vertices) +{ + int index = vertex->copy; + if (index < 0) + { + index = vertices.size(); + vertex->copy = index; + vertices.push_back(vertex); +#ifdef DEBUG_CONVEX_HULL + printf("Vertex %d gets index *%d\n", vertex->point.index, index); +#endif + } + return index; +} + +btScalar btConvexHullComputer::compute(const void* coords, bool doubleCoords, int stride, int count, btScalar shrink, btScalar shrinkClamp) +{ + if (count <= 0) + { + vertices.clear(); + edges.clear(); + faces.clear(); + return 0; + } + + btConvexHullInternal hull; + hull.compute(coords, doubleCoords, stride, count); + + btScalar shift = 0; + if ((shrink > 0) && ((shift = hull.shrink(shrink, shrinkClamp)) < 0)) + { + vertices.clear(); + edges.clear(); + faces.clear(); + return shift; + } + + vertices.resize(0); + original_vertex_index.resize(0); + edges.resize(0); + faces.resize(0); + + btAlignedObjectArray oldVertices; + getVertexCopy(hull.vertexList, oldVertices); + int copied = 0; + while (copied < oldVertices.size()) + { + btConvexHullInternal::Vertex* v = oldVertices[copied]; + vertices.push_back(hull.getCoordinates(v)); + original_vertex_index.push_back(v->point.index); + btConvexHullInternal::Edge* firstEdge = v->edges; + if (firstEdge) + { + int firstCopy = -1; + int prevCopy = -1; + btConvexHullInternal::Edge* e = firstEdge; + do + { + if (e->copy < 0) + { + int s = edges.size(); + edges.push_back(Edge()); + edges.push_back(Edge()); + Edge* c = &edges[s]; + Edge* r = &edges[s + 1]; + e->copy = s; + e->reverse->copy = s + 1; + c->reverse = 1; + r->reverse = -1; + c->targetVertex = getVertexCopy(e->target, oldVertices); + r->targetVertex = copied; +#ifdef DEBUG_CONVEX_HULL + printf(" CREATE: Vertex *%d has edge to *%d\n", copied, c->getTargetVertex()); +#endif + } + if (prevCopy >= 0) + { + edges[e->copy].next = prevCopy - e->copy; + } + else + { + firstCopy = e->copy; + } + prevCopy = e->copy; + e = e->next; + } while (e != firstEdge); + edges[firstCopy].next = prevCopy - firstCopy; + } + copied++; + } + + for (int i = 0; i < copied; i++) + { + btConvexHullInternal::Vertex* v = oldVertices[i]; + btConvexHullInternal::Edge* firstEdge = v->edges; + if (firstEdge) + { + btConvexHullInternal::Edge* e = firstEdge; + do + { + if (e->copy >= 0) + { +#ifdef DEBUG_CONVEX_HULL + printf("Vertex *%d has edge to *%d\n", i, edges[e->copy].getTargetVertex()); +#endif + faces.push_back(e->copy); + btConvexHullInternal::Edge* f = e; + do + { +#ifdef DEBUG_CONVEX_HULL + printf(" Face *%d\n", edges[f->copy].getTargetVertex()); +#endif + f->copy = -1; + f = f->reverse->prev; + } while (f != e); + } + e = e->next; + } while (e != firstEdge); + } + } + + return shift; +} diff --git a/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.cpp.i b/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.cpp.i new file mode 100644 index 00000000..b2dfa9b4 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btConvexHullComputer.cpp ---------------- + +%include "LinearMath/btConvexHullComputer.cpp" + +%{ +#include "LinearMath/btConvexHullComputer.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.h b/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.h new file mode 100644 index 00000000..18b26eea --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.h @@ -0,0 +1,102 @@ +/* +Copyright (c) 2011 Ole Kniemeyer, MAXON, www.maxon.net + +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_CONVEX_HULL_COMPUTER_H +#define BT_CONVEX_HULL_COMPUTER_H + +#include "btVector3.h" +#include "btAlignedObjectArray.h" + +/// Convex hull implementation based on Preparata and Hong +/// See http://code.google.com/p/bullet/issues/detail?id=275 +/// Ole Kniemeyer, MAXON Computer GmbH +class btConvexHullComputer +{ +private: + btScalar compute(const void* coords, bool doubleCoords, int stride, int count, btScalar shrink, btScalar shrinkClamp); + +public: + class Edge + { + private: + int next; + int reverse; + int targetVertex; + + friend class btConvexHullComputer; + + public: + int getSourceVertex() const + { + return (this + reverse)->targetVertex; + } + + int getTargetVertex() const + { + return targetVertex; + } + + const Edge* getNextEdgeOfVertex() const // clockwise list of all edges of a vertex + { + return this + next; + } + + const Edge* getNextEdgeOfFace() const // counter-clockwise list of all edges of a face + { + return (this + reverse)->getNextEdgeOfVertex(); + } + + const Edge* getReverseEdge() const + { + return this + reverse; + } + }; + + // Vertices of the output hull + btAlignedObjectArray vertices; + + // The original vertex index in the input coords array + btAlignedObjectArray original_vertex_index; + + // Edges of the output hull + btAlignedObjectArray edges; + + // Faces of the convex hull. Each entry is an index into the "edges" array pointing to an edge of the face. Faces are planar n-gons + btAlignedObjectArray faces; + + /* + Compute convex hull of "count" vertices stored in "coords". "stride" is the difference in bytes + between the addresses of consecutive vertices. If "shrink" is positive, the convex hull is shrunken + by that amount (each face is moved by "shrink" length units towards the center along its normal). + If "shrinkClamp" is positive, "shrink" is clamped to not exceed "shrinkClamp * innerRadius", where "innerRadius" + is the minimum distance of a face to the center of the convex hull. + + The returned value is the amount by which the hull has been shrunken. If it is negative, the amount was so large + that the resulting convex hull is empty. + + The output convex hull can be found in the member variables "vertices", "edges", "faces". + */ + btScalar compute(const float* coords, int stride, int count, btScalar shrink, btScalar shrinkClamp) + { + return compute(coords, false, stride, count, shrink, shrinkClamp); + } + + // same as above, but double precision + btScalar compute(const double* coords, int stride, int count, btScalar shrink, btScalar shrinkClamp) + { + return compute(coords, true, stride, count, shrink, shrinkClamp); + } +}; + +#endif //BT_CONVEX_HULL_COMPUTER_H diff --git a/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.h.i b/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.h.i new file mode 100644 index 00000000..b0be5712 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btConvexHullComputer.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btConvexHullComputer.h ---------------- + +%include "LinearMath/btConvexHullComputer.h" + +%{ +#include "LinearMath/btConvexHullComputer.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btCpuFeatureUtility.h b/pkg/mphysics/mbt/LinearMath/btCpuFeatureUtility.h new file mode 100644 index 00000000..5e4b9a31 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btCpuFeatureUtility.h @@ -0,0 +1,88 @@ + +#ifndef BT_CPU_UTILITY_H +#define BT_CPU_UTILITY_H + +#include "LinearMath/btScalar.h" + +#include //memset +#ifdef USE_SIMD +#include +#ifdef BT_ALLOW_SSE4 +#include +#endif //BT_ALLOW_SSE4 +#endif //USE_SIMD + +#if defined BT_USE_NEON +#define ARM_NEON_GCC_COMPATIBILITY 1 +#include +#include +#include //for sysctlbyname +#endif //BT_USE_NEON + +///Rudimentary btCpuFeatureUtility for CPU features: only report the features that Bullet actually uses (SSE4/FMA3, NEON_HPFP) +///We assume SSE2 in case BT_USE_SSE2 is defined in LinearMath/btScalar.h +class btCpuFeatureUtility +{ +public: + enum btCpuFeature + { + CPU_FEATURE_FMA3 = 1, + CPU_FEATURE_SSE4_1 = 2, + CPU_FEATURE_NEON_HPFP = 4 + }; + + static int getCpuFeatures() + { + static int capabilities = 0; + static bool testedCapabilities = false; + if (0 != testedCapabilities) + { + return capabilities; + } + +#ifdef BT_USE_NEON + { + uint32_t hasFeature = 0; + size_t featureSize = sizeof(hasFeature); + int err = sysctlbyname("hw.optional.neon_hpfp", &hasFeature, &featureSize, NULL, 0); + if (0 == err && hasFeature) + capabilities |= CPU_FEATURE_NEON_HPFP; + } +#endif //BT_USE_NEON + +#ifdef BT_ALLOW_SSE4 + { + int cpuInfo[4]; + memset(cpuInfo, 0, sizeof(cpuInfo)); + unsigned long long sseExt = 0; + __cpuid(cpuInfo, 1); + + bool osUsesXSAVE_XRSTORE = cpuInfo[2] & (1 << 27) || false; + bool cpuAVXSuport = cpuInfo[2] & (1 << 28) || false; + + if (osUsesXSAVE_XRSTORE && cpuAVXSuport) + { + sseExt = _xgetbv(0); + } + const int OSXSAVEFlag = (1UL << 27); + const int AVXFlag = ((1UL << 28) | OSXSAVEFlag); + const int FMAFlag = ((1UL << 12) | AVXFlag | OSXSAVEFlag); + if ((cpuInfo[2] & FMAFlag) == FMAFlag && (sseExt & 6) == 6) + { + capabilities |= btCpuFeatureUtility::CPU_FEATURE_FMA3; + } + + const int SSE41Flag = (1 << 19); + if (cpuInfo[2] & SSE41Flag) + { + capabilities |= btCpuFeatureUtility::CPU_FEATURE_SSE4_1; + } + } +#endif //BT_ALLOW_SSE4 + + testedCapabilities = true; + return capabilities; + } +}; + +#endif //BT_CPU_UTILITY_H diff --git a/pkg/mphysics/mbt/LinearMath/btCpuFeatureUtility.h.i b/pkg/mphysics/mbt/LinearMath/btCpuFeatureUtility.h.i new file mode 100644 index 00000000..a9b68468 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btCpuFeatureUtility.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btCpuFeatureUtility.h ---------------- + +%include "LinearMath/btCpuFeatureUtility.h" + +%{ +#include "LinearMath/btCpuFeatureUtility.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btDefaultMotionState.h b/pkg/mphysics/mbt/LinearMath/btDefaultMotionState.h new file mode 100644 index 00000000..14c40d36 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btDefaultMotionState.h @@ -0,0 +1,40 @@ +#ifndef BT_DEFAULT_MOTION_STATE_H +#define BT_DEFAULT_MOTION_STATE_H + +#include "btMotionState.h" + +///The btDefaultMotionState provides a common implementation to synchronize world transforms with offsets. +ATTRIBUTE_ALIGNED16(struct) +btDefaultMotionState : public btMotionState +{ + btTransform m_graphicsWorldTrans; + btTransform m_centerOfMassOffset; + btTransform m_startWorldTrans; + void* m_userPointer; + + BT_DECLARE_ALIGNED_ALLOCATOR(); + + btDefaultMotionState(const btTransform& startTrans = btTransform::getIdentity(), const btTransform& centerOfMassOffset = btTransform::getIdentity()) + : m_graphicsWorldTrans(startTrans), + m_centerOfMassOffset(centerOfMassOffset), + m_startWorldTrans(startTrans), + m_userPointer(0) + + { + } + + ///synchronizes world transform from user to physics + virtual void getWorldTransform(btTransform & centerOfMassWorldTrans) const + { + centerOfMassWorldTrans = m_graphicsWorldTrans * m_centerOfMassOffset.inverse(); + } + + ///synchronizes world transform from physics to user + ///Bullet only calls the update of worldtransform for active objects + virtual void setWorldTransform(const btTransform& centerOfMassWorldTrans) + { + m_graphicsWorldTrans = centerOfMassWorldTrans * m_centerOfMassOffset; + } +}; + +#endif //BT_DEFAULT_MOTION_STATE_H diff --git a/pkg/mphysics/mbt/LinearMath/btDefaultMotionState.h.i b/pkg/mphysics/mbt/LinearMath/btDefaultMotionState.h.i new file mode 100644 index 00000000..16f9decd --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btDefaultMotionState.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btDefaultMotionState.h ---------------- + +%include "LinearMath/btDefaultMotionState.h" + +%{ +#include "LinearMath/btDefaultMotionState.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btGeometryUtil.cpp b/pkg/mphysics/mbt/LinearMath/btGeometryUtil.cpp new file mode 100644 index 00000000..62bbef2c --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btGeometryUtil.cpp @@ -0,0 +1,174 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btGeometryUtil.h" + +/* + Make sure this dummy function never changes so that it + can be used by probes that are checking whether the + library is actually installed. +*/ +extern "C" +{ + void btBulletMathProbe(); + + void btBulletMathProbe() {} +} + +bool btGeometryUtil::isPointInsidePlanes(const btAlignedObjectArray& planeEquations, const btVector3& point, btScalar margin) +{ + int numbrushes = planeEquations.size(); + for (int i = 0; i < numbrushes; i++) + { + const btVector3& N1 = planeEquations[i]; + btScalar dist = btScalar(N1.dot(point)) + btScalar(N1[3]) - margin; + if (dist > btScalar(0.)) + { + return false; + } + } + return true; +} + +bool btGeometryUtil::areVerticesBehindPlane(const btVector3& planeNormal, const btAlignedObjectArray& vertices, btScalar margin) +{ + int numvertices = vertices.size(); + for (int i = 0; i < numvertices; i++) + { + const btVector3& N1 = vertices[i]; + btScalar dist = btScalar(planeNormal.dot(N1)) + btScalar(planeNormal[3]) - margin; + if (dist > btScalar(0.)) + { + return false; + } + } + return true; +} + +bool notExist(const btVector3& planeEquation, const btAlignedObjectArray& planeEquations); + +bool notExist(const btVector3& planeEquation, const btAlignedObjectArray& planeEquations) +{ + int numbrushes = planeEquations.size(); + for (int i = 0; i < numbrushes; i++) + { + const btVector3& N1 = planeEquations[i]; + if (planeEquation.dot(N1) > btScalar(0.999)) + { + return false; + } + } + return true; +} + +void btGeometryUtil::getPlaneEquationsFromVertices(btAlignedObjectArray& vertices, btAlignedObjectArray& planeEquationsOut) +{ + const int numvertices = vertices.size(); + // brute force: + for (int i = 0; i < numvertices; i++) + { + const btVector3& N1 = vertices[i]; + + for (int j = i + 1; j < numvertices; j++) + { + const btVector3& N2 = vertices[j]; + + for (int k = j + 1; k < numvertices; k++) + { + const btVector3& N3 = vertices[k]; + + btVector3 planeEquation, edge0, edge1; + edge0 = N2 - N1; + edge1 = N3 - N1; + btScalar normalSign = btScalar(1.); + for (int ww = 0; ww < 2; ww++) + { + planeEquation = normalSign * edge0.cross(edge1); + if (planeEquation.length2() > btScalar(0.0001)) + { + planeEquation.normalize(); + if (notExist(planeEquation, planeEquationsOut)) + { + planeEquation[3] = -planeEquation.dot(N1); + + //check if inside, and replace supportingVertexOut if needed + if (areVerticesBehindPlane(planeEquation, vertices, btScalar(0.01))) + { + planeEquationsOut.push_back(planeEquation); + } + } + } + normalSign = btScalar(-1.); + } + } + } + } +} + +void btGeometryUtil::getVerticesFromPlaneEquations(const btAlignedObjectArray& planeEquations, btAlignedObjectArray& verticesOut) +{ + const int numbrushes = planeEquations.size(); + // brute force: + for (int i = 0; i < numbrushes; i++) + { + const btVector3& N1 = planeEquations[i]; + + for (int j = i + 1; j < numbrushes; j++) + { + const btVector3& N2 = planeEquations[j]; + + for (int k = j + 1; k < numbrushes; k++) + { + const btVector3& N3 = planeEquations[k]; + + btVector3 n2n3; + n2n3 = N2.cross(N3); + btVector3 n3n1; + n3n1 = N3.cross(N1); + btVector3 n1n2; + n1n2 = N1.cross(N2); + + if ((n2n3.length2() > btScalar(0.0001)) && + (n3n1.length2() > btScalar(0.0001)) && + (n1n2.length2() > btScalar(0.0001))) + { + //point P out of 3 plane equations: + + // d1 ( N2 * N3 ) + d2 ( N3 * N1 ) + d3 ( N1 * N2 ) + //P = ------------------------------------------------------------------------- + // N1 . ( N2 * N3 ) + + btScalar quotient = (N1.dot(n2n3)); + if (btFabs(quotient) > btScalar(0.000001)) + { + quotient = btScalar(-1.) / quotient; + n2n3 *= N1[3]; + n3n1 *= N2[3]; + n1n2 *= N3[3]; + btVector3 potentialVertex = n2n3; + potentialVertex += n3n1; + potentialVertex += n1n2; + potentialVertex *= quotient; + + //check if inside, and replace supportingVertexOut if needed + if (isPointInsidePlanes(planeEquations, potentialVertex, btScalar(0.01))) + { + verticesOut.push_back(potentialVertex); + } + } + } + } + } + } +} diff --git a/pkg/mphysics/mbt/LinearMath/btGeometryUtil.cpp.i b/pkg/mphysics/mbt/LinearMath/btGeometryUtil.cpp.i new file mode 100644 index 00000000..d7a0cb36 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btGeometryUtil.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btGeometryUtil.cpp ---------------- + +%include "LinearMath/btGeometryUtil.cpp" + +%{ +#include "LinearMath/btGeometryUtil.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btGeometryUtil.h b/pkg/mphysics/mbt/LinearMath/btGeometryUtil.h new file mode 100644 index 00000000..75a01297 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btGeometryUtil.h @@ -0,0 +1,36 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_GEOMETRY_UTIL_H +#define BT_GEOMETRY_UTIL_H + +#include "btVector3.h" +#include "btAlignedObjectArray.h" + +///The btGeometryUtil helper class provides a few methods to convert between plane equations and vertices. +class btGeometryUtil +{ +public: + static void getPlaneEquationsFromVertices(btAlignedObjectArray& vertices, btAlignedObjectArray& planeEquationsOut); + + static void getVerticesFromPlaneEquations(const btAlignedObjectArray& planeEquations, btAlignedObjectArray& verticesOut); + + // static bool isInside(const btAlignedObjectArray& vertices, const btVector3& planeNormal, btScalar margin); + + static bool isPointInsidePlanes(const btAlignedObjectArray& planeEquations, const btVector3& point, btScalar margin); + + static bool areVerticesBehindPlane(const btVector3& planeNormal, const btAlignedObjectArray& vertices, btScalar margin); +}; + +#endif //BT_GEOMETRY_UTIL_H diff --git a/pkg/mphysics/mbt/LinearMath/btGeometryUtil.h.i b/pkg/mphysics/mbt/LinearMath/btGeometryUtil.h.i new file mode 100644 index 00000000..08740657 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btGeometryUtil.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btGeometryUtil.h ---------------- + +%include "LinearMath/btGeometryUtil.h" + +%{ +#include "LinearMath/btGeometryUtil.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btGrahamScan2dConvexHull.h b/pkg/mphysics/mbt/LinearMath/btGrahamScan2dConvexHull.h new file mode 100644 index 00000000..0fcb2859 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btGrahamScan2dConvexHull.h @@ -0,0 +1,129 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef GRAHAM_SCAN_2D_CONVEX_HULL_H +#define GRAHAM_SCAN_2D_CONVEX_HULL_H + +#include "btVector3.h" +#include "btAlignedObjectArray.h" + +struct GrahamVector3 : public btVector3 +{ + GrahamVector3(const btVector3& org, int orgIndex) + : btVector3(org), + m_orgIndex(orgIndex) + { + } + btScalar m_angle; + int m_orgIndex; +}; + +struct btAngleCompareFunc +{ + btVector3 m_anchor; + btAngleCompareFunc(const btVector3& anchor) + : m_anchor(anchor) + { + } + bool operator()(const GrahamVector3& a, const GrahamVector3& b) const + { + if (a.m_angle != b.m_angle) + return a.m_angle < b.m_angle; + else + { + btScalar al = (a - m_anchor).length2(); + btScalar bl = (b - m_anchor).length2(); + if (al != bl) + return al < bl; + else + { + return a.m_orgIndex < b.m_orgIndex; + } + } + } +}; + +inline void GrahamScanConvexHull2D(btAlignedObjectArray& originalPoints, btAlignedObjectArray& hull, const btVector3& normalAxis) +{ + btVector3 axis0, axis1; + btPlaneSpace1(normalAxis, axis0, axis1); + + if (originalPoints.size() <= 1) + { + for (int i = 0; i < originalPoints.size(); i++) + hull.push_back(originalPoints[0]); + return; + } + //step1 : find anchor point with smallest projection on axis0 and move it to first location + for (int i = 0; i < originalPoints.size(); i++) + { + // const btVector3& left = originalPoints[i]; + // const btVector3& right = originalPoints[0]; + btScalar projL = originalPoints[i].dot(axis0); + btScalar projR = originalPoints[0].dot(axis0); + if (projL < projR) + { + originalPoints.swap(0, i); + } + } + + //also precompute angles + originalPoints[0].m_angle = -1e30f; + for (int i = 1; i < originalPoints.size(); i++) + { + btVector3 ar = originalPoints[i] - originalPoints[0]; + btScalar ar1 = axis1.dot(ar); + btScalar ar0 = axis0.dot(ar); + if (ar1 * ar1 + ar0 * ar0 < FLT_EPSILON) + { + originalPoints[i].m_angle = 0.0f; + } + else + { + originalPoints[i].m_angle = btAtan2Fast(ar1, ar0); + } + } + + //step 2: sort all points, based on 'angle' with this anchor + btAngleCompareFunc comp(originalPoints[0]); + originalPoints.quickSortInternal(comp, 1, originalPoints.size() - 1); + + int i; + for (i = 0; i < 2; i++) + hull.push_back(originalPoints[i]); + + //step 3: keep all 'convex' points and discard concave points (using back tracking) + for (; i != originalPoints.size(); i++) + { + bool isConvex = false; + while (!isConvex && hull.size() > 1) + { + btVector3& a = hull[hull.size() - 2]; + btVector3& b = hull[hull.size() - 1]; + isConvex = btCross(a - b, a - originalPoints[i]).dot(normalAxis) > 0; + if (!isConvex) + hull.pop_back(); + else + hull.push_back(originalPoints[i]); + } + + if (hull.size() == 1) + { + hull.push_back(originalPoints[i]); + } + } +} + +#endif //GRAHAM_SCAN_2D_CONVEX_HULL_H diff --git a/pkg/mphysics/mbt/LinearMath/btGrahamScan2dConvexHull.h.i b/pkg/mphysics/mbt/LinearMath/btGrahamScan2dConvexHull.h.i new file mode 100644 index 00000000..b1e3dc57 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btGrahamScan2dConvexHull.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btGrahamScan2dConvexHull.h ---------------- + +%include "LinearMath/btGrahamScan2dConvexHull.h" + +%{ +#include "LinearMath/btGrahamScan2dConvexHull.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btHashMap.h b/pkg/mphysics/mbt/LinearMath/btHashMap.h new file mode 100644 index 00000000..40590872 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btHashMap.h @@ -0,0 +1,474 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_HASH_MAP_H +#define BT_HASH_MAP_H + +#include +#include "btAlignedObjectArray.h" + +///very basic hashable string implementation, compatible with btHashMap +struct btHashString +{ + std::string m_string1; + unsigned int m_hash; + + SIMD_FORCE_INLINE unsigned int getHash() const + { + return m_hash; + } + + btHashString() + { + m_string1 = ""; + m_hash = 0; + } + btHashString(const char* name) + : m_string1(name) + { + /* magic numbers from http://www.isthe.com/chongo/tech/comp/fnv/ */ + static const unsigned int InitialFNV = 2166136261u; + static const unsigned int FNVMultiple = 16777619u; + + /* Fowler / Noll / Vo (FNV) Hash */ + unsigned int hash = InitialFNV; + + for (int i = 0; m_string1.c_str()[i]; i++) + { + hash = hash ^ (m_string1.c_str()[i]); /* xor the low 8 bits */ + hash = hash * FNVMultiple; /* multiply by the magic number */ + } + m_hash = hash; + } + + bool equals(const btHashString& other) const + { + return (m_string1 == other.m_string1); + } +}; + +const int BT_HASH_NULL = 0xffffffff; + +class btHashInt +{ + int m_uid; + +public: + btHashInt() + { + } + + btHashInt(int uid) : m_uid(uid) + { + } + + int getUid1() const + { + return m_uid; + } + + void setUid1(int uid) + { + m_uid = uid; + } + + bool equals(const btHashInt& other) const + { + return getUid1() == other.getUid1(); + } + //to our success + SIMD_FORCE_INLINE unsigned int getHash() const + { + unsigned int key = m_uid; + // Thomas Wang's hash + key += ~(key << 15); + key ^= (key >> 10); + key += (key << 3); + key ^= (key >> 6); + key += ~(key << 11); + key ^= (key >> 16); + + return key; + } +}; + +class btHashPtr +{ + union { + const void* m_pointer; + unsigned int m_hashValues[2]; + }; + +public: + btHashPtr() + { + } + + btHashPtr(const void* ptr) + : m_pointer(ptr) + { + } + + const void* getPointer() const + { + return m_pointer; + } + + bool equals(const btHashPtr& other) const + { + return getPointer() == other.getPointer(); + } + + //to our success + SIMD_FORCE_INLINE unsigned int getHash() const + { + const bool VOID_IS_8 = ((sizeof(void*) == 8)); + + unsigned int key = VOID_IS_8 ? m_hashValues[0] + m_hashValues[1] : m_hashValues[0]; + // Thomas Wang's hash + key += ~(key << 15); + key ^= (key >> 10); + key += (key << 3); + key ^= (key >> 6); + key += ~(key << 11); + key ^= (key >> 16); + return key; + } +}; + +template +class btHashKeyPtr +{ + int m_uid; + +public: + btHashKeyPtr(int uid) : m_uid(uid) + { + } + + int getUid1() const + { + return m_uid; + } + + bool equals(const btHashKeyPtr& other) const + { + return getUid1() == other.getUid1(); + } + + //to our success + SIMD_FORCE_INLINE unsigned int getHash() const + { + unsigned int key = m_uid; + // Thomas Wang's hash + key += ~(key << 15); + key ^= (key >> 10); + key += (key << 3); + key ^= (key >> 6); + key += ~(key << 11); + key ^= (key >> 16); + return key; + } +}; + +template +class btHashKey +{ + int m_uid; + +public: + btHashKey(int uid) : m_uid(uid) + { + } + + int getUid1() const + { + return m_uid; + } + + bool equals(const btHashKey& other) const + { + return getUid1() == other.getUid1(); + } + //to our success + SIMD_FORCE_INLINE unsigned int getHash() const + { + unsigned int key = m_uid; + // Thomas Wang's hash + key += ~(key << 15); + key ^= (key >> 10); + key += (key << 3); + key ^= (key >> 6); + key += ~(key << 11); + key ^= (key >> 16); + return key; + } +}; + +///The btHashMap template class implements a generic and lightweight hashmap. +///A basic sample of how to use btHashMap is located in Demos\BasicDemo\main.cpp +template +class btHashMap +{ +protected: + btAlignedObjectArray m_hashTable; + btAlignedObjectArray m_next; + + btAlignedObjectArray m_valueArray; + btAlignedObjectArray m_keyArray; + + void growTables(const Key& /*key*/) + { + int newCapacity = m_valueArray.capacity(); + + if (m_hashTable.size() < newCapacity) + { + //grow hashtable and next table + int curHashtableSize = m_hashTable.size(); + + m_hashTable.resize(newCapacity); + m_next.resize(newCapacity); + + int i; + + for (i = 0; i < newCapacity; ++i) + { + m_hashTable[i] = BT_HASH_NULL; + } + for (i = 0; i < newCapacity; ++i) + { + m_next[i] = BT_HASH_NULL; + } + + for (i = 0; i < curHashtableSize; i++) + { + //const Value& value = m_valueArray[i]; + //const Key& key = m_keyArray[i]; + + int hashValue = m_keyArray[i].getHash() & (m_valueArray.capacity() - 1); // New hash value with new mask + m_next[i] = m_hashTable[hashValue]; + m_hashTable[hashValue] = i; + } + } + } + +public: + void insert(const Key& key, const Value& value) + { + int hash = key.getHash() & (m_valueArray.capacity() - 1); + + //replace value if the key is already there + int index = findIndex(key); + if (index != BT_HASH_NULL) + { + m_valueArray[index] = value; + return; + } + + int count = m_valueArray.size(); + int oldCapacity = m_valueArray.capacity(); + m_valueArray.push_back(value); + m_keyArray.push_back(key); + + int newCapacity = m_valueArray.capacity(); + if (oldCapacity < newCapacity) + { + growTables(key); + //hash with new capacity + hash = key.getHash() & (m_valueArray.capacity() - 1); + } + m_next[count] = m_hashTable[hash]; + m_hashTable[hash] = count; + } + + void remove(const Key& key) + { + int hash = key.getHash() & (m_valueArray.capacity() - 1); + + int pairIndex = findIndex(key); + + if (pairIndex == BT_HASH_NULL) + { + return; + } + + // Remove the pair from the hash table. + int index = m_hashTable[hash]; + btAssert(index != BT_HASH_NULL); + + int previous = BT_HASH_NULL; + while (index != pairIndex) + { + previous = index; + index = m_next[index]; + } + + if (previous != BT_HASH_NULL) + { + btAssert(m_next[previous] == pairIndex); + m_next[previous] = m_next[pairIndex]; + } + else + { + m_hashTable[hash] = m_next[pairIndex]; + } + + // We now move the last pair into spot of the + // pair being removed. We need to fix the hash + // table indices to support the move. + + int lastPairIndex = m_valueArray.size() - 1; + + // If the removed pair is the last pair, we are done. + if (lastPairIndex == pairIndex) + { + m_valueArray.pop_back(); + m_keyArray.pop_back(); + return; + } + + // Remove the last pair from the hash table. + int lastHash = m_keyArray[lastPairIndex].getHash() & (m_valueArray.capacity() - 1); + + index = m_hashTable[lastHash]; + btAssert(index != BT_HASH_NULL); + + previous = BT_HASH_NULL; + while (index != lastPairIndex) + { + previous = index; + index = m_next[index]; + } + + if (previous != BT_HASH_NULL) + { + btAssert(m_next[previous] == lastPairIndex); + m_next[previous] = m_next[lastPairIndex]; + } + else + { + m_hashTable[lastHash] = m_next[lastPairIndex]; + } + + // Copy the last pair into the remove pair's spot. + m_valueArray[pairIndex] = m_valueArray[lastPairIndex]; + m_keyArray[pairIndex] = m_keyArray[lastPairIndex]; + + // Insert the last pair into the hash table + m_next[pairIndex] = m_hashTable[lastHash]; + m_hashTable[lastHash] = pairIndex; + + m_valueArray.pop_back(); + m_keyArray.pop_back(); + } + + int size() const + { + return m_valueArray.size(); + } + + const Value* getAtIndex(int index) const + { + btAssert(index < m_valueArray.size()); + btAssert(index >= 0); + if (index >= 0 && index < m_valueArray.size()) + { + return &m_valueArray[index]; + } + return 0; + } + + Value* getAtIndex(int index) + { + btAssert(index < m_valueArray.size()); + btAssert(index >= 0); + if (index >= 0 && index < m_valueArray.size()) + { + return &m_valueArray[index]; + } + return 0; + } + + Key getKeyAtIndex(int index) + { + btAssert(index < m_keyArray.size()); + btAssert(index >= 0); + return m_keyArray[index]; + } + + const Key getKeyAtIndex(int index) const + { + btAssert(index < m_keyArray.size()); + btAssert(index >= 0); + return m_keyArray[index]; + } + + Value* operator[](const Key& key) + { + return find(key); + } + + const Value* operator[](const Key& key) const + { + return find(key); + } + + const Value* find(const Key& key) const + { + int index = findIndex(key); + if (index == BT_HASH_NULL) + { + return NULL; + } + return &m_valueArray[index]; + } + + Value* find(const Key& key) + { + int index = findIndex(key); + if (index == BT_HASH_NULL) + { + return NULL; + } + return &m_valueArray[index]; + } + + int findIndex(const Key& key) const + { + unsigned int hash = key.getHash() & (m_valueArray.capacity() - 1); + + if (hash >= (unsigned int)m_hashTable.size()) + { + return BT_HASH_NULL; + } + + int index = m_hashTable[hash]; + while ((index != BT_HASH_NULL) && key.equals(m_keyArray[index]) == false) + { + index = m_next[index]; + } + return index; + } + + void clear() + { + m_hashTable.clear(); + m_next.clear(); + m_valueArray.clear(); + m_keyArray.clear(); + } +}; + +#endif //BT_HASH_MAP_H diff --git a/pkg/mphysics/mbt/LinearMath/btHashMap.h.i b/pkg/mphysics/mbt/LinearMath/btHashMap.h.i new file mode 100644 index 00000000..2b495c06 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btHashMap.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btHashMap.h ---------------- + +%include "LinearMath/btHashMap.h" + +%{ +#include "LinearMath/btHashMap.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btIDebugDraw.h b/pkg/mphysics/mbt/LinearMath/btIDebugDraw.h new file mode 100644 index 00000000..df4db2ff --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btIDebugDraw.h @@ -0,0 +1,473 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_IDEBUG_DRAW__H +#define BT_IDEBUG_DRAW__H + +#include "btVector3.h" +#include "btTransform.h" + +///The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations. +///Typical use case: create a debug drawer object, and assign it to a btCollisionWorld or btDynamicsWorld using setDebugDrawer and call debugDrawWorld. +///A class that implements the btIDebugDraw interface will need to provide non-empty implementations of the the drawLine and getDebugMode methods at a minimum. +///For color arguments the X,Y,Z components refer to Red, Green and Blue each in the range [0..1] +class btIDebugDraw +{ +public: + ATTRIBUTE_ALIGNED16(struct) + DefaultColors + { + btVector3 m_activeObject; + btVector3 m_deactivatedObject; + btVector3 m_wantsDeactivationObject; + btVector3 m_disabledDeactivationObject; + btVector3 m_disabledSimulationObject; + btVector3 m_aabb; + btVector3 m_contactPoint; + + DefaultColors() + : m_activeObject(1, 1, 1), + m_deactivatedObject(0, 1, 0), + m_wantsDeactivationObject(0, 1, 1), + m_disabledDeactivationObject(1, 0, 0), + m_disabledSimulationObject(1, 1, 0), + m_aabb(1, 0, 0), + m_contactPoint(1, 1, 0) + { + } + }; + + enum DebugDrawModes + { + DBG_NoDebug = 0, + DBG_DrawWireframe = 1, + DBG_DrawAabb = 2, + DBG_DrawFeaturesText = 4, + DBG_DrawContactPoints = 8, + DBG_NoDeactivation = 16, + DBG_NoHelpText = 32, + DBG_DrawText = 64, + DBG_ProfileTimings = 128, + DBG_EnableSatComparison = 256, + DBG_DisableBulletLCP = 512, + DBG_EnableCCD = 1024, + DBG_DrawConstraints = (1 << 11), + DBG_DrawConstraintLimits = (1 << 12), + DBG_FastWireframe = (1 << 13), + DBG_DrawNormals = (1 << 14), + DBG_DrawFrames = (1 << 15), + DBG_MAX_DEBUG_DRAW_MODE + }; + + virtual ~btIDebugDraw(){}; + + virtual DefaultColors getDefaultColors() const + { + DefaultColors colors; + return colors; + } + ///the default implementation for setDefaultColors has no effect. A derived class can implement it and store the colors. + virtual void setDefaultColors(const DefaultColors& /*colors*/) {} + + virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& color) = 0; + + virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& fromColor, const btVector3& toColor) + { + (void)toColor; + drawLine(from, to, fromColor); + } + + virtual void drawSphere(btScalar radius, const btTransform& transform, const btVector3& color) + { + btVector3 center = transform.getOrigin(); + btVector3 up = transform.getBasis().getColumn(1); + btVector3 axis = transform.getBasis().getColumn(0); + btScalar minTh = -SIMD_HALF_PI; + btScalar maxTh = SIMD_HALF_PI; + btScalar minPs = -SIMD_HALF_PI; + btScalar maxPs = SIMD_HALF_PI; + btScalar stepDegrees = 30.f; + drawSpherePatch(center, up, axis, radius, minTh, maxTh, minPs, maxPs, color, stepDegrees, false); + drawSpherePatch(center, up, -axis, radius, minTh, maxTh, minPs, maxPs, color, stepDegrees, false); + } + + virtual void drawSphere(const btVector3& p, btScalar radius, const btVector3& color) + { + btTransform tr; + tr.setIdentity(); + tr.setOrigin(p); + drawSphere(radius, tr, color); + } + + virtual void drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& /*n0*/, const btVector3& /*n1*/, const btVector3& /*n2*/, const btVector3& color, btScalar alpha) + { + drawTriangle(v0, v1, v2, color, alpha); + } + virtual void drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& color, btScalar /*alpha*/) + { + drawLine(v0, v1, color); + drawLine(v1, v2, color); + drawLine(v2, v0, color); + } + + virtual void drawContactPoint(const btVector3& PointOnB, const btVector3& normalOnB, btScalar distance, int lifeTime, const btVector3& color) = 0; + + virtual void reportErrorWarning(const char* warningString) = 0; + + virtual void draw3dText(const btVector3& location, const char* textString) = 0; + + virtual void setDebugMode(int debugMode) = 0; + + virtual int getDebugMode() const = 0; + + virtual void drawAabb(const btVector3& from, const btVector3& to, const btVector3& color) + { + btVector3 halfExtents = (to - from) * 0.5f; + btVector3 center = (to + from) * 0.5f; + int i, j; + + btVector3 edgecoord(1.f, 1.f, 1.f), pa, pb; + for (i = 0; i < 4; i++) + { + for (j = 0; j < 3; j++) + { + pa = btVector3(edgecoord[0] * halfExtents[0], edgecoord[1] * halfExtents[1], + edgecoord[2] * halfExtents[2]); + pa += center; + + int othercoord = j % 3; + edgecoord[othercoord] *= -1.f; + pb = btVector3(edgecoord[0] * halfExtents[0], edgecoord[1] * halfExtents[1], + edgecoord[2] * halfExtents[2]); + pb += center; + + drawLine(pa, pb, color); + } + edgecoord = btVector3(-1.f, -1.f, -1.f); + if (i < 3) + edgecoord[i] *= -1.f; + } + } + virtual void drawTransform(const btTransform& transform, btScalar orthoLen) + { + btVector3 start = transform.getOrigin(); + drawLine(start, start + transform.getBasis() * btVector3(orthoLen, 0, 0), btVector3(btScalar(1.), btScalar(0.3), btScalar(0.3))); + drawLine(start, start + transform.getBasis() * btVector3(0, orthoLen, 0), btVector3(btScalar(0.3), btScalar(1.), btScalar(0.3))); + drawLine(start, start + transform.getBasis() * btVector3(0, 0, orthoLen), btVector3(btScalar(0.3), btScalar(0.3), btScalar(1.))); + } + + virtual void drawArc(const btVector3& center, const btVector3& normal, const btVector3& axis, btScalar radiusA, btScalar radiusB, btScalar minAngle, btScalar maxAngle, + const btVector3& color, bool drawSect, btScalar stepDegrees = btScalar(10.f)) + { + const btVector3& vx = axis; + btVector3 vy = normal.cross(axis); + btScalar step = stepDegrees * SIMD_RADS_PER_DEG; + int nSteps = (int)btFabs((maxAngle - minAngle) / step); + if (!nSteps) nSteps = 1; + btVector3 prev = center + radiusA * vx * btCos(minAngle) + radiusB * vy * btSin(minAngle); + if (drawSect) + { + drawLine(center, prev, color); + } + for (int i = 1; i <= nSteps; i++) + { + btScalar angle = minAngle + (maxAngle - minAngle) * btScalar(i) / btScalar(nSteps); + btVector3 next = center + radiusA * vx * btCos(angle) + radiusB * vy * btSin(angle); + drawLine(prev, next, color); + prev = next; + } + if (drawSect) + { + drawLine(center, prev, color); + } + } + virtual void drawSpherePatch(const btVector3& center, const btVector3& up, const btVector3& axis, btScalar radius, + btScalar minTh, btScalar maxTh, btScalar minPs, btScalar maxPs, const btVector3& color, btScalar stepDegrees = btScalar(10.f), bool drawCenter = true) + { + btVector3 vA[74]; + btVector3 vB[74]; + btVector3 *pvA = vA, *pvB = vB, *pT; + btVector3 npole = center + up * radius; + btVector3 spole = center - up * radius; + btVector3 arcStart; + btScalar step = stepDegrees * SIMD_RADS_PER_DEG; + const btVector3& kv = up; + const btVector3& iv = axis; + btVector3 jv = kv.cross(iv); + bool drawN = false; + bool drawS = false; + if (minTh <= -SIMD_HALF_PI) + { + minTh = -SIMD_HALF_PI + step; + drawN = true; + } + if (maxTh >= SIMD_HALF_PI) + { + maxTh = SIMD_HALF_PI - step; + drawS = true; + } + if (minTh > maxTh) + { + minTh = -SIMD_HALF_PI + step; + maxTh = SIMD_HALF_PI - step; + drawN = drawS = true; + } + int n_hor = (int)((maxTh - minTh) / step) + 1; + if (n_hor < 2) n_hor = 2; + btScalar step_h = (maxTh - minTh) / btScalar(n_hor - 1); + bool isClosed = false; + if (minPs > maxPs) + { + minPs = -SIMD_PI + step; + maxPs = SIMD_PI; + isClosed = true; + } + else if ((maxPs - minPs) >= SIMD_PI * btScalar(2.f)) + { + isClosed = true; + } + else + { + isClosed = false; + } + int n_vert = (int)((maxPs - minPs) / step) + 1; + if (n_vert < 2) n_vert = 2; + btScalar step_v = (maxPs - minPs) / btScalar(n_vert - 1); + for (int i = 0; i < n_hor; i++) + { + btScalar th = minTh + btScalar(i) * step_h; + btScalar sth = radius * btSin(th); + btScalar cth = radius * btCos(th); + for (int j = 0; j < n_vert; j++) + { + btScalar psi = minPs + btScalar(j) * step_v; + btScalar sps = btSin(psi); + btScalar cps = btCos(psi); + pvB[j] = center + cth * cps * iv + cth * sps * jv + sth * kv; + if (i) + { + drawLine(pvA[j], pvB[j], color); + } + else if (drawS) + { + drawLine(spole, pvB[j], color); + } + if (j) + { + drawLine(pvB[j - 1], pvB[j], color); + } + else + { + arcStart = pvB[j]; + } + if ((i == (n_hor - 1)) && drawN) + { + drawLine(npole, pvB[j], color); + } + + if (drawCenter) + { + if (isClosed) + { + if (j == (n_vert - 1)) + { + drawLine(arcStart, pvB[j], color); + } + } + else + { + if (((!i) || (i == (n_hor - 1))) && ((!j) || (j == (n_vert - 1)))) + { + drawLine(center, pvB[j], color); + } + } + } + } + pT = pvA; + pvA = pvB; + pvB = pT; + } + } + + virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btVector3& color) + { + drawLine(btVector3(bbMin[0], bbMin[1], bbMin[2]), btVector3(bbMax[0], bbMin[1], bbMin[2]), color); + drawLine(btVector3(bbMax[0], bbMin[1], bbMin[2]), btVector3(bbMax[0], bbMax[1], bbMin[2]), color); + drawLine(btVector3(bbMax[0], bbMax[1], bbMin[2]), btVector3(bbMin[0], bbMax[1], bbMin[2]), color); + drawLine(btVector3(bbMin[0], bbMax[1], bbMin[2]), btVector3(bbMin[0], bbMin[1], bbMin[2]), color); + drawLine(btVector3(bbMin[0], bbMin[1], bbMin[2]), btVector3(bbMin[0], bbMin[1], bbMax[2]), color); + drawLine(btVector3(bbMax[0], bbMin[1], bbMin[2]), btVector3(bbMax[0], bbMin[1], bbMax[2]), color); + drawLine(btVector3(bbMax[0], bbMax[1], bbMin[2]), btVector3(bbMax[0], bbMax[1], bbMax[2]), color); + drawLine(btVector3(bbMin[0], bbMax[1], bbMin[2]), btVector3(bbMin[0], bbMax[1], bbMax[2]), color); + drawLine(btVector3(bbMin[0], bbMin[1], bbMax[2]), btVector3(bbMax[0], bbMin[1], bbMax[2]), color); + drawLine(btVector3(bbMax[0], bbMin[1], bbMax[2]), btVector3(bbMax[0], bbMax[1], bbMax[2]), color); + drawLine(btVector3(bbMax[0], bbMax[1], bbMax[2]), btVector3(bbMin[0], bbMax[1], bbMax[2]), color); + drawLine(btVector3(bbMin[0], bbMax[1], bbMax[2]), btVector3(bbMin[0], bbMin[1], bbMax[2]), color); + } + virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btTransform& trans, const btVector3& color) + { + drawLine(trans * btVector3(bbMin[0], bbMin[1], bbMin[2]), trans * btVector3(bbMax[0], bbMin[1], bbMin[2]), color); + drawLine(trans * btVector3(bbMax[0], bbMin[1], bbMin[2]), trans * btVector3(bbMax[0], bbMax[1], bbMin[2]), color); + drawLine(trans * btVector3(bbMax[0], bbMax[1], bbMin[2]), trans * btVector3(bbMin[0], bbMax[1], bbMin[2]), color); + drawLine(trans * btVector3(bbMin[0], bbMax[1], bbMin[2]), trans * btVector3(bbMin[0], bbMin[1], bbMin[2]), color); + drawLine(trans * btVector3(bbMin[0], bbMin[1], bbMin[2]), trans * btVector3(bbMin[0], bbMin[1], bbMax[2]), color); + drawLine(trans * btVector3(bbMax[0], bbMin[1], bbMin[2]), trans * btVector3(bbMax[0], bbMin[1], bbMax[2]), color); + drawLine(trans * btVector3(bbMax[0], bbMax[1], bbMin[2]), trans * btVector3(bbMax[0], bbMax[1], bbMax[2]), color); + drawLine(trans * btVector3(bbMin[0], bbMax[1], bbMin[2]), trans * btVector3(bbMin[0], bbMax[1], bbMax[2]), color); + drawLine(trans * btVector3(bbMin[0], bbMin[1], bbMax[2]), trans * btVector3(bbMax[0], bbMin[1], bbMax[2]), color); + drawLine(trans * btVector3(bbMax[0], bbMin[1], bbMax[2]), trans * btVector3(bbMax[0], bbMax[1], bbMax[2]), color); + drawLine(trans * btVector3(bbMax[0], bbMax[1], bbMax[2]), trans * btVector3(bbMin[0], bbMax[1], bbMax[2]), color); + drawLine(trans * btVector3(bbMin[0], bbMax[1], bbMax[2]), trans * btVector3(bbMin[0], bbMin[1], bbMax[2]), color); + } + + virtual void drawCapsule(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color) + { + int stepDegrees = 30; + + btVector3 capStart(0.f, 0.f, 0.f); + capStart[upAxis] = -halfHeight; + + btVector3 capEnd(0.f, 0.f, 0.f); + capEnd[upAxis] = halfHeight; + + // Draw the ends + { + btTransform childTransform = transform; + childTransform.getOrigin() = transform * capStart; + { + btVector3 center = childTransform.getOrigin(); + btVector3 up = childTransform.getBasis().getColumn((upAxis + 1) % 3); + btVector3 axis = -childTransform.getBasis().getColumn(upAxis); + btScalar minTh = -SIMD_HALF_PI; + btScalar maxTh = SIMD_HALF_PI; + btScalar minPs = -SIMD_HALF_PI; + btScalar maxPs = SIMD_HALF_PI; + + drawSpherePatch(center, up, axis, radius, minTh, maxTh, minPs, maxPs, color, btScalar(stepDegrees), false); + } + } + + { + btTransform childTransform = transform; + childTransform.getOrigin() = transform * capEnd; + { + btVector3 center = childTransform.getOrigin(); + btVector3 up = childTransform.getBasis().getColumn((upAxis + 1) % 3); + btVector3 axis = childTransform.getBasis().getColumn(upAxis); + btScalar minTh = -SIMD_HALF_PI; + btScalar maxTh = SIMD_HALF_PI; + btScalar minPs = -SIMD_HALF_PI; + btScalar maxPs = SIMD_HALF_PI; + drawSpherePatch(center, up, axis, radius, minTh, maxTh, minPs, maxPs, color, btScalar(stepDegrees), false); + } + } + + // Draw some additional lines + btVector3 start = transform.getOrigin(); + + for (int i = 0; i < 360; i += stepDegrees) + { + capEnd[(upAxis + 1) % 3] = capStart[(upAxis + 1) % 3] = btSin(btScalar(i) * SIMD_RADS_PER_DEG) * radius; + capEnd[(upAxis + 2) % 3] = capStart[(upAxis + 2) % 3] = btCos(btScalar(i) * SIMD_RADS_PER_DEG) * radius; + drawLine(start + transform.getBasis() * capStart, start + transform.getBasis() * capEnd, color); + } + } + + virtual void drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color) + { + btVector3 start = transform.getOrigin(); + btVector3 offsetHeight(0, 0, 0); + offsetHeight[upAxis] = halfHeight; + int stepDegrees = 30; + btVector3 capStart(0.f, 0.f, 0.f); + capStart[upAxis] = -halfHeight; + btVector3 capEnd(0.f, 0.f, 0.f); + capEnd[upAxis] = halfHeight; + + for (int i = 0; i < 360; i += stepDegrees) + { + capEnd[(upAxis + 1) % 3] = capStart[(upAxis + 1) % 3] = btSin(btScalar(i) * SIMD_RADS_PER_DEG) * radius; + capEnd[(upAxis + 2) % 3] = capStart[(upAxis + 2) % 3] = btCos(btScalar(i) * SIMD_RADS_PER_DEG) * radius; + drawLine(start + transform.getBasis() * capStart, start + transform.getBasis() * capEnd, color); + } + // Drawing top and bottom caps of the cylinder + btVector3 yaxis(0, 0, 0); + yaxis[upAxis] = btScalar(1.0); + btVector3 xaxis(0, 0, 0); + xaxis[(upAxis + 1) % 3] = btScalar(1.0); + drawArc(start - transform.getBasis() * (offsetHeight), transform.getBasis() * yaxis, transform.getBasis() * xaxis, radius, radius, 0, SIMD_2_PI, color, false, btScalar(10.0)); + drawArc(start + transform.getBasis() * (offsetHeight), transform.getBasis() * yaxis, transform.getBasis() * xaxis, radius, radius, 0, SIMD_2_PI, color, false, btScalar(10.0)); + } + + virtual void drawCone(btScalar radius, btScalar height, int upAxis, const btTransform& transform, const btVector3& color) + { + int stepDegrees = 30; + btVector3 start = transform.getOrigin(); + + btVector3 offsetHeight(0, 0, 0); + btScalar halfHeight = height * btScalar(0.5); + offsetHeight[upAxis] = halfHeight; + btVector3 offsetRadius(0, 0, 0); + offsetRadius[(upAxis + 1) % 3] = radius; + btVector3 offset2Radius(0, 0, 0); + offset2Radius[(upAxis + 2) % 3] = radius; + + btVector3 capEnd(0.f, 0.f, 0.f); + capEnd[upAxis] = -halfHeight; + + for (int i = 0; i < 360; i += stepDegrees) + { + capEnd[(upAxis + 1) % 3] = btSin(btScalar(i) * SIMD_RADS_PER_DEG) * radius; + capEnd[(upAxis + 2) % 3] = btCos(btScalar(i) * SIMD_RADS_PER_DEG) * radius; + drawLine(start + transform.getBasis() * (offsetHeight), start + transform.getBasis() * capEnd, color); + } + + drawLine(start + transform.getBasis() * (offsetHeight), start + transform.getBasis() * (-offsetHeight + offsetRadius), color); + drawLine(start + transform.getBasis() * (offsetHeight), start + transform.getBasis() * (-offsetHeight - offsetRadius), color); + drawLine(start + transform.getBasis() * (offsetHeight), start + transform.getBasis() * (-offsetHeight + offset2Radius), color); + drawLine(start + transform.getBasis() * (offsetHeight), start + transform.getBasis() * (-offsetHeight - offset2Radius), color); + + // Drawing the base of the cone + btVector3 yaxis(0, 0, 0); + yaxis[upAxis] = btScalar(1.0); + btVector3 xaxis(0, 0, 0); + xaxis[(upAxis + 1) % 3] = btScalar(1.0); + drawArc(start - transform.getBasis() * (offsetHeight), transform.getBasis() * yaxis, transform.getBasis() * xaxis, radius, radius, 0, SIMD_2_PI, color, false, 10.0); + } + + virtual void drawPlane(const btVector3& planeNormal, btScalar planeConst, const btTransform& transform, const btVector3& color) + { + btVector3 planeOrigin = planeNormal * planeConst; + btVector3 vec0, vec1; + btPlaneSpace1(planeNormal, vec0, vec1); + btScalar vecLen = 100.f; + btVector3 pt0 = planeOrigin + vec0 * vecLen; + btVector3 pt1 = planeOrigin - vec0 * vecLen; + btVector3 pt2 = planeOrigin + vec1 * vecLen; + btVector3 pt3 = planeOrigin - vec1 * vecLen; + drawLine(transform * pt0, transform * pt1, color); + drawLine(transform * pt2, transform * pt3, color); + } + + virtual void clearLines() + { + } + + virtual void flushLines() + { + } +}; + +#endif //BT_IDEBUG_DRAW__H diff --git a/pkg/mphysics/mbt/LinearMath/btIDebugDraw.h.i b/pkg/mphysics/mbt/LinearMath/btIDebugDraw.h.i new file mode 100644 index 00000000..1eb0502a --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btIDebugDraw.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btIDebugDraw.h ---------------- + +%include "LinearMath/btIDebugDraw.h" + +%{ +#include "LinearMath/btIDebugDraw.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btImplicitQRSVD.h b/pkg/mphysics/mbt/LinearMath/btImplicitQRSVD.h new file mode 100644 index 00000000..aaedc964 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btImplicitQRSVD.h @@ -0,0 +1,916 @@ +/** + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Copyright (c) 2016 Theodore Gast, Chuyuan Fu, Chenfanfu Jiang, Joseph Teran + + Permission is hereby granted, free of charge, to any person obtaining a copy of + this software and associated documentation files (the "Software"), to deal in + the Software without restriction, including without limitation the rights to + use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is furnished to do + so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + If the code is used in an article, the following paper shall be cited: + @techreport{qrsvd:2016, + title={Implicit-shifted Symmetric QR Singular Value Decomposition of 3x3 Matrices}, + author={Gast, Theodore and Fu, Chuyuan and Jiang, Chenfanfu and Teran, Joseph}, + year={2016}, + institution={University of California Los Angeles} + } + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +**/ + +#ifndef btImplicitQRSVD_h +#define btImplicitQRSVD_h +#include +#include "btMatrix3x3.h" +class btMatrix2x2 +{ +public: + btScalar m_00, m_01, m_10, m_11; + btMatrix2x2(): m_00(0), m_10(0), m_01(0), m_11(0) + { + } + btMatrix2x2(const btMatrix2x2& other): m_00(other.m_00),m_01(other.m_01),m_10(other.m_10),m_11(other.m_11) + {} + btScalar& operator()(int i, int j) + { + if (i == 0 && j == 0) + return m_00; + if (i == 1 && j == 0) + return m_10; + if (i == 0 && j == 1) + return m_01; + if (i == 1 && j == 1) + return m_11; + btAssert(false); + return m_00; + } + const btScalar& operator()(int i, int j) const + { + if (i == 0 && j == 0) + return m_00; + if (i == 1 && j == 0) + return m_10; + if (i == 0 && j == 1) + return m_01; + if (i == 1 && j == 1) + return m_11; + btAssert(false); + return m_00; + } + void setIdentity() + { + m_00 = 1; + m_11 = 1; + m_01 = 0; + m_10 = 0; + } +}; + +static inline btScalar copySign(btScalar x, btScalar y) { + if ((x < 0 && y > 0) || (x > 0 && y < 0)) + return -x; + return x; +} + +/** + Class for givens rotation. + Row rotation G*A corresponds to something like + c -s 0 + ( s c 0 ) A + 0 0 1 + Column rotation A G' corresponds to something like + c -s 0 + A ( s c 0 ) + 0 0 1 + + c and s are always computed so that + ( c -s ) ( a ) = ( * ) + s c b ( 0 ) + + Assume rowi SIMD_EPSILON) { + btScalar sqrtd = btSqrt(d); + if (sqrtd>SIMD_EPSILON) + { + btScalar t = btScalar(1.0)/sqrtd; + c = a * t; + s = -b * t; + } + } + } + + /** + This function computes c and s so that + ( c -s ) ( a ) = ( 0 ) + s c b ( * ) + */ + inline void computeUnconventional(const btScalar a, const btScalar b) + { + btScalar d = a * a + b * b; + c = 0; + s = 1; + if (d > SIMD_EPSILON) { + btScalar t = btScalar(1.0)/btSqrt(d); + s = a * t; + c = b * t; + } + } + /** + Fill the R with the entries of this rotation + */ + inline void fill(const btMatrix3x3& R) const + { + btMatrix3x3& A = const_cast(R); + A.setIdentity(); + A[rowi][rowi] = c; + A[rowk][rowi] = -s; + A[rowi][rowk] = s; + A[rowk][rowk] = c; + } + + inline void fill(const btMatrix2x2& R) const + { + btMatrix2x2& A = const_cast(R); + A(rowi,rowi) = c; + A(rowk,rowi) = -s; + A(rowi,rowk) = s; + A(rowk,rowk) = c; + } + + /** + This function does something like + c -s 0 + ( s c 0 ) A -> A + 0 0 1 + It only affects row i and row k of A. + */ + inline void rowRotation(btMatrix3x3& A) const + { + for (int j = 0; j < 3; j++) { + btScalar tau1 = A[rowi][j]; + btScalar tau2 = A[rowk][j]; + A[rowi][j] = c * tau1 - s * tau2; + A[rowk][j] = s * tau1 + c * tau2; + } + } + inline void rowRotation(btMatrix2x2& A) const + { + for (int j = 0; j < 2; j++) { + btScalar tau1 = A(rowi,j); + btScalar tau2 = A(rowk,j); + A(rowi,j) = c * tau1 - s * tau2; + A(rowk,j) = s * tau1 + c * tau2; + } + } + + /** + This function does something like + c s 0 + A ( -s c 0 ) -> A + 0 0 1 + It only affects column i and column k of A. + */ + inline void columnRotation(btMatrix3x3& A) const + { + for (int j = 0; j < 3; j++) { + btScalar tau1 = A[j][rowi]; + btScalar tau2 = A[j][rowk]; + A[j][rowi] = c * tau1 - s * tau2; + A[j][rowk] = s * tau1 + c * tau2; + } + } + inline void columnRotation(btMatrix2x2& A) const + { + for (int j = 0; j < 2; j++) { + btScalar tau1 = A(j,rowi); + btScalar tau2 = A(j,rowk); + A(j,rowi) = c * tau1 - s * tau2; + A(j,rowk) = s * tau1 + c * tau2; + } + } + + /** + Multiply givens must be for same row and column + **/ + inline void operator*=(const GivensRotation& A) + { + btScalar new_c = c * A.c - s * A.s; + btScalar new_s = s * A.c + c * A.s; + c = new_c; + s = new_s; + } + + /** + Multiply givens must be for same row and column + **/ + inline GivensRotation operator*(const GivensRotation& A) const + { + GivensRotation r(*this); + r *= A; + return r; + } +}; + +/** + \brief zero chasing the 3X3 matrix to bidiagonal form + original form of H: x x 0 + x x x + 0 0 x + after zero chase: + x x 0 + 0 x x + 0 0 x + */ +inline void zeroChase(btMatrix3x3& H, btMatrix3x3& U, btMatrix3x3& V) +{ + + /** + Reduce H to of form + x x + + 0 x x + 0 0 x + */ + GivensRotation r1(H[0][0], H[1][0], 0, 1); + /** + Reduce H to of form + x x 0 + 0 x x + 0 + x + Can calculate r2 without multiplying by r1 since both entries are in first two + rows thus no need to divide by sqrt(a^2+b^2) + */ + GivensRotation r2(1, 2); + if (H[1][0] != 0) + r2.compute(H[0][0] * H[0][1] + H[1][0] * H[1][1], H[0][0] * H[0][2] + H[1][0] * H[1][2]); + else + r2.compute(H[0][1], H[0][2]); + + r1.rowRotation(H); + + /* GivensRotation r2(H(0, 1), H(0, 2), 1, 2); */ + r2.columnRotation(H); + r2.columnRotation(V); + + /** + Reduce H to of form + x x 0 + 0 x x + 0 0 x + */ + GivensRotation r3(H[1][1], H[2][1], 1, 2); + r3.rowRotation(H); + + // Save this till end for better cache coherency + // r1.rowRotation(u_transpose); + // r3.rowRotation(u_transpose); + r1.columnRotation(U); + r3.columnRotation(U); +} + +/** + \brief make a 3X3 matrix to upper bidiagonal form + original form of H: x x x + x x x + x x x + after zero chase: + x x 0 + 0 x x + 0 0 x + */ +inline void makeUpperBidiag(btMatrix3x3& H, btMatrix3x3& U, btMatrix3x3& V) +{ + U.setIdentity(); + V.setIdentity(); + + /** + Reduce H to of form + x x x + x x x + 0 x x + */ + + GivensRotation r(H[1][0], H[2][0], 1, 2); + r.rowRotation(H); + // r.rowRotation(u_transpose); + r.columnRotation(U); + // zeroChase(H, u_transpose, V); + zeroChase(H, U, V); +} + +/** + \brief make a 3X3 matrix to lambda shape + original form of H: x x x + * x x x + * x x x + after : + * x 0 0 + * x x 0 + * x 0 x + */ +inline void makeLambdaShape(btMatrix3x3& H, btMatrix3x3& U, btMatrix3x3& V) +{ + U.setIdentity(); + V.setIdentity(); + + /** + Reduce H to of form + * x x 0 + * x x x + * x x x + */ + + GivensRotation r1(H[0][1], H[0][2], 1, 2); + r1.columnRotation(H); + r1.columnRotation(V); + + /** + Reduce H to of form + * x x 0 + * x x 0 + * x x x + */ + + r1.computeUnconventional(H[1][2], H[2][2]); + r1.rowRotation(H); + r1.columnRotation(U); + + /** + Reduce H to of form + * x x 0 + * x x 0 + * x 0 x + */ + + GivensRotation r2(H[2][0], H[2][1], 0, 1); + r2.columnRotation(H); + r2.columnRotation(V); + + /** + Reduce H to of form + * x 0 0 + * x x 0 + * x 0 x + */ + r2.computeUnconventional(H[0][1], H[1][1]); + r2.rowRotation(H); + r2.columnRotation(U); +} + +/** + \brief 2x2 polar decomposition. + \param[in] A matrix. + \param[out] R Robustly a rotation matrix. + \param[out] S_Sym Symmetric. Whole matrix is stored + + Polar guarantees negative sign is on the small magnitude singular value. + S is guaranteed to be the closest one to identity. + R is guaranteed to be the closest rotation to A. + */ +inline void polarDecomposition(const btMatrix2x2& A, + GivensRotation& R, + const btMatrix2x2& S_Sym) +{ + btScalar a = (A(0, 0) + A(1, 1)), b = (A(1, 0) - A(0, 1)); + btScalar denominator = btSqrt(a*a+b*b); + R.c = (btScalar)1; + R.s = (btScalar)0; + if (denominator > SIMD_EPSILON) { + /* + No need to use a tolerance here because x(0) and x(1) always have + smaller magnitude then denominator, therefore overflow never happens. + In Bullet, we use a tolerance anyway. + */ + R.c = a / denominator; + R.s = -b / denominator; + } + btMatrix2x2& S = const_cast(S_Sym); + S = A; + R.rowRotation(S); +} + +inline void polarDecomposition(const btMatrix2x2& A, + const btMatrix2x2& R, + const btMatrix2x2& S_Sym) +{ + GivensRotation r(0, 1); + polarDecomposition(A, r, S_Sym); + r.fill(R); +} + +/** + \brief 2x2 SVD (singular value decomposition) A=USV' + \param[in] A Input matrix. + \param[out] U Robustly a rotation matrix in Givens form + \param[out] Sigma matrix of singular values sorted with decreasing magnitude. The second one can be negative. + \param[out] V Robustly a rotation matrix in Givens form + */ +inline void singularValueDecomposition( + const btMatrix2x2& A, + GivensRotation& U, + const btMatrix2x2& Sigma, + GivensRotation& V, + const btScalar tol = 64 * std::numeric_limits::epsilon()) +{ + btMatrix2x2& sigma = const_cast(Sigma); + sigma.setIdentity(); + btMatrix2x2 S_Sym; + polarDecomposition(A, U, S_Sym); + btScalar cosine, sine; + btScalar x = S_Sym(0, 0); + btScalar y = S_Sym(0, 1); + btScalar z = S_Sym(1, 1); + if (y == 0) { + // S is already diagonal + cosine = 1; + sine = 0; + sigma(0,0) = x; + sigma(1,1) = z; + } + else { + btScalar tau = 0.5 * (x - z); + btScalar val = tau * tau + y * y; + if (val > SIMD_EPSILON) + { + btScalar w = btSqrt(val); + // w > y > 0 + btScalar t; + if (tau > 0) { + // tau + w > w > y > 0 ==> division is safe + t = y / (tau + w); + } + else { + // tau - w < -w < -y < 0 ==> division is safe + t = y / (tau - w); + } + cosine = btScalar(1) / btSqrt(t * t + btScalar(1)); + sine = -t * cosine; + /* + V = [cosine -sine; sine cosine] + Sigma = V'SV. Only compute the diagonals for efficiency. + Also utilize symmetry of S and don't form V yet. + */ + btScalar c2 = cosine * cosine; + btScalar csy = 2 * cosine * sine * y; + btScalar s2 = sine * sine; + sigma(0,0) = c2 * x - csy + s2 * z; + sigma(1,1) = s2 * x + csy + c2 * z; + } else + { + cosine = 1; + sine = 0; + sigma(0,0) = x; + sigma(1,1) = z; + } + } + + // Sorting + // Polar already guarantees negative sign is on the small magnitude singular value. + if (sigma(0,0) < sigma(1,1)) { + std::swap(sigma(0,0), sigma(1,1)); + V.c = -sine; + V.s = cosine; + } + else { + V.c = cosine; + V.s = sine; + } + U *= V; +} + +/** + \brief 2x2 SVD (singular value decomposition) A=USV' + \param[in] A Input matrix. + \param[out] U Robustly a rotation matrix. + \param[out] Sigma Vector of singular values sorted with decreasing magnitude. The second one can be negative. + \param[out] V Robustly a rotation matrix. + */ +inline void singularValueDecomposition( + const btMatrix2x2& A, + const btMatrix2x2& U, + const btMatrix2x2& Sigma, + const btMatrix2x2& V, + const btScalar tol = 64 * std::numeric_limits::epsilon()) +{ + GivensRotation gv(0, 1); + GivensRotation gu(0, 1); + singularValueDecomposition(A, gu, Sigma, gv); + + gu.fill(U); + gv.fill(V); +} + +/** + \brief compute wilkinsonShift of the block + a1 b1 + b1 a2 + based on the wilkinsonShift formula + mu = c + d - sign (d) \ sqrt (d*d + b*b), where d = (a-c)/2 + + */ +inline btScalar wilkinsonShift(const btScalar a1, const btScalar b1, const btScalar a2) +{ + btScalar d = (btScalar)0.5 * (a1 - a2); + btScalar bs = b1 * b1; + btScalar val = d * d + bs; + if (val>SIMD_EPSILON) + { + btScalar denom = btFabs(d) + btSqrt(val); + + btScalar mu = a2 - copySign(bs / (denom), d); + // T mu = a2 - bs / ( d + sign_d*sqrt (d*d + bs)); + return mu; + } + return a2; +} + +/** + \brief Helper function of 3X3 SVD for processing 2X2 SVD + */ +template +inline void process(btMatrix3x3& B, btMatrix3x3& U, btVector3& sigma, btMatrix3x3& V) +{ + int other = (t == 1) ? 0 : 2; + GivensRotation u(0, 1); + GivensRotation v(0, 1); + sigma[other] = B[other][other]; + + btMatrix2x2 B_sub, sigma_sub; + if (t == 0) + { + B_sub.m_00 = B[0][0]; + B_sub.m_10 = B[1][0]; + B_sub.m_01 = B[0][1]; + B_sub.m_11 = B[1][1]; + sigma_sub.m_00 = sigma[0]; + sigma_sub.m_11 = sigma[1]; +// singularValueDecomposition(B.template block<2, 2>(t, t), u, sigma.template block<2, 1>(t, 0), v); + singularValueDecomposition(B_sub, u, sigma_sub, v); + B[0][0] = B_sub.m_00; + B[1][0] = B_sub.m_10; + B[0][1] = B_sub.m_01; + B[1][1] = B_sub.m_11; + sigma[0] = sigma_sub.m_00; + sigma[1] = sigma_sub.m_11; + } + else + { + B_sub.m_00 = B[1][1]; + B_sub.m_10 = B[2][1]; + B_sub.m_01 = B[1][2]; + B_sub.m_11 = B[2][2]; + sigma_sub.m_00 = sigma[1]; + sigma_sub.m_11 = sigma[2]; + // singularValueDecomposition(B.template block<2, 2>(t, t), u, sigma.template block<2, 1>(t, 0), v); + singularValueDecomposition(B_sub, u, sigma_sub, v); + B[1][1] = B_sub.m_00; + B[2][1] = B_sub.m_10; + B[1][2] = B_sub.m_01; + B[2][2] = B_sub.m_11; + sigma[1] = sigma_sub.m_00; + sigma[2] = sigma_sub.m_11; + } + u.rowi += t; + u.rowk += t; + v.rowi += t; + v.rowk += t; + u.columnRotation(U); + v.columnRotation(V); +} + +/** + \brief Helper function of 3X3 SVD for flipping signs due to flipping signs of sigma + */ +inline void flipSign(int i, btMatrix3x3& U, btVector3& sigma) +{ + sigma[i] = -sigma[i]; + U[0][i] = -U[0][i]; + U[1][i] = -U[1][i]; + U[2][i] = -U[2][i]; +} + +inline void flipSign(int i, btMatrix3x3& U) +{ + U[0][i] = -U[0][i]; + U[1][i] = -U[1][i]; + U[2][i] = -U[2][i]; +} + +inline void swapCol(btMatrix3x3& A, int i, int j) +{ + for (int d = 0; d < 3; ++d) + std::swap(A[d][i], A[d][j]); +} +/** + \brief Helper function of 3X3 SVD for sorting singular values + */ +inline void sort(btMatrix3x3& U, btVector3& sigma, btMatrix3x3& V, int t) +{ + if (t == 0) + { + // Case: sigma(0) > |sigma(1)| >= |sigma(2)| + if (btFabs(sigma[1]) >= btFabs(sigma[2])) { + if (sigma[1] < 0) { + flipSign(1, U, sigma); + flipSign(2, U, sigma); + } + return; + } + + //fix sign of sigma for both cases + if (sigma[2] < 0) { + flipSign(1, U, sigma); + flipSign(2, U, sigma); + } + + //swap sigma(1) and sigma(2) for both cases + std::swap(sigma[1], sigma[2]); + // swap the col 1 and col 2 for U,V + swapCol(U,1,2); + swapCol(V,1,2); + + // Case: |sigma(2)| >= sigma(0) > |simga(1)| + if (sigma[1] > sigma[0]) { + std::swap(sigma[0], sigma[1]); + swapCol(U,0,1); + swapCol(V,0,1); + } + + // Case: sigma(0) >= |sigma(2)| > |simga(1)| + else { + flipSign(2, U); + flipSign(2, V); + } + } + else if (t == 1) + { + // Case: |sigma(0)| >= sigma(1) > |sigma(2)| + if (btFabs(sigma[0]) >= sigma[1]) { + if (sigma[0] < 0) { + flipSign(0, U, sigma); + flipSign(2, U, sigma); + } + return; + } + + //swap sigma(0) and sigma(1) for both cases + std::swap(sigma[0], sigma[1]); + swapCol(U, 0, 1); + swapCol(V, 0, 1); + + // Case: sigma(1) > |sigma(2)| >= |sigma(0)| + if (btFabs(sigma[1]) < btFabs(sigma[2])) { + std::swap(sigma[1], sigma[2]); + swapCol(U, 1, 2); + swapCol(V, 1, 2); + } + + // Case: sigma(1) >= |sigma(0)| > |sigma(2)| + else { + flipSign(1, U); + flipSign(1, V); + } + + // fix sign for both cases + if (sigma[1] < 0) { + flipSign(1, U, sigma); + flipSign(2, U, sigma); + } + } +} + +/** + \brief 3X3 SVD (singular value decomposition) A=USV' + \param[in] A Input matrix. + \param[out] U is a rotation matrix. + \param[out] sigma Diagonal matrix, sorted with decreasing magnitude. The third one can be negative. + \param[out] V is a rotation matrix. + */ +inline int singularValueDecomposition(const btMatrix3x3& A, + btMatrix3x3& U, + btVector3& sigma, + btMatrix3x3& V, + btScalar tol = 128*std::numeric_limits::epsilon()) +{ +// using std::fabs; + btMatrix3x3 B = A; + U.setIdentity(); + V.setIdentity(); + + makeUpperBidiag(B, U, V); + + int count = 0; + btScalar mu = (btScalar)0; + GivensRotation r(0, 1); + + btScalar alpha_1 = B[0][0]; + btScalar beta_1 = B[0][1]; + btScalar alpha_2 = B[1][1]; + btScalar alpha_3 = B[2][2]; + btScalar beta_2 = B[1][2]; + btScalar gamma_1 = alpha_1 * beta_1; + btScalar gamma_2 = alpha_2 * beta_2; + btScalar val = alpha_1 * alpha_1 + alpha_2 * alpha_2 + alpha_3 * alpha_3 + beta_1 * beta_1 + beta_2 * beta_2; + if (val > SIMD_EPSILON) + { + tol *= btMax((btScalar)0.5 * btSqrt(val), (btScalar)1); + } + /** + Do implicit shift QR until A^T A is block diagonal + */ + int max_count = 100; + + while (btFabs(beta_2) > tol && btFabs(beta_1) > tol + && btFabs(alpha_1) > tol && btFabs(alpha_2) > tol + && btFabs(alpha_3) > tol + && count < max_count) { + mu = wilkinsonShift(alpha_2 * alpha_2 + beta_1 * beta_1, gamma_2, alpha_3 * alpha_3 + beta_2 * beta_2); + + r.compute(alpha_1 * alpha_1 - mu, gamma_1); + r.columnRotation(B); + + r.columnRotation(V); + zeroChase(B, U, V); + + alpha_1 = B[0][0]; + beta_1 = B[0][1]; + alpha_2 = B[1][1]; + alpha_3 = B[2][2]; + beta_2 = B[1][2]; + gamma_1 = alpha_1 * beta_1; + gamma_2 = alpha_2 * beta_2; + count++; + } + /** + Handle the cases of one of the alphas and betas being 0 + Sorted by ease of handling and then frequency + of occurrence + + If B is of form + x x 0 + 0 x 0 + 0 0 x + */ + if (btFabs(beta_2) <= tol) { + process<0>(B, U, sigma, V); + sort(U, sigma, V,0); + } + /** + If B is of form + x 0 0 + 0 x x + 0 0 x + */ + else if (btFabs(beta_1) <= tol) { + process<1>(B, U, sigma, V); + sort(U, sigma, V,1); + } + /** + If B is of form + x x 0 + 0 0 x + 0 0 x + */ + else if (btFabs(alpha_2) <= tol) { + /** + Reduce B to + x x 0 + 0 0 0 + 0 0 x + */ + GivensRotation r1(1, 2); + r1.computeUnconventional(B[1][2], B[2][2]); + r1.rowRotation(B); + r1.columnRotation(U); + + process<0>(B, U, sigma, V); + sort(U, sigma, V, 0); + } + /** + If B is of form + x x 0 + 0 x x + 0 0 0 + */ + else if (btFabs(alpha_3) <= tol) { + /** + Reduce B to + x x + + 0 x 0 + 0 0 0 + */ + GivensRotation r1(1, 2); + r1.compute(B[1][1], B[1][2]); + r1.columnRotation(B); + r1.columnRotation(V); + /** + Reduce B to + x x 0 + + x 0 + 0 0 0 + */ + GivensRotation r2(0, 2); + r2.compute(B[0][0], B[0][2]); + r2.columnRotation(B); + r2.columnRotation(V); + + process<0>(B, U, sigma, V); + sort(U, sigma, V, 0); + } + /** + If B is of form + 0 x 0 + 0 x x + 0 0 x + */ + else if (btFabs(alpha_1) <= tol) { + /** + Reduce B to + 0 0 + + 0 x x + 0 0 x + */ + GivensRotation r1(0, 1); + r1.computeUnconventional(B[0][1], B[1][1]); + r1.rowRotation(B); + r1.columnRotation(U); + + /** + Reduce B to + 0 0 0 + 0 x x + 0 + x + */ + GivensRotation r2(0, 2); + r2.computeUnconventional(B[0][2], B[2][2]); + r2.rowRotation(B); + r2.columnRotation(U); + + process<1>(B, U, sigma, V); + sort(U, sigma, V, 1); + } + + return count; +} +#endif /* btImplicitQRSVD_h */ diff --git a/pkg/mphysics/mbt/LinearMath/btImplicitQRSVD.h.i b/pkg/mphysics/mbt/LinearMath/btImplicitQRSVD.h.i new file mode 100644 index 00000000..f98264f0 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btImplicitQRSVD.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btImplicitQRSVD.h ---------------- + +%include "LinearMath/btImplicitQRSVD.h" + +%{ +#include "LinearMath/btImplicitQRSVD.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btList.h b/pkg/mphysics/mbt/LinearMath/btList.h new file mode 100644 index 00000000..9072abcd --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btList.h @@ -0,0 +1,73 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_GEN_LIST_H +#define BT_GEN_LIST_H + +class btGEN_Link +{ +public: + btGEN_Link() : m_next(0), m_prev(0) {} + btGEN_Link(btGEN_Link *next, btGEN_Link *prev) : m_next(next), m_prev(prev) {} + + btGEN_Link *getNext() const { return m_next; } + btGEN_Link *getPrev() const { return m_prev; } + + bool isHead() const { return m_prev == 0; } + bool isTail() const { return m_next == 0; } + + void insertBefore(btGEN_Link *link) + { + m_next = link; + m_prev = link->m_prev; + m_next->m_prev = this; + m_prev->m_next = this; + } + + void insertAfter(btGEN_Link *link) + { + m_next = link->m_next; + m_prev = link; + m_next->m_prev = this; + m_prev->m_next = this; + } + + void remove() + { + m_next->m_prev = m_prev; + m_prev->m_next = m_next; + } + +private: + btGEN_Link *m_next; + btGEN_Link *m_prev; +}; + +class btGEN_List +{ +public: + btGEN_List() : m_head(&m_tail, 0), m_tail(0, &m_head) {} + + btGEN_Link *getHead() const { return m_head.getNext(); } + btGEN_Link *getTail() const { return m_tail.getPrev(); } + + void addHead(btGEN_Link *link) { link->insertAfter(&m_head); } + void addTail(btGEN_Link *link) { link->insertBefore(&m_tail); } + +private: + btGEN_Link m_head; + btGEN_Link m_tail; +}; + +#endif //BT_GEN_LIST_H diff --git a/pkg/mphysics/mbt/LinearMath/btList.h.i b/pkg/mphysics/mbt/LinearMath/btList.h.i new file mode 100644 index 00000000..586d7ced --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btList.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btList.h ---------------- + +%include "LinearMath/btList.h" + +%{ +#include "LinearMath/btList.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btMDebugDraw.cpp b/pkg/mphysics/mbt/LinearMath/btMDebugDraw.cpp new file mode 100644 index 00000000..a3831bdc --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMDebugDraw.cpp @@ -0,0 +1,183 @@ +#include "btMDebugDraw.h" + +btMDefaultColors::btMDefaultColors(btVector3 activeObject, btVector3 deactivatedObject, btVector3 wantsDeactivationObject, btVector3 disabledDeactivationObject, btVector3 disabledSimulationObject, btVector3 aabb, btVector3 contactPoint) + : btIDebugDraw::DefaultColors() +{ + m_activeObject = activeObject; + m_deactivatedObject = deactivatedObject; + m_wantsDeactivationObject = wantsDeactivationObject; + m_disabledDeactivationObject = disabledDeactivationObject; + m_disabledSimulationObject = disabledSimulationObject; + m_aabb = aabb; + m_contactPoint = contactPoint; +} + +// --------------------------------------------------------- + +btMDebugDrawLiner::btMDebugDrawLiner() {} +btMDebugDrawLiner::~btMDebugDrawLiner() {} + +// void btMDebugDrawLiner::drawLine(const btVector3& from, const btVector3& to, const btVector3& color) { +// printf("btMDebugDrawLiner::drawLine: from(%f, %f, %f), to(%f, %f, %f), color(%f, %f, %f)\n", from.x(), from.y(), from.z(), to.x(), to.y(), to.z(), color.x(), color.y(), color.z()); +// } + +// --------------------------------------------------------- +// コンストラクタ +btMDebugDraw::btMDebugDraw() : + m_debugMode(0) + , m_defaultColors( + btVector3(1.0f, 0.0f, 0.0f), // activeObject + btVector3(0.0f, 1.0f, 0.0f), // deactivatedObject + btVector3(0.0f, 1.0f, 1.0f), // wantsDeactivationObject + btVector3(1.0f, 0.0f, 1.0f), // disabledDeactivationObject + btVector3(1.0f, 1.0f, 1.0f), // disabledSimulationObject + btVector3(1.0f, 1.0f, 1.0f), // aabb + btVector3(0.0f, 0.0f, 1.0f) // contactPoint + ) + , m_liner(0) + {} +btMDebugDraw::~btMDebugDraw() {} + +// 継承先で実装が必要なメソッド +void btMDebugDraw::drawContactPoint(const btVector3& PointOnB, const btVector3& normalOnB, btScalar distance, int lifeTime, const btVector3& color) { + // Implement drawContactPoint method here + // printf("drawContactPoint: PointOnB(%f, %f, %f), normalOnB(%f, %f, %f), distance(%f), lifeTime(%d), color(%f, %f, %f)\n", PointOnB.x(), PointOnB.y(), PointOnB.z(), normalOnB.x(), normalOnB.y(), normalOnB.z(), distance, lifeTime, color.x(), color.y(), color.z()); + + getLiner()->drawLine( PointOnB, PointOnB + normalOnB * distance, color ); + btVector3 ncolor( 0, 0.5, 0.5 ); + getLiner()->drawLine( PointOnB, PointOnB + normalOnB * 0.01f, ncolor ); +} + +void btMDebugDraw::drawLine(const btVector3& from, const btVector3& to, const btVector3& color) { + // Implement drawLine method here + // printf("drawLine: from(%f, %f, %f), to(%f, %f, %f), color(%f, %f, %f)\n", from.x(), from.y(), from.z(), to.x(), to.y(), to.z(), color.x(), color.y(), color.z()); + getLiner()->drawLine(from, to, color); +} + +void btMDebugDraw::reportErrorWarning(const char* warningString) { + // Implement reportErrorWarning method here + // printf("reportErrorWarning: %s\n", warningString); +} + +void btMDebugDraw::draw3dText(const btVector3& location, const char* textString) { + // Implement draw3dText method here + // printf("draw3dText: location(%f, %f, %f), textString(%s)\n", location.x(), location.y(), location.z(), textString); +} + +// 独自メソッド +void btMDebugDraw::setLiner(btMDebugDrawLiner* liner) { + // printf("setLiner: %p\n", liner); + m_liner = liner; +} + +btMDebugDrawLiner* btMDebugDraw::getLiner() { + // printf("getLiner: %p\n", m_liner); + return m_liner; +} + +// ヘッダーで定義済みのメソッド +void btMDebugDraw::setDebugMode(int debugMode) { + // printf("setDebugMode: %d\n", debugMode); + m_debugMode = debugMode; +} + +int btMDebugDraw::getDebugMode() const { + // printf("getDebugMode: %d\n", m_debugMode); + return m_debugMode; +} + +// btIDebugDrawで定義済みのメソッド +void btMDebugDraw::setMDefaultColors(const btMDefaultColors& colors) { + m_defaultColors = colors; +} + +btIDebugDraw::DefaultColors btMDebugDraw::getDefaultColors() const { + return m_defaultColors; +} + +void btMDebugDraw::drawLine(const btVector3& from, const btVector3& to, const btVector3& fromColor, const btVector3& toColor) { + // printf("drawLine: from(%f, %f, %f), to(%f, %f, %f), fromColor(%f, %f, %f), toColor(%f, %f, %f)\n", from.x(), from.y(), from.z(), to.x(), to.y(), to.z(), fromColor.x(), fromColor.y(), fromColor.z(), toColor.x(), toColor.y(), toColor.z()); + (void)toColor; + drawLine(from, to, fromColor); +} + +void btMDebugDraw::drawSphere(btScalar radius, const btTransform& transform, const btVector3& color) { + // printf("drawSphere: radius(%f), transform(%f, %f, %f), color(%f, %f, %f)\n", radius, transform.getOrigin().x(), transform.getOrigin().y(), transform.getOrigin().z(), color.x(), color.y(), color.z()); + btIDebugDraw::drawSphere(radius, transform, color); +} + +void btMDebugDraw::drawSphere(const btVector3& p, btScalar radius, const btVector3& color) { + // printf("drawSphere: p(%f, %f, %f), radius(%f), color(%f, %f, %f)\n", p.x(), p.y(), p.z(), radius, color.x(), color.y(), color.z()); + btIDebugDraw::drawSphere(p, radius, color); +} + +void btMDebugDraw::drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& n0, const btVector3& n1, const btVector3& n2, const btVector3& color, btScalar alpha) { + // printf("drawTriangle: v0(%f, %f, %f), v1(%f, %f, %f), v2(%f, %f, %f), n0(%f, %f, %f), n1(%f, %f, %f), n2(%f, %f, %f), color(%f, %f, %f), alpha(%f)\n", v0.x(), v0.y(), v0.z(), v1.x(), v1.y(), v1.z(), v2.x(), v2.y(), v2.z(), n0.x(), n0.y(), n0.z(), n1.x(), n1.y(), n1.z(), n2.x(), n2.y(), n2.z(), color.x(), color.y(), color.z(), alpha); + btIDebugDraw::drawTriangle(v0, v1, v2, n0, n1, n2, color, alpha); +} + +void btMDebugDraw::drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& color, btScalar alpha) { + // printf("drawTriangle: v0(%f, %f, %f), v1(%f, %f, %f), v2(%f, %f, %f), color(%f, %f, %f), alpha(%f)\n", v0.x(), v0.y(), v0.z(), v1.x(), v1.y(), v1.z(), v2.x(), v2.y(), v2.z(), color.x(), color.y(), color.z(), alpha); + btIDebugDraw::drawTriangle(v0, v1, v2, color, alpha); +} + +void btMDebugDraw::drawAabb(const btVector3& from, const btVector3& to, const btVector3& color) { + // printf("drawAabb: from(%f, %f, %f), to(%f, %f, %f), color(%f, %f, %f)\n", from.x(), from.y(), from.z(), to.x(), to.y(), to.z(), color.x(), color.y(), color.z()); + btIDebugDraw::drawAabb(from, to, color); +} + +void btMDebugDraw::drawTransform(const btTransform& transform, btScalar orthoLen) { + // printf("drawTransform: transform(%f, %f, %f), orthoLen(%f)\n", transform.getOrigin().x(), transform.getOrigin().y(), transform.getOrigin().z(), orthoLen); + btIDebugDraw::drawTransform(transform, orthoLen); +} + +void btMDebugDraw::drawArc(const btVector3& center, const btVector3& normal, const btVector3& axis, btScalar radiusA, btScalar radiusB, btScalar minAngle, btScalar maxAngle, const btVector3& color, bool drawSect, btScalar stepDegrees) { + // printf("drawArc: center(%f, %f, %f), normal(%f, %f, %f), axis(%f, %f, %f), radiusA(%f), radiusB(%f), minAngle(%f), maxAngle(%f), color(%f, %f, %f), drawSect(%d), stepDegrees(%f)\n", center.x(), center.y(), center.z(), normal.x(), normal.y(), normal.z(), axis.x(), axis.y(), axis.z(), radiusA, radiusB, minAngle, maxAngle, color.x(), color.y(), color.z(), drawSect, stepDegrees); + btIDebugDraw::drawArc(center, normal, axis, radiusA, radiusB, minAngle, maxAngle, color, drawSect, stepDegrees); +} + +void btMDebugDraw::drawSpherePatch(const btVector3& center, const btVector3& up, const btVector3& axis, btScalar radius, btScalar minTh, btScalar maxTh, btScalar minPs, btScalar maxPs, const btVector3& color, btScalar stepDegrees, bool drawCenter) { + // printf("drawSpherePatch: center(%f, %f, %f), up(%f, %f, %f), axis(%f, %f, %f), radius(%f), minTh(%f), maxTh(%f), minPs(%f), maxPs(%f), color(%f, %f, %f), stepDegrees(%f), drawCenter(%d)\n", center.x(), center.y(), center.z(), up.x(), up.y(), up.z(), axis.x(), axis.y(), axis.z(), radius, minTh, maxTh, minPs, maxPs, color.x(), color.y(), color.z(), stepDegrees, drawCenter); + btIDebugDraw::drawSpherePatch(center, up, axis, radius, minTh, maxTh, minPs, maxPs, color, stepDegrees, drawCenter); +} + +void btMDebugDraw::drawBox(const btVector3& bbMin, const btVector3& bbMax, const btVector3& color) { + // printf("drawBox: bbMin(%f, %f, %f), bbMax(%f, %f, %f), color(%f, %f, %f)\n", bbMin.x(), bbMin.y(), bbMin.z(), bbMax.x(), bbMax.y(), bbMax.z(), color.x(), color.y(), color.z()); + btIDebugDraw::drawBox(bbMin, bbMax, color); +} + +void btMDebugDraw::drawBox(const btVector3& bbMin, const btVector3& bbMax, const btTransform& trans, const btVector3& color) { + // printf("drawBox: bbMin(%f, %f, %f), bbMax: (%f, %f, %f), trans: (%f, %f, %f), color(%f, %f, %f)\n", bbMin.x(), bbMin.y(), bbMin.z(), bbMax.x(), bbMax.y(), bbMax.z(), color.x(), color.y(), color.z()); + btIDebugDraw::drawBox(bbMin, bbMax, trans, color); +} + +void btMDebugDraw::drawCapsule(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color) { + // printf("drawCapsule: radius(%f), halfHeight(%f), upAxis(%d), transform(%f, %f, %f), color(%f, %f, %f)\n", radius, halfHeight, upAxis, transform.getOrigin().x(), transform.getOrigin().y(), transform.getOrigin().z(), color.x(), color.y(), color.z()); + btIDebugDraw::drawCapsule(radius, halfHeight, upAxis, transform, color); +} + +void btMDebugDraw::drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color) { + // printf("drawCylinder: radius(%f), halfHeight(%f), upAxis(%d), transform(%f, %f, %f), color(%f, %f, %f)\n", radius, halfHeight, upAxis, transform.getOrigin().x(), transform.getOrigin().y(), transform.getOrigin().z(), color.x(), color.y(), color.z()); + btIDebugDraw::drawCylinder(radius, halfHeight, upAxis, transform, color); +} + +void btMDebugDraw::drawCone(btScalar radius, btScalar height, int upAxis, const btTransform& transform, const btVector3& color) { + // printf("drawCone: radius(%f), height(%f), upAxis(%d), transform(%f, %f, %f), color(%f, %f, %f)\n", radius, height, upAxis, transform.getOrigin().x(), transform.getOrigin().y(), transform.getOrigin().z(), color.x(), color.y(), color.z()); + btIDebugDraw::drawCone(radius, height, upAxis, transform, color); +} + +void btMDebugDraw::drawPlane(const btVector3& planeNormal, btScalar planeConst, const btTransform& transform, const btVector3& color) { + // printf("drawPlane: planeNormal(%f, %f, %f), planeConst(%f), transform(%f, %f, %f), color(%f, %f, %f)\n", planeNormal.x(), planeNormal.y(), planeNormal.z(), planeConst, transform.getOrigin().x(), transform.getOrigin().y(), transform.getOrigin().z(), color.x(), color.y(), color.z()); + btIDebugDraw::drawPlane(planeNormal, planeConst, transform, color); +} + +void btMDebugDraw::clearLines() { + // printf("clearLines\n"); + btIDebugDraw::clearLines(); +} + +void btMDebugDraw::flushLines() { + // printf("flushLines\n"); + btIDebugDraw::flushLines(); +} + diff --git a/pkg/mphysics/mbt/LinearMath/btMDebugDraw.cpp.i b/pkg/mphysics/mbt/LinearMath/btMDebugDraw.cpp.i new file mode 100644 index 00000000..cbfd6906 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMDebugDraw.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btMDebugDraw.cpp ---------------- + +%include "LinearMath/btMDebugDraw.cpp" + +%{ +#include "LinearMath/btMDebugDraw.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btMDebugDraw.h b/pkg/mphysics/mbt/LinearMath/btMDebugDraw.h new file mode 100644 index 00000000..ee668a88 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMDebugDraw.h @@ -0,0 +1,70 @@ +#ifndef BTMDEBUGDRAW_H +#define BTMDEBUGDRAW_H + +#include "btIDebugDraw.h" + +class btMDefaultColors: public btIDebugDraw::DefaultColors { +public: + btMDefaultColors(btVector3 activeObject, btVector3 deactivatedObject, btVector3 wantsDeactivationObject, btVector3 disabledDeactivationObject, btVector3 disabledSimulationObject, btVector3 aabb, btVector3 contactPoint); +}; + + +class btMDebugDrawLiner { +public: + btMDebugDrawLiner(); + virtual ~btMDebugDrawLiner(); + + virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& color) = 0; +}; + + +class btMDebugDraw : public btIDebugDraw { +public: + btMDebugDraw(); + virtual ~btMDebugDraw(); + + // btIDebugDrawで定義済みのメソッド + virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& fromColor, const btVector3& toColor); + virtual void drawSphere(btScalar radius, const btTransform& transform, const btVector3& color); + virtual void drawSphere(const btVector3& p, btScalar radius, const btVector3& color); + virtual void drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& /*n0*/, const btVector3& /*n1*/, const btVector3& /*n2*/, const btVector3& color, btScalar alpha); + virtual void drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& color, btScalar /*alpha*/); + virtual void drawAabb(const btVector3& from, const btVector3& to, const btVector3& color); + virtual void drawTransform(const btTransform& transform, btScalar orthoLen); + virtual void drawArc(const btVector3& center, const btVector3& normal, const btVector3& axis, btScalar radiusA, btScalar radiusB, btScalar minAngle, btScalar maxAngle, + const btVector3& color, bool drawSect, btScalar stepDegrees = btScalar(10.f)); + virtual void drawSpherePatch(const btVector3& center, const btVector3& up, const btVector3& axis, btScalar radius, + btScalar minTh, btScalar maxTh, btScalar minPs, btScalar maxPs, const btVector3& color, btScalar stepDegrees = btScalar(10.f), bool drawCenter = true); + virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btVector3& color); + virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btTransform& trans, const btVector3& color); + virtual void drawCapsule(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color); + virtual void drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color); + virtual void drawCone(btScalar radius, btScalar height, int upAxis, const btTransform& transform, const btVector3& color); + virtual void drawPlane(const btVector3& planeNormal, btScalar planeConst, const btTransform& transform, const btVector3& color); + virtual void clearLines(); + virtual void flushLines(); + virtual btIDebugDraw::DefaultColors getDefaultColors() const override; + + // 独自メソッド + virtual void setMDefaultColors(const btMDefaultColors& colors); + virtual void setLiner(btMDebugDrawLiner* liner); + virtual btMDebugDrawLiner* getLiner(); + + // ヘッダーで定義済みのメソッド + void setDebugMode(int debugMode); + int getDebugMode() const; + + // 継承先で実装が必要なメソッド + virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& color); + virtual void drawContactPoint(const btVector3& PointOnB, const btVector3& normalOnB, btScalar distance, int lifeTime, const btVector3& color); + virtual void reportErrorWarning(const char* warningString); + virtual void draw3dText(const btVector3& location, const char* textString); + +private: + int m_debugMode; + btMDefaultColors m_defaultColors; + btMDebugDrawLiner* m_liner; +}; + + +#endif // BTMDEBUGDRAW_H diff --git a/pkg/mphysics/mbt/LinearMath/btMDebugDraw.h.i b/pkg/mphysics/mbt/LinearMath/btMDebugDraw.h.i new file mode 100644 index 00000000..05a42527 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMDebugDraw.h.i @@ -0,0 +1,20 @@ +////// LinearMath/btMDebugDraw.h ---------------- + +%module(directors="1") mbt +%feature("director") btMDebugDrawLiner; + +%include "LinearMath/btMDebugDraw.h" + +%{ +#include "LinearMath/btMDebugDraw.h" +%} + +// class directorBtMDebugDrawLiner : public btMDebugDrawLiner { +// public: +// virtual ~directorBtMDebugDrawLiner() {} +// virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& color) {} +// }; + +// void drawLine(directorBtMDebugDrawLiner *director, const btVector3& from, const btVector3& to, const btVector3& color) { +// director->drawLine(from, to, color); +// } \ No newline at end of file diff --git a/pkg/mphysics/mbt/LinearMath/btMatrix3x3.h b/pkg/mphysics/mbt/LinearMath/btMatrix3x3.h new file mode 100644 index 00000000..4391a52c --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMatrix3x3.h @@ -0,0 +1,1431 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_MATRIX3x3_H +#define BT_MATRIX3x3_H + +#include "btVector3.h" +#include "btQuaternion.h" +#include + +#ifdef BT_USE_SSE +//const __m128 ATTRIBUTE_ALIGNED16(v2220) = {2.0f, 2.0f, 2.0f, 0.0f}; +//const __m128 ATTRIBUTE_ALIGNED16(vMPPP) = {-0.0f, +0.0f, +0.0f, +0.0f}; +#define vMPPP (_mm_set_ps(+0.0f, +0.0f, +0.0f, -0.0f)) +#endif + +#if defined(BT_USE_SSE) +#define v0000 (_mm_set_ps(0.0f, 0.0f, 0.0f, 0.0f)) +#define v1000 (_mm_set_ps(0.0f, 0.0f, 0.0f, 1.0f)) +#define v0100 (_mm_set_ps(0.0f, 0.0f, 1.0f, 0.0f)) +#define v0010 (_mm_set_ps(0.0f, 1.0f, 0.0f, 0.0f)) +#elif defined(BT_USE_NEON) +const btSimdFloat4 ATTRIBUTE_ALIGNED16(v0000) = {0.0f, 0.0f, 0.0f, 0.0f}; +const btSimdFloat4 ATTRIBUTE_ALIGNED16(v1000) = {1.0f, 0.0f, 0.0f, 0.0f}; +const btSimdFloat4 ATTRIBUTE_ALIGNED16(v0100) = {0.0f, 1.0f, 0.0f, 0.0f}; +const btSimdFloat4 ATTRIBUTE_ALIGNED16(v0010) = {0.0f, 0.0f, 1.0f, 0.0f}; +#endif + +#ifdef BT_USE_DOUBLE_PRECISION +#define btMatrix3x3Data btMatrix3x3DoubleData +#else +#define btMatrix3x3Data btMatrix3x3FloatData +#endif //BT_USE_DOUBLE_PRECISION + +/**@brief The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with btQuaternion, btTransform and btVector3. +* Make sure to only include a pure orthogonal matrix without scaling. */ +ATTRIBUTE_ALIGNED16(class) +btMatrix3x3 +{ + ///Data storage for the matrix, each vector is a row of the matrix + btVector3 m_el[3]; + +public: + /** @brief No initializaion constructor */ + btMatrix3x3() {} + + // explicit btMatrix3x3(const btScalar *m) { setFromOpenGLSubMatrix(m); } + + /**@brief Constructor from Quaternion */ + explicit btMatrix3x3(const btQuaternion& q) { setRotation(q); } + /* + template + Matrix3x3(const btScalar& yaw, const btScalar& pitch, const btScalar& roll) + { + setEulerYPR(yaw, pitch, roll); + } + */ + /** @brief Constructor with row major formatting */ + btMatrix3x3(const btScalar& xx, const btScalar& xy, const btScalar& xz, + const btScalar& yx, const btScalar& yy, const btScalar& yz, + const btScalar& zx, const btScalar& zy, const btScalar& zz) + { + setValue(xx, xy, xz, + yx, yy, yz, + zx, zy, zz); + } + +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + SIMD_FORCE_INLINE btMatrix3x3(const btSimdFloat4 v0, const btSimdFloat4 v1, const btSimdFloat4 v2) + { + m_el[0].mVec128 = v0; + m_el[1].mVec128 = v1; + m_el[2].mVec128 = v2; + } + + SIMD_FORCE_INLINE btMatrix3x3(const btVector3& v0, const btVector3& v1, const btVector3& v2) + { + m_el[0] = v0; + m_el[1] = v1; + m_el[2] = v2; + } + + // Copy constructor + SIMD_FORCE_INLINE btMatrix3x3(const btMatrix3x3& rhs) + { + m_el[0].mVec128 = rhs.m_el[0].mVec128; + m_el[1].mVec128 = rhs.m_el[1].mVec128; + m_el[2].mVec128 = rhs.m_el[2].mVec128; + } + + // Assignment Operator + SIMD_FORCE_INLINE btMatrix3x3& operator=(const btMatrix3x3& m) + { + m_el[0].mVec128 = m.m_el[0].mVec128; + m_el[1].mVec128 = m.m_el[1].mVec128; + m_el[2].mVec128 = m.m_el[2].mVec128; + + return *this; + } + +#else + + /** @brief Copy constructor */ + SIMD_FORCE_INLINE btMatrix3x3(const btMatrix3x3& other) + { + m_el[0] = other.m_el[0]; + m_el[1] = other.m_el[1]; + m_el[2] = other.m_el[2]; + } + + /** @brief Assignment Operator */ + SIMD_FORCE_INLINE btMatrix3x3& operator=(const btMatrix3x3& other) + { + m_el[0] = other.m_el[0]; + m_el[1] = other.m_el[1]; + m_el[2] = other.m_el[2]; + return *this; + } + + SIMD_FORCE_INLINE btMatrix3x3(const btVector3& v0, const btVector3& v1, const btVector3& v2) + { + m_el[0] = v0; + m_el[1] = v1; + m_el[2] = v2; + } + +#endif + + /** @brief Get a column of the matrix as a vector + * @param i Column number 0 indexed */ + SIMD_FORCE_INLINE btVector3 getColumn(int i) const + { + return btVector3(m_el[0][i], m_el[1][i], m_el[2][i]); + } + + /** @brief Get a row of the matrix as a vector + * @param i Row number 0 indexed */ + SIMD_FORCE_INLINE const btVector3& getRow(int i) const + { + btFullAssert(0 <= i && i < 3); + return m_el[i]; + } + + /** @brief Get a mutable reference to a row of the matrix as a vector + * @param i Row number 0 indexed */ + SIMD_FORCE_INLINE btVector3& operator[](int i) + { + btFullAssert(0 <= i && i < 3); + return m_el[i]; + } + + /** @brief Get a const reference to a row of the matrix as a vector + * @param i Row number 0 indexed */ + SIMD_FORCE_INLINE const btVector3& operator[](int i) const + { + btFullAssert(0 <= i && i < 3); + return m_el[i]; + } + + /** @brief Multiply by the target matrix on the right + * @param m Rotation matrix to be applied + * Equivilant to this = this * m */ + btMatrix3x3& operator*=(const btMatrix3x3& m); + + /** @brief Adds by the target matrix on the right + * @param m matrix to be applied + * Equivilant to this = this + m */ + btMatrix3x3& operator+=(const btMatrix3x3& m); + + /** @brief Substractss by the target matrix on the right + * @param m matrix to be applied + * Equivilant to this = this - m */ + btMatrix3x3& operator-=(const btMatrix3x3& m); + + /** @brief Set from the rotational part of a 4x4 OpenGL matrix + * @param m A pointer to the beginning of the array of scalars*/ + void setFromOpenGLSubMatrix(const btScalar* m) + { + m_el[0].setValue(m[0], m[4], m[8]); + m_el[1].setValue(m[1], m[5], m[9]); + m_el[2].setValue(m[2], m[6], m[10]); + } + /** @brief Set the values of the matrix explicitly (row major) + * @param xx Top left + * @param xy Top Middle + * @param xz Top Right + * @param yx Middle Left + * @param yy Middle Middle + * @param yz Middle Right + * @param zx Bottom Left + * @param zy Bottom Middle + * @param zz Bottom Right*/ + void setValue(const btScalar& xx, const btScalar& xy, const btScalar& xz, + const btScalar& yx, const btScalar& yy, const btScalar& yz, + const btScalar& zx, const btScalar& zy, const btScalar& zz) + { + m_el[0].setValue(xx, xy, xz); + m_el[1].setValue(yx, yy, yz); + m_el[2].setValue(zx, zy, zz); + } + + /** @brief Set the matrix from a quaternion + * @param q The Quaternion to match */ + void setRotation(const btQuaternion& q) + { + btScalar d = q.length2(); + btFullAssert(d != btScalar(0.0)); + btScalar s = btScalar(2.0) / d; + +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vs, Q = q.get128(); + __m128i Qi = btCastfTo128i(Q); + __m128 Y, Z; + __m128 V1, V2, V3; + __m128 V11, V21, V31; + __m128 NQ = _mm_xor_ps(Q, btvMzeroMask); + __m128i NQi = btCastfTo128i(NQ); + + V1 = btCastiTo128f(_mm_shuffle_epi32(Qi, BT_SHUFFLE(1, 0, 2, 3))); // Y X Z W + V2 = _mm_shuffle_ps(NQ, Q, BT_SHUFFLE(0, 0, 1, 3)); // -X -X Y W + V3 = btCastiTo128f(_mm_shuffle_epi32(Qi, BT_SHUFFLE(2, 1, 0, 3))); // Z Y X W + V1 = _mm_xor_ps(V1, vMPPP); // change the sign of the first element + + V11 = btCastiTo128f(_mm_shuffle_epi32(Qi, BT_SHUFFLE(1, 1, 0, 3))); // Y Y X W + V21 = _mm_unpackhi_ps(Q, Q); // Z Z W W + V31 = _mm_shuffle_ps(Q, NQ, BT_SHUFFLE(0, 2, 0, 3)); // X Z -X -W + + V2 = V2 * V1; // + V1 = V1 * V11; // + V3 = V3 * V31; // + + V11 = _mm_shuffle_ps(NQ, Q, BT_SHUFFLE(2, 3, 1, 3)); // -Z -W Y W + V11 = V11 * V21; // + V21 = _mm_xor_ps(V21, vMPPP); // change the sign of the first element + V31 = _mm_shuffle_ps(Q, NQ, BT_SHUFFLE(3, 3, 1, 3)); // W W -Y -W + V31 = _mm_xor_ps(V31, vMPPP); // change the sign of the first element + Y = btCastiTo128f(_mm_shuffle_epi32(NQi, BT_SHUFFLE(3, 2, 0, 3))); // -W -Z -X -W + Z = btCastiTo128f(_mm_shuffle_epi32(Qi, BT_SHUFFLE(1, 0, 1, 3))); // Y X Y W + + vs = _mm_load_ss(&s); + V21 = V21 * Y; + V31 = V31 * Z; + + V1 = V1 + V11; + V2 = V2 + V21; + V3 = V3 + V31; + + vs = bt_splat3_ps(vs, 0); + // s ready + V1 = V1 * vs; + V2 = V2 * vs; + V3 = V3 * vs; + + V1 = V1 + v1000; + V2 = V2 + v0100; + V3 = V3 + v0010; + + m_el[0] = V1; + m_el[1] = V2; + m_el[2] = V3; +#else + btScalar xs = q.x() * s, ys = q.y() * s, zs = q.z() * s; + btScalar wx = q.w() * xs, wy = q.w() * ys, wz = q.w() * zs; + btScalar xx = q.x() * xs, xy = q.x() * ys, xz = q.x() * zs; + btScalar yy = q.y() * ys, yz = q.y() * zs, zz = q.z() * zs; + setValue( + btScalar(1.0) - (yy + zz), xy - wz, xz + wy, + xy + wz, btScalar(1.0) - (xx + zz), yz - wx, + xz - wy, yz + wx, btScalar(1.0) - (xx + yy)); +#endif + } + + /** @brief Set the matrix from euler angles using YPR around YXZ respectively + * @param yaw Yaw about Y axis + * @param pitch Pitch about X axis + * @param roll Roll about Z axis + */ + void setEulerYPR(const btScalar& yaw, const btScalar& pitch, const btScalar& roll) + { + setEulerZYX(roll, pitch, yaw); + } + + /** @brief Set the matrix from euler angles YPR around ZYX axes + * @param eulerX Roll about X axis + * @param eulerY Pitch around Y axis + * @param eulerZ Yaw about Z axis + * + * These angles are used to produce a rotation matrix. The euler + * angles are applied in ZYX order. I.e a vector is first rotated + * about X then Y and then Z + **/ + void setEulerZYX(btScalar eulerX, btScalar eulerY, btScalar eulerZ) + { + ///@todo proposed to reverse this since it's labeled zyx but takes arguments xyz and it will match all other parts of the code + btScalar ci(btCos(eulerX)); + btScalar cj(btCos(eulerY)); + btScalar ch(btCos(eulerZ)); + btScalar si(btSin(eulerX)); + btScalar sj(btSin(eulerY)); + btScalar sh(btSin(eulerZ)); + btScalar cc = ci * ch; + btScalar cs = ci * sh; + btScalar sc = si * ch; + btScalar ss = si * sh; + + setValue(cj * ch, sj * sc - cs, sj * cc + ss, + cj * sh, sj * ss + cc, sj * cs - sc, + -sj, cj * si, cj * ci); + } + + /**@brief Set the matrix to the identity */ + void setIdentity() + { +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + m_el[0] = v1000; + m_el[1] = v0100; + m_el[2] = v0010; +#else + setValue(btScalar(1.0), btScalar(0.0), btScalar(0.0), + btScalar(0.0), btScalar(1.0), btScalar(0.0), + btScalar(0.0), btScalar(0.0), btScalar(1.0)); +#endif + } + + /**@brief Set the matrix to the identity */ + void setZero() + { +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + m_el[0] = v0000; + m_el[1] = v0000; + m_el[2] = v0000; +#else + setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0), + btScalar(0.0), btScalar(0.0), btScalar(0.0), + btScalar(0.0), btScalar(0.0), btScalar(0.0)); +#endif + } + + static const btMatrix3x3& getIdentity() + { +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + static const btMatrix3x3 + identityMatrix(v1000, v0100, v0010); +#else + static const btMatrix3x3 + identityMatrix( + btScalar(1.0), btScalar(0.0), btScalar(0.0), + btScalar(0.0), btScalar(1.0), btScalar(0.0), + btScalar(0.0), btScalar(0.0), btScalar(1.0)); +#endif + return identityMatrix; + } + + /**@brief Fill the rotational part of an OpenGL matrix and clear the shear/perspective + * @param m The array to be filled */ + void getOpenGLSubMatrix(btScalar * m) const + { +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 v0 = m_el[0].mVec128; + __m128 v1 = m_el[1].mVec128; + __m128 v2 = m_el[2].mVec128; // x2 y2 z2 w2 + __m128* vm = (__m128*)m; + __m128 vT; + + v2 = _mm_and_ps(v2, btvFFF0fMask); // x2 y2 z2 0 + + vT = _mm_unpackhi_ps(v0, v1); // z0 z1 * * + v0 = _mm_unpacklo_ps(v0, v1); // x0 x1 y0 y1 + + v1 = _mm_shuffle_ps(v0, v2, BT_SHUFFLE(2, 3, 1, 3)); // y0 y1 y2 0 + v0 = _mm_shuffle_ps(v0, v2, BT_SHUFFLE(0, 1, 0, 3)); // x0 x1 x2 0 + v2 = btCastdTo128f(_mm_move_sd(btCastfTo128d(v2), btCastfTo128d(vT))); // z0 z1 z2 0 + + vm[0] = v0; + vm[1] = v1; + vm[2] = v2; +#elif defined(BT_USE_NEON) + // note: zeros the w channel. We can preserve it at the cost of two more vtrn instructions. + static const uint32x2_t zMask = (const uint32x2_t){static_cast(-1), 0}; + float32x4_t* vm = (float32x4_t*)m; + float32x4x2_t top = vtrnq_f32(m_el[0].mVec128, m_el[1].mVec128); // {x0 x1 z0 z1}, {y0 y1 w0 w1} + float32x2x2_t bl = vtrn_f32(vget_low_f32(m_el[2].mVec128), vdup_n_f32(0.0f)); // {x2 0 }, {y2 0} + float32x4_t v0 = vcombine_f32(vget_low_f32(top.val[0]), bl.val[0]); + float32x4_t v1 = vcombine_f32(vget_low_f32(top.val[1]), bl.val[1]); + float32x2_t q = (float32x2_t)vand_u32((uint32x2_t)vget_high_f32(m_el[2].mVec128), zMask); + float32x4_t v2 = vcombine_f32(vget_high_f32(top.val[0]), q); // z0 z1 z2 0 + + vm[0] = v0; + vm[1] = v1; + vm[2] = v2; +#else + m[0] = btScalar(m_el[0].x()); + m[1] = btScalar(m_el[1].x()); + m[2] = btScalar(m_el[2].x()); + m[3] = btScalar(0.0); + m[4] = btScalar(m_el[0].y()); + m[5] = btScalar(m_el[1].y()); + m[6] = btScalar(m_el[2].y()); + m[7] = btScalar(0.0); + m[8] = btScalar(m_el[0].z()); + m[9] = btScalar(m_el[1].z()); + m[10] = btScalar(m_el[2].z()); + m[11] = btScalar(0.0); +#endif + } + + /**@brief Get the matrix represented as a quaternion + * @param q The quaternion which will be set */ + void getRotation(btQuaternion & q) const + { +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + btScalar trace = m_el[0].x() + m_el[1].y() + m_el[2].z(); + btScalar s, x; + + union { + btSimdFloat4 vec; + btScalar f[4]; + } temp; + + if (trace > btScalar(0.0)) + { + x = trace + btScalar(1.0); + + temp.f[0] = m_el[2].y() - m_el[1].z(); + temp.f[1] = m_el[0].z() - m_el[2].x(); + temp.f[2] = m_el[1].x() - m_el[0].y(); + temp.f[3] = x; + //temp.f[3]= s * btScalar(0.5); + } + else + { + int i, j, k; + if (m_el[0].x() < m_el[1].y()) + { + if (m_el[1].y() < m_el[2].z()) + { + i = 2; + j = 0; + k = 1; + } + else + { + i = 1; + j = 2; + k = 0; + } + } + else + { + if (m_el[0].x() < m_el[2].z()) + { + i = 2; + j = 0; + k = 1; + } + else + { + i = 0; + j = 1; + k = 2; + } + } + + x = m_el[i][i] - m_el[j][j] - m_el[k][k] + btScalar(1.0); + + temp.f[3] = (m_el[k][j] - m_el[j][k]); + temp.f[j] = (m_el[j][i] + m_el[i][j]); + temp.f[k] = (m_el[k][i] + m_el[i][k]); + temp.f[i] = x; + //temp.f[i] = s * btScalar(0.5); + } + + s = btSqrt(x); + q.set128(temp.vec); + s = btScalar(0.5) / s; + + q *= s; +#else + btScalar trace = m_el[0].x() + m_el[1].y() + m_el[2].z(); + + btScalar temp[4]; + + if (trace > btScalar(0.0)) + { + btScalar s = btSqrt(trace + btScalar(1.0)); + temp[3] = (s * btScalar(0.5)); + s = btScalar(0.5) / s; + + temp[0] = ((m_el[2].y() - m_el[1].z()) * s); + temp[1] = ((m_el[0].z() - m_el[2].x()) * s); + temp[2] = ((m_el[1].x() - m_el[0].y()) * s); + } + else + { + int i = m_el[0].x() < m_el[1].y() ? (m_el[1].y() < m_el[2].z() ? 2 : 1) : (m_el[0].x() < m_el[2].z() ? 2 : 0); + int j = (i + 1) % 3; + int k = (i + 2) % 3; + + btScalar s = btSqrt(m_el[i][i] - m_el[j][j] - m_el[k][k] + btScalar(1.0)); + temp[i] = s * btScalar(0.5); + s = btScalar(0.5) / s; + + temp[3] = (m_el[k][j] - m_el[j][k]) * s; + temp[j] = (m_el[j][i] + m_el[i][j]) * s; + temp[k] = (m_el[k][i] + m_el[i][k]) * s; + } + q.setValue(temp[0], temp[1], temp[2], temp[3]); +#endif + } + + /**@brief Get the matrix represented as euler angles around YXZ, roundtrip with setEulerYPR + * @param yaw Yaw around Y axis + * @param pitch Pitch around X axis + * @param roll around Z axis */ + void getEulerYPR(btScalar & yaw, btScalar & pitch, btScalar & roll) const + { + // first use the normal calculus + yaw = btScalar(btAtan2(m_el[1].x(), m_el[0].x())); + pitch = btScalar(btAsin(-m_el[2].x())); + roll = btScalar(btAtan2(m_el[2].y(), m_el[2].z())); + + // on pitch = +/-HalfPI + if (btFabs(pitch) == SIMD_HALF_PI) + { + if (yaw > 0) + yaw -= SIMD_PI; + else + yaw += SIMD_PI; + + if (roll > 0) + roll -= SIMD_PI; + else + roll += SIMD_PI; + } + }; + + /**@brief Get the matrix represented as euler angles around ZYX + * @param yaw Yaw around Z axis + * @param pitch Pitch around Y axis + * @param roll around X axis + * @param solution_number Which solution of two possible solutions ( 1 or 2) are possible values*/ + void getEulerZYX(btScalar & yaw, btScalar & pitch, btScalar & roll, unsigned int solution_number = 1) const + { + struct Euler + { + btScalar yaw; + btScalar pitch; + btScalar roll; + }; + + Euler euler_out; + Euler euler_out2; //second solution + //get the pointer to the raw data + + // Check that pitch is not at a singularity + if (btFabs(m_el[2].x()) >= 1) + { + euler_out.yaw = 0; + euler_out2.yaw = 0; + + // From difference of angles formula + btScalar delta = btAtan2(m_el[0].x(), m_el[0].z()); + if (m_el[2].x() > 0) //gimbal locked up + { + euler_out.pitch = SIMD_PI / btScalar(2.0); + euler_out2.pitch = SIMD_PI / btScalar(2.0); + euler_out.roll = euler_out.pitch + delta; + euler_out2.roll = euler_out.pitch + delta; + } + else // gimbal locked down + { + euler_out.pitch = -SIMD_PI / btScalar(2.0); + euler_out2.pitch = -SIMD_PI / btScalar(2.0); + euler_out.roll = -euler_out.pitch + delta; + euler_out2.roll = -euler_out.pitch + delta; + } + } + else + { + euler_out.pitch = -btAsin(m_el[2].x()); + euler_out2.pitch = SIMD_PI - euler_out.pitch; + + euler_out.roll = btAtan2(m_el[2].y() / btCos(euler_out.pitch), + m_el[2].z() / btCos(euler_out.pitch)); + euler_out2.roll = btAtan2(m_el[2].y() / btCos(euler_out2.pitch), + m_el[2].z() / btCos(euler_out2.pitch)); + + euler_out.yaw = btAtan2(m_el[1].x() / btCos(euler_out.pitch), + m_el[0].x() / btCos(euler_out.pitch)); + euler_out2.yaw = btAtan2(m_el[1].x() / btCos(euler_out2.pitch), + m_el[0].x() / btCos(euler_out2.pitch)); + } + + if (solution_number == 1) + { + yaw = euler_out.yaw; + pitch = euler_out.pitch; + roll = euler_out.roll; + } + else + { + yaw = euler_out2.yaw; + pitch = euler_out2.pitch; + roll = euler_out2.roll; + } + } + + /**@brief Create a scaled copy of the matrix + * @param s Scaling vector The elements of the vector will scale each column */ + + btMatrix3x3 scaled(const btVector3& s) const + { +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + return btMatrix3x3(m_el[0] * s, m_el[1] * s, m_el[2] * s); +#else + return btMatrix3x3( + m_el[0].x() * s.x(), m_el[0].y() * s.y(), m_el[0].z() * s.z(), + m_el[1].x() * s.x(), m_el[1].y() * s.y(), m_el[1].z() * s.z(), + m_el[2].x() * s.x(), m_el[2].y() * s.y(), m_el[2].z() * s.z()); +#endif + } + + /**@brief Return the determinant of the matrix */ + btScalar determinant() const; + /**@brief Return the adjoint of the matrix */ + btMatrix3x3 adjoint() const; + /**@brief Return the matrix with all values non negative */ + btMatrix3x3 absolute() const; + /**@brief Return the transpose of the matrix */ + btMatrix3x3 transpose() const; + /**@brief Return the inverse of the matrix */ + btMatrix3x3 inverse() const; + + /// Solve A * x = b, where b is a column vector. This is more efficient + /// than computing the inverse in one-shot cases. + ///Solve33 is from Box2d, thanks to Erin Catto, + btVector3 solve33(const btVector3& b) const + { + btVector3 col1 = getColumn(0); + btVector3 col2 = getColumn(1); + btVector3 col3 = getColumn(2); + + btScalar det = btDot(col1, btCross(col2, col3)); + if (btFabs(det) > SIMD_EPSILON) + { + det = 1.0f / det; + } + btVector3 x; + x[0] = det * btDot(b, btCross(col2, col3)); + x[1] = det * btDot(col1, btCross(b, col3)); + x[2] = det * btDot(col1, btCross(col2, b)); + return x; + } + + btMatrix3x3 transposeTimes(const btMatrix3x3& m) const; + btMatrix3x3 timesTranspose(const btMatrix3x3& m) const; + + SIMD_FORCE_INLINE btScalar tdotx(const btVector3& v) const + { + return m_el[0].x() * v.x() + m_el[1].x() * v.y() + m_el[2].x() * v.z(); + } + SIMD_FORCE_INLINE btScalar tdoty(const btVector3& v) const + { + return m_el[0].y() * v.x() + m_el[1].y() * v.y() + m_el[2].y() * v.z(); + } + SIMD_FORCE_INLINE btScalar tdotz(const btVector3& v) const + { + return m_el[0].z() * v.x() + m_el[1].z() * v.y() + m_el[2].z() * v.z(); + } + + ///extractRotation is from "A robust method to extract the rotational part of deformations" + ///See http://dl.acm.org/citation.cfm?doid=2994258.2994269 + ///decomposes a matrix A in a orthogonal matrix R and a + ///symmetric matrix S: + ///A = R*S. + ///note that R can include both rotation and scaling. + SIMD_FORCE_INLINE void extractRotation(btQuaternion & q, btScalar tolerance = 1.0e-9, int maxIter = 100) + { + int iter = 0; + btScalar w; + const btMatrix3x3& A = *this; + for (iter = 0; iter < maxIter; iter++) + { + btMatrix3x3 R(q); + btVector3 omega = (R.getColumn(0).cross(A.getColumn(0)) + R.getColumn(1).cross(A.getColumn(1)) + R.getColumn(2).cross(A.getColumn(2))) * (btScalar(1.0) / btFabs(R.getColumn(0).dot(A.getColumn(0)) + R.getColumn(1).dot(A.getColumn(1)) + R.getColumn(2).dot(A.getColumn(2))) + + tolerance); + w = omega.norm(); + if (w < tolerance) + break; + q = btQuaternion(btVector3((btScalar(1.0) / w) * omega), w) * + q; + q.normalize(); + } + } + + /**@brief diagonalizes this matrix by the Jacobi method. + * @param rot stores the rotation from the coordinate system in which the matrix is diagonal to the original + * coordinate system, i.e., old_this = rot * new_this * rot^T. + * @param threshold See iteration + * @param iteration The iteration stops when all off-diagonal elements are less than the threshold multiplied + * by the sum of the absolute values of the diagonal, or when maxSteps have been executed. + * + * Note that this matrix is assumed to be symmetric. + */ + void diagonalize(btMatrix3x3 & rot, btScalar threshold, int maxSteps) + { + rot.setIdentity(); + for (int step = maxSteps; step > 0; step--) + { + // find off-diagonal element [p][q] with largest magnitude + int p = 0; + int q = 1; + int r = 2; + btScalar max = btFabs(m_el[0][1]); + btScalar v = btFabs(m_el[0][2]); + if (v > max) + { + q = 2; + r = 1; + max = v; + } + v = btFabs(m_el[1][2]); + if (v > max) + { + p = 1; + q = 2; + r = 0; + max = v; + } + + btScalar t = threshold * (btFabs(m_el[0][0]) + btFabs(m_el[1][1]) + btFabs(m_el[2][2])); + if (max <= t) + { + if (max <= SIMD_EPSILON * t) + { + return; + } + step = 1; + } + + // compute Jacobi rotation J which leads to a zero for element [p][q] + btScalar mpq = m_el[p][q]; + btScalar theta = (m_el[q][q] - m_el[p][p]) / (2 * mpq); + btScalar theta2 = theta * theta; + btScalar cos; + btScalar sin; + if (theta2 * theta2 < btScalar(10 / SIMD_EPSILON)) + { + t = (theta >= 0) ? 1 / (theta + btSqrt(1 + theta2)) + : 1 / (theta - btSqrt(1 + theta2)); + cos = 1 / btSqrt(1 + t * t); + sin = cos * t; + } + else + { + // approximation for large theta-value, i.e., a nearly diagonal matrix + t = 1 / (theta * (2 + btScalar(0.5) / theta2)); + cos = 1 - btScalar(0.5) * t * t; + sin = cos * t; + } + + // apply rotation to matrix (this = J^T * this * J) + m_el[p][q] = m_el[q][p] = 0; + m_el[p][p] -= t * mpq; + m_el[q][q] += t * mpq; + btScalar mrp = m_el[r][p]; + btScalar mrq = m_el[r][q]; + m_el[r][p] = m_el[p][r] = cos * mrp - sin * mrq; + m_el[r][q] = m_el[q][r] = cos * mrq + sin * mrp; + + // apply rotation to rot (rot = rot * J) + for (int i = 0; i < 3; i++) + { + btVector3& row = rot[i]; + mrp = row[p]; + mrq = row[q]; + row[p] = cos * mrp - sin * mrq; + row[q] = cos * mrq + sin * mrp; + } + } + } + + /**@brief Calculate the matrix cofactor + * @param r1 The first row to use for calculating the cofactor + * @param c1 The first column to use for calculating the cofactor + * @param r1 The second row to use for calculating the cofactor + * @param c1 The second column to use for calculating the cofactor + * See http://en.wikipedia.org/wiki/Cofactor_(linear_algebra) for more details + */ + btScalar cofac(int r1, int c1, int r2, int c2) const + { + return m_el[r1][c1] * m_el[r2][c2] - m_el[r1][c2] * m_el[r2][c1]; + } + + void serialize(struct btMatrix3x3Data & dataOut) const; + + void serializeFloat(struct btMatrix3x3FloatData & dataOut) const; + + void deSerialize(const struct btMatrix3x3Data& dataIn); + + void deSerializeFloat(const struct btMatrix3x3FloatData& dataIn); + + void deSerializeDouble(const struct btMatrix3x3DoubleData& dataIn); +}; + +SIMD_FORCE_INLINE btMatrix3x3& +btMatrix3x3::operator*=(const btMatrix3x3& m) +{ +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 rv00, rv01, rv02; + __m128 rv10, rv11, rv12; + __m128 rv20, rv21, rv22; + __m128 mv0, mv1, mv2; + + rv02 = m_el[0].mVec128; + rv12 = m_el[1].mVec128; + rv22 = m_el[2].mVec128; + + mv0 = _mm_and_ps(m[0].mVec128, btvFFF0fMask); + mv1 = _mm_and_ps(m[1].mVec128, btvFFF0fMask); + mv2 = _mm_and_ps(m[2].mVec128, btvFFF0fMask); + + // rv0 + rv00 = bt_splat_ps(rv02, 0); + rv01 = bt_splat_ps(rv02, 1); + rv02 = bt_splat_ps(rv02, 2); + + rv00 = _mm_mul_ps(rv00, mv0); + rv01 = _mm_mul_ps(rv01, mv1); + rv02 = _mm_mul_ps(rv02, mv2); + + // rv1 + rv10 = bt_splat_ps(rv12, 0); + rv11 = bt_splat_ps(rv12, 1); + rv12 = bt_splat_ps(rv12, 2); + + rv10 = _mm_mul_ps(rv10, mv0); + rv11 = _mm_mul_ps(rv11, mv1); + rv12 = _mm_mul_ps(rv12, mv2); + + // rv2 + rv20 = bt_splat_ps(rv22, 0); + rv21 = bt_splat_ps(rv22, 1); + rv22 = bt_splat_ps(rv22, 2); + + rv20 = _mm_mul_ps(rv20, mv0); + rv21 = _mm_mul_ps(rv21, mv1); + rv22 = _mm_mul_ps(rv22, mv2); + + rv00 = _mm_add_ps(rv00, rv01); + rv10 = _mm_add_ps(rv10, rv11); + rv20 = _mm_add_ps(rv20, rv21); + + m_el[0].mVec128 = _mm_add_ps(rv00, rv02); + m_el[1].mVec128 = _mm_add_ps(rv10, rv12); + m_el[2].mVec128 = _mm_add_ps(rv20, rv22); + +#elif defined(BT_USE_NEON) + + float32x4_t rv0, rv1, rv2; + float32x4_t v0, v1, v2; + float32x4_t mv0, mv1, mv2; + + v0 = m_el[0].mVec128; + v1 = m_el[1].mVec128; + v2 = m_el[2].mVec128; + + mv0 = (float32x4_t)vandq_s32((int32x4_t)m[0].mVec128, btvFFF0Mask); + mv1 = (float32x4_t)vandq_s32((int32x4_t)m[1].mVec128, btvFFF0Mask); + mv2 = (float32x4_t)vandq_s32((int32x4_t)m[2].mVec128, btvFFF0Mask); + + rv0 = vmulq_lane_f32(mv0, vget_low_f32(v0), 0); + rv1 = vmulq_lane_f32(mv0, vget_low_f32(v1), 0); + rv2 = vmulq_lane_f32(mv0, vget_low_f32(v2), 0); + + rv0 = vmlaq_lane_f32(rv0, mv1, vget_low_f32(v0), 1); + rv1 = vmlaq_lane_f32(rv1, mv1, vget_low_f32(v1), 1); + rv2 = vmlaq_lane_f32(rv2, mv1, vget_low_f32(v2), 1); + + rv0 = vmlaq_lane_f32(rv0, mv2, vget_high_f32(v0), 0); + rv1 = vmlaq_lane_f32(rv1, mv2, vget_high_f32(v1), 0); + rv2 = vmlaq_lane_f32(rv2, mv2, vget_high_f32(v2), 0); + + m_el[0].mVec128 = rv0; + m_el[1].mVec128 = rv1; + m_el[2].mVec128 = rv2; +#else + setValue( + m.tdotx(m_el[0]), m.tdoty(m_el[0]), m.tdotz(m_el[0]), + m.tdotx(m_el[1]), m.tdoty(m_el[1]), m.tdotz(m_el[1]), + m.tdotx(m_el[2]), m.tdoty(m_el[2]), m.tdotz(m_el[2])); +#endif + return *this; +} + +SIMD_FORCE_INLINE btMatrix3x3& +btMatrix3x3::operator+=(const btMatrix3x3& m) +{ +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + m_el[0].mVec128 = m_el[0].mVec128 + m.m_el[0].mVec128; + m_el[1].mVec128 = m_el[1].mVec128 + m.m_el[1].mVec128; + m_el[2].mVec128 = m_el[2].mVec128 + m.m_el[2].mVec128; +#else + setValue( + m_el[0][0] + m.m_el[0][0], + m_el[0][1] + m.m_el[0][1], + m_el[0][2] + m.m_el[0][2], + m_el[1][0] + m.m_el[1][0], + m_el[1][1] + m.m_el[1][1], + m_el[1][2] + m.m_el[1][2], + m_el[2][0] + m.m_el[2][0], + m_el[2][1] + m.m_el[2][1], + m_el[2][2] + m.m_el[2][2]); +#endif + return *this; +} + +SIMD_FORCE_INLINE btMatrix3x3 +operator*(const btMatrix3x3& m, const btScalar& k) +{ +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + __m128 vk = bt_splat_ps(_mm_load_ss((float*)&k), 0x80); + return btMatrix3x3( + _mm_mul_ps(m[0].mVec128, vk), + _mm_mul_ps(m[1].mVec128, vk), + _mm_mul_ps(m[2].mVec128, vk)); +#elif defined(BT_USE_NEON) + return btMatrix3x3( + vmulq_n_f32(m[0].mVec128, k), + vmulq_n_f32(m[1].mVec128, k), + vmulq_n_f32(m[2].mVec128, k)); +#else + return btMatrix3x3( + m[0].x() * k, m[0].y() * k, m[0].z() * k, + m[1].x() * k, m[1].y() * k, m[1].z() * k, + m[2].x() * k, m[2].y() * k, m[2].z() * k); +#endif +} + +SIMD_FORCE_INLINE btMatrix3x3 +operator+(const btMatrix3x3& m1, const btMatrix3x3& m2) +{ +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + return btMatrix3x3( + m1[0].mVec128 + m2[0].mVec128, + m1[1].mVec128 + m2[1].mVec128, + m1[2].mVec128 + m2[2].mVec128); +#else + return btMatrix3x3( + m1[0][0] + m2[0][0], + m1[0][1] + m2[0][1], + m1[0][2] + m2[0][2], + + m1[1][0] + m2[1][0], + m1[1][1] + m2[1][1], + m1[1][2] + m2[1][2], + + m1[2][0] + m2[2][0], + m1[2][1] + m2[2][1], + m1[2][2] + m2[2][2]); +#endif +} + +SIMD_FORCE_INLINE btMatrix3x3 +operator-(const btMatrix3x3& m1, const btMatrix3x3& m2) +{ +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + return btMatrix3x3( + m1[0].mVec128 - m2[0].mVec128, + m1[1].mVec128 - m2[1].mVec128, + m1[2].mVec128 - m2[2].mVec128); +#else + return btMatrix3x3( + m1[0][0] - m2[0][0], + m1[0][1] - m2[0][1], + m1[0][2] - m2[0][2], + + m1[1][0] - m2[1][0], + m1[1][1] - m2[1][1], + m1[1][2] - m2[1][2], + + m1[2][0] - m2[2][0], + m1[2][1] - m2[2][1], + m1[2][2] - m2[2][2]); +#endif +} + +SIMD_FORCE_INLINE btMatrix3x3& +btMatrix3x3::operator-=(const btMatrix3x3& m) +{ +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + m_el[0].mVec128 = m_el[0].mVec128 - m.m_el[0].mVec128; + m_el[1].mVec128 = m_el[1].mVec128 - m.m_el[1].mVec128; + m_el[2].mVec128 = m_el[2].mVec128 - m.m_el[2].mVec128; +#else + setValue( + m_el[0][0] - m.m_el[0][0], + m_el[0][1] - m.m_el[0][1], + m_el[0][2] - m.m_el[0][2], + m_el[1][0] - m.m_el[1][0], + m_el[1][1] - m.m_el[1][1], + m_el[1][2] - m.m_el[1][2], + m_el[2][0] - m.m_el[2][0], + m_el[2][1] - m.m_el[2][1], + m_el[2][2] - m.m_el[2][2]); +#endif + return *this; +} + +SIMD_FORCE_INLINE btScalar +btMatrix3x3::determinant() const +{ + return btTriple((*this)[0], (*this)[1], (*this)[2]); +} + +SIMD_FORCE_INLINE btMatrix3x3 +btMatrix3x3::absolute() const +{ +#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + return btMatrix3x3( + _mm_and_ps(m_el[0].mVec128, btvAbsfMask), + _mm_and_ps(m_el[1].mVec128, btvAbsfMask), + _mm_and_ps(m_el[2].mVec128, btvAbsfMask)); +#elif defined(BT_USE_NEON) + return btMatrix3x3( + (float32x4_t)vandq_s32((int32x4_t)m_el[0].mVec128, btv3AbsMask), + (float32x4_t)vandq_s32((int32x4_t)m_el[1].mVec128, btv3AbsMask), + (float32x4_t)vandq_s32((int32x4_t)m_el[2].mVec128, btv3AbsMask)); +#else + return btMatrix3x3( + btFabs(m_el[0].x()), btFabs(m_el[0].y()), btFabs(m_el[0].z()), + btFabs(m_el[1].x()), btFabs(m_el[1].y()), btFabs(m_el[1].z()), + btFabs(m_el[2].x()), btFabs(m_el[2].y()), btFabs(m_el[2].z())); +#endif +} + +SIMD_FORCE_INLINE btMatrix3x3 +btMatrix3x3::transpose() const +{ +#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + __m128 v0 = m_el[0].mVec128; + __m128 v1 = m_el[1].mVec128; + __m128 v2 = m_el[2].mVec128; // x2 y2 z2 w2 + __m128 vT; + + v2 = _mm_and_ps(v2, btvFFF0fMask); // x2 y2 z2 0 + + vT = _mm_unpackhi_ps(v0, v1); // z0 z1 * * + v0 = _mm_unpacklo_ps(v0, v1); // x0 x1 y0 y1 + + v1 = _mm_shuffle_ps(v0, v2, BT_SHUFFLE(2, 3, 1, 3)); // y0 y1 y2 0 + v0 = _mm_shuffle_ps(v0, v2, BT_SHUFFLE(0, 1, 0, 3)); // x0 x1 x2 0 + v2 = btCastdTo128f(_mm_move_sd(btCastfTo128d(v2), btCastfTo128d(vT))); // z0 z1 z2 0 + + return btMatrix3x3(v0, v1, v2); +#elif defined(BT_USE_NEON) + // note: zeros the w channel. We can preserve it at the cost of two more vtrn instructions. + static const uint32x2_t zMask = (const uint32x2_t){static_cast(-1), 0}; + float32x4x2_t top = vtrnq_f32(m_el[0].mVec128, m_el[1].mVec128); // {x0 x1 z0 z1}, {y0 y1 w0 w1} + float32x2x2_t bl = vtrn_f32(vget_low_f32(m_el[2].mVec128), vdup_n_f32(0.0f)); // {x2 0 }, {y2 0} + float32x4_t v0 = vcombine_f32(vget_low_f32(top.val[0]), bl.val[0]); + float32x4_t v1 = vcombine_f32(vget_low_f32(top.val[1]), bl.val[1]); + float32x2_t q = (float32x2_t)vand_u32((uint32x2_t)vget_high_f32(m_el[2].mVec128), zMask); + float32x4_t v2 = vcombine_f32(vget_high_f32(top.val[0]), q); // z0 z1 z2 0 + return btMatrix3x3(v0, v1, v2); +#else + return btMatrix3x3(m_el[0].x(), m_el[1].x(), m_el[2].x(), + m_el[0].y(), m_el[1].y(), m_el[2].y(), + m_el[0].z(), m_el[1].z(), m_el[2].z()); +#endif +} + +SIMD_FORCE_INLINE btMatrix3x3 +btMatrix3x3::adjoint() const +{ + return btMatrix3x3(cofac(1, 1, 2, 2), cofac(0, 2, 2, 1), cofac(0, 1, 1, 2), + cofac(1, 2, 2, 0), cofac(0, 0, 2, 2), cofac(0, 2, 1, 0), + cofac(1, 0, 2, 1), cofac(0, 1, 2, 0), cofac(0, 0, 1, 1)); +} + +SIMD_FORCE_INLINE btMatrix3x3 +btMatrix3x3::inverse() const +{ + btVector3 co(cofac(1, 1, 2, 2), cofac(1, 2, 2, 0), cofac(1, 0, 2, 1)); + btScalar det = (*this)[0].dot(co); + //btFullAssert(det != btScalar(0.0)); + btAssert(det != btScalar(0.0)); + btScalar s = btScalar(1.0) / det; + return btMatrix3x3(co.x() * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s, + co.y() * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s, + co.z() * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s); +} + +SIMD_FORCE_INLINE btMatrix3x3 +btMatrix3x3::transposeTimes(const btMatrix3x3& m) const +{ +#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + // zeros w + // static const __m128i xyzMask = (const __m128i){ -1ULL, 0xffffffffULL }; + __m128 row = m_el[0].mVec128; + __m128 m0 = _mm_and_ps(m.getRow(0).mVec128, btvFFF0fMask); + __m128 m1 = _mm_and_ps(m.getRow(1).mVec128, btvFFF0fMask); + __m128 m2 = _mm_and_ps(m.getRow(2).mVec128, btvFFF0fMask); + __m128 r0 = _mm_mul_ps(m0, _mm_shuffle_ps(row, row, 0)); + __m128 r1 = _mm_mul_ps(m0, _mm_shuffle_ps(row, row, 0x55)); + __m128 r2 = _mm_mul_ps(m0, _mm_shuffle_ps(row, row, 0xaa)); + row = m_el[1].mVec128; + r0 = _mm_add_ps(r0, _mm_mul_ps(m1, _mm_shuffle_ps(row, row, 0))); + r1 = _mm_add_ps(r1, _mm_mul_ps(m1, _mm_shuffle_ps(row, row, 0x55))); + r2 = _mm_add_ps(r2, _mm_mul_ps(m1, _mm_shuffle_ps(row, row, 0xaa))); + row = m_el[2].mVec128; + r0 = _mm_add_ps(r0, _mm_mul_ps(m2, _mm_shuffle_ps(row, row, 0))); + r1 = _mm_add_ps(r1, _mm_mul_ps(m2, _mm_shuffle_ps(row, row, 0x55))); + r2 = _mm_add_ps(r2, _mm_mul_ps(m2, _mm_shuffle_ps(row, row, 0xaa))); + return btMatrix3x3(r0, r1, r2); + +#elif defined BT_USE_NEON + // zeros w + static const uint32x4_t xyzMask = (const uint32x4_t){static_cast(-1), static_cast(-1), static_cast(-1), 0}; + float32x4_t m0 = (float32x4_t)vandq_u32((uint32x4_t)m.getRow(0).mVec128, xyzMask); + float32x4_t m1 = (float32x4_t)vandq_u32((uint32x4_t)m.getRow(1).mVec128, xyzMask); + float32x4_t m2 = (float32x4_t)vandq_u32((uint32x4_t)m.getRow(2).mVec128, xyzMask); + float32x4_t row = m_el[0].mVec128; + float32x4_t r0 = vmulq_lane_f32(m0, vget_low_f32(row), 0); + float32x4_t r1 = vmulq_lane_f32(m0, vget_low_f32(row), 1); + float32x4_t r2 = vmulq_lane_f32(m0, vget_high_f32(row), 0); + row = m_el[1].mVec128; + r0 = vmlaq_lane_f32(r0, m1, vget_low_f32(row), 0); + r1 = vmlaq_lane_f32(r1, m1, vget_low_f32(row), 1); + r2 = vmlaq_lane_f32(r2, m1, vget_high_f32(row), 0); + row = m_el[2].mVec128; + r0 = vmlaq_lane_f32(r0, m2, vget_low_f32(row), 0); + r1 = vmlaq_lane_f32(r1, m2, vget_low_f32(row), 1); + r2 = vmlaq_lane_f32(r2, m2, vget_high_f32(row), 0); + return btMatrix3x3(r0, r1, r2); +#else + return btMatrix3x3( + m_el[0].x() * m[0].x() + m_el[1].x() * m[1].x() + m_el[2].x() * m[2].x(), + m_el[0].x() * m[0].y() + m_el[1].x() * m[1].y() + m_el[2].x() * m[2].y(), + m_el[0].x() * m[0].z() + m_el[1].x() * m[1].z() + m_el[2].x() * m[2].z(), + m_el[0].y() * m[0].x() + m_el[1].y() * m[1].x() + m_el[2].y() * m[2].x(), + m_el[0].y() * m[0].y() + m_el[1].y() * m[1].y() + m_el[2].y() * m[2].y(), + m_el[0].y() * m[0].z() + m_el[1].y() * m[1].z() + m_el[2].y() * m[2].z(), + m_el[0].z() * m[0].x() + m_el[1].z() * m[1].x() + m_el[2].z() * m[2].x(), + m_el[0].z() * m[0].y() + m_el[1].z() * m[1].y() + m_el[2].z() * m[2].y(), + m_el[0].z() * m[0].z() + m_el[1].z() * m[1].z() + m_el[2].z() * m[2].z()); +#endif +} + +SIMD_FORCE_INLINE btMatrix3x3 +btMatrix3x3::timesTranspose(const btMatrix3x3& m) const +{ +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + __m128 a0 = m_el[0].mVec128; + __m128 a1 = m_el[1].mVec128; + __m128 a2 = m_el[2].mVec128; + + btMatrix3x3 mT = m.transpose(); // we rely on transpose() zeroing w channel so that we don't have to do it here + __m128 mx = mT[0].mVec128; + __m128 my = mT[1].mVec128; + __m128 mz = mT[2].mVec128; + + __m128 r0 = _mm_mul_ps(mx, _mm_shuffle_ps(a0, a0, 0x00)); + __m128 r1 = _mm_mul_ps(mx, _mm_shuffle_ps(a1, a1, 0x00)); + __m128 r2 = _mm_mul_ps(mx, _mm_shuffle_ps(a2, a2, 0x00)); + r0 = _mm_add_ps(r0, _mm_mul_ps(my, _mm_shuffle_ps(a0, a0, 0x55))); + r1 = _mm_add_ps(r1, _mm_mul_ps(my, _mm_shuffle_ps(a1, a1, 0x55))); + r2 = _mm_add_ps(r2, _mm_mul_ps(my, _mm_shuffle_ps(a2, a2, 0x55))); + r0 = _mm_add_ps(r0, _mm_mul_ps(mz, _mm_shuffle_ps(a0, a0, 0xaa))); + r1 = _mm_add_ps(r1, _mm_mul_ps(mz, _mm_shuffle_ps(a1, a1, 0xaa))); + r2 = _mm_add_ps(r2, _mm_mul_ps(mz, _mm_shuffle_ps(a2, a2, 0xaa))); + return btMatrix3x3(r0, r1, r2); + +#elif defined BT_USE_NEON + float32x4_t a0 = m_el[0].mVec128; + float32x4_t a1 = m_el[1].mVec128; + float32x4_t a2 = m_el[2].mVec128; + + btMatrix3x3 mT = m.transpose(); // we rely on transpose() zeroing w channel so that we don't have to do it here + float32x4_t mx = mT[0].mVec128; + float32x4_t my = mT[1].mVec128; + float32x4_t mz = mT[2].mVec128; + + float32x4_t r0 = vmulq_lane_f32(mx, vget_low_f32(a0), 0); + float32x4_t r1 = vmulq_lane_f32(mx, vget_low_f32(a1), 0); + float32x4_t r2 = vmulq_lane_f32(mx, vget_low_f32(a2), 0); + r0 = vmlaq_lane_f32(r0, my, vget_low_f32(a0), 1); + r1 = vmlaq_lane_f32(r1, my, vget_low_f32(a1), 1); + r2 = vmlaq_lane_f32(r2, my, vget_low_f32(a2), 1); + r0 = vmlaq_lane_f32(r0, mz, vget_high_f32(a0), 0); + r1 = vmlaq_lane_f32(r1, mz, vget_high_f32(a1), 0); + r2 = vmlaq_lane_f32(r2, mz, vget_high_f32(a2), 0); + return btMatrix3x3(r0, r1, r2); + +#else + return btMatrix3x3( + m_el[0].dot(m[0]), m_el[0].dot(m[1]), m_el[0].dot(m[2]), + m_el[1].dot(m[0]), m_el[1].dot(m[1]), m_el[1].dot(m[2]), + m_el[2].dot(m[0]), m_el[2].dot(m[1]), m_el[2].dot(m[2])); +#endif +} + +SIMD_FORCE_INLINE btVector3 +operator*(const btMatrix3x3& m, const btVector3& v) +{ +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + return v.dot3(m[0], m[1], m[2]); +#else + return btVector3(m[0].dot(v), m[1].dot(v), m[2].dot(v)); +#endif +} + +SIMD_FORCE_INLINE btVector3 +operator*(const btVector3& v, const btMatrix3x3& m) +{ +#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + + const __m128 vv = v.mVec128; + + __m128 c0 = bt_splat_ps(vv, 0); + __m128 c1 = bt_splat_ps(vv, 1); + __m128 c2 = bt_splat_ps(vv, 2); + + c0 = _mm_mul_ps(c0, _mm_and_ps(m[0].mVec128, btvFFF0fMask)); + c1 = _mm_mul_ps(c1, _mm_and_ps(m[1].mVec128, btvFFF0fMask)); + c0 = _mm_add_ps(c0, c1); + c2 = _mm_mul_ps(c2, _mm_and_ps(m[2].mVec128, btvFFF0fMask)); + + return btVector3(_mm_add_ps(c0, c2)); +#elif defined(BT_USE_NEON) + const float32x4_t vv = v.mVec128; + const float32x2_t vlo = vget_low_f32(vv); + const float32x2_t vhi = vget_high_f32(vv); + + float32x4_t c0, c1, c2; + + c0 = (float32x4_t)vandq_s32((int32x4_t)m[0].mVec128, btvFFF0Mask); + c1 = (float32x4_t)vandq_s32((int32x4_t)m[1].mVec128, btvFFF0Mask); + c2 = (float32x4_t)vandq_s32((int32x4_t)m[2].mVec128, btvFFF0Mask); + + c0 = vmulq_lane_f32(c0, vlo, 0); + c1 = vmulq_lane_f32(c1, vlo, 1); + c2 = vmulq_lane_f32(c2, vhi, 0); + c0 = vaddq_f32(c0, c1); + c0 = vaddq_f32(c0, c2); + + return btVector3(c0); +#else + return btVector3(m.tdotx(v), m.tdoty(v), m.tdotz(v)); +#endif +} + +SIMD_FORCE_INLINE btMatrix3x3 +operator*(const btMatrix3x3& m1, const btMatrix3x3& m2) +{ +#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + + __m128 m10 = m1[0].mVec128; + __m128 m11 = m1[1].mVec128; + __m128 m12 = m1[2].mVec128; + + __m128 m2v = _mm_and_ps(m2[0].mVec128, btvFFF0fMask); + + __m128 c0 = bt_splat_ps(m10, 0); + __m128 c1 = bt_splat_ps(m11, 0); + __m128 c2 = bt_splat_ps(m12, 0); + + c0 = _mm_mul_ps(c0, m2v); + c1 = _mm_mul_ps(c1, m2v); + c2 = _mm_mul_ps(c2, m2v); + + m2v = _mm_and_ps(m2[1].mVec128, btvFFF0fMask); + + __m128 c0_1 = bt_splat_ps(m10, 1); + __m128 c1_1 = bt_splat_ps(m11, 1); + __m128 c2_1 = bt_splat_ps(m12, 1); + + c0_1 = _mm_mul_ps(c0_1, m2v); + c1_1 = _mm_mul_ps(c1_1, m2v); + c2_1 = _mm_mul_ps(c2_1, m2v); + + m2v = _mm_and_ps(m2[2].mVec128, btvFFF0fMask); + + c0 = _mm_add_ps(c0, c0_1); + c1 = _mm_add_ps(c1, c1_1); + c2 = _mm_add_ps(c2, c2_1); + + m10 = bt_splat_ps(m10, 2); + m11 = bt_splat_ps(m11, 2); + m12 = bt_splat_ps(m12, 2); + + m10 = _mm_mul_ps(m10, m2v); + m11 = _mm_mul_ps(m11, m2v); + m12 = _mm_mul_ps(m12, m2v); + + c0 = _mm_add_ps(c0, m10); + c1 = _mm_add_ps(c1, m11); + c2 = _mm_add_ps(c2, m12); + + return btMatrix3x3(c0, c1, c2); + +#elif defined(BT_USE_NEON) + + float32x4_t rv0, rv1, rv2; + float32x4_t v0, v1, v2; + float32x4_t mv0, mv1, mv2; + + v0 = m1[0].mVec128; + v1 = m1[1].mVec128; + v2 = m1[2].mVec128; + + mv0 = (float32x4_t)vandq_s32((int32x4_t)m2[0].mVec128, btvFFF0Mask); + mv1 = (float32x4_t)vandq_s32((int32x4_t)m2[1].mVec128, btvFFF0Mask); + mv2 = (float32x4_t)vandq_s32((int32x4_t)m2[2].mVec128, btvFFF0Mask); + + rv0 = vmulq_lane_f32(mv0, vget_low_f32(v0), 0); + rv1 = vmulq_lane_f32(mv0, vget_low_f32(v1), 0); + rv2 = vmulq_lane_f32(mv0, vget_low_f32(v2), 0); + + rv0 = vmlaq_lane_f32(rv0, mv1, vget_low_f32(v0), 1); + rv1 = vmlaq_lane_f32(rv1, mv1, vget_low_f32(v1), 1); + rv2 = vmlaq_lane_f32(rv2, mv1, vget_low_f32(v2), 1); + + rv0 = vmlaq_lane_f32(rv0, mv2, vget_high_f32(v0), 0); + rv1 = vmlaq_lane_f32(rv1, mv2, vget_high_f32(v1), 0); + rv2 = vmlaq_lane_f32(rv2, mv2, vget_high_f32(v2), 0); + + return btMatrix3x3(rv0, rv1, rv2); + +#else + return btMatrix3x3( + m2.tdotx(m1[0]), m2.tdoty(m1[0]), m2.tdotz(m1[0]), + m2.tdotx(m1[1]), m2.tdoty(m1[1]), m2.tdotz(m1[1]), + m2.tdotx(m1[2]), m2.tdoty(m1[2]), m2.tdotz(m1[2])); +#endif +} + +/* +SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const btMatrix3x3& m2) { +return btMatrix3x3( +m1[0][0] * m2[0][0] + m1[1][0] * m2[1][0] + m1[2][0] * m2[2][0], +m1[0][0] * m2[0][1] + m1[1][0] * m2[1][1] + m1[2][0] * m2[2][1], +m1[0][0] * m2[0][2] + m1[1][0] * m2[1][2] + m1[2][0] * m2[2][2], +m1[0][1] * m2[0][0] + m1[1][1] * m2[1][0] + m1[2][1] * m2[2][0], +m1[0][1] * m2[0][1] + m1[1][1] * m2[1][1] + m1[2][1] * m2[2][1], +m1[0][1] * m2[0][2] + m1[1][1] * m2[1][2] + m1[2][1] * m2[2][2], +m1[0][2] * m2[0][0] + m1[1][2] * m2[1][0] + m1[2][2] * m2[2][0], +m1[0][2] * m2[0][1] + m1[1][2] * m2[1][1] + m1[2][2] * m2[2][1], +m1[0][2] * m2[0][2] + m1[1][2] * m2[1][2] + m1[2][2] * m2[2][2]); +} +*/ + +/**@brief Equality operator between two matrices +* It will test all elements are equal. */ +SIMD_FORCE_INLINE bool operator==(const btMatrix3x3& m1, const btMatrix3x3& m2) +{ +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + + __m128 c0, c1, c2; + + c0 = _mm_cmpeq_ps(m1[0].mVec128, m2[0].mVec128); + c1 = _mm_cmpeq_ps(m1[1].mVec128, m2[1].mVec128); + c2 = _mm_cmpeq_ps(m1[2].mVec128, m2[2].mVec128); + + c0 = _mm_and_ps(c0, c1); + c0 = _mm_and_ps(c0, c2); + + int m = _mm_movemask_ps((__m128)c0); + return (0x7 == (m & 0x7)); + +#else + return (m1[0][0] == m2[0][0] && m1[1][0] == m2[1][0] && m1[2][0] == m2[2][0] && + m1[0][1] == m2[0][1] && m1[1][1] == m2[1][1] && m1[2][1] == m2[2][1] && + m1[0][2] == m2[0][2] && m1[1][2] == m2[1][2] && m1[2][2] == m2[2][2]); +#endif +} + +///for serialization +struct btMatrix3x3FloatData +{ + btVector3FloatData m_el[3]; +}; + +///for serialization +struct btMatrix3x3DoubleData +{ + btVector3DoubleData m_el[3]; +}; + +SIMD_FORCE_INLINE void btMatrix3x3::serialize(struct btMatrix3x3Data& dataOut) const +{ + for (int i = 0; i < 3; i++) + m_el[i].serialize(dataOut.m_el[i]); +} + +SIMD_FORCE_INLINE void btMatrix3x3::serializeFloat(struct btMatrix3x3FloatData& dataOut) const +{ + for (int i = 0; i < 3; i++) + m_el[i].serializeFloat(dataOut.m_el[i]); +} + +SIMD_FORCE_INLINE void btMatrix3x3::deSerialize(const struct btMatrix3x3Data& dataIn) +{ + for (int i = 0; i < 3; i++) + m_el[i].deSerialize(dataIn.m_el[i]); +} + +SIMD_FORCE_INLINE void btMatrix3x3::deSerializeFloat(const struct btMatrix3x3FloatData& dataIn) +{ + for (int i = 0; i < 3; i++) + m_el[i].deSerializeFloat(dataIn.m_el[i]); +} + +SIMD_FORCE_INLINE void btMatrix3x3::deSerializeDouble(const struct btMatrix3x3DoubleData& dataIn) +{ + for (int i = 0; i < 3; i++) + m_el[i].deSerializeDouble(dataIn.m_el[i]); +} + +#endif //BT_MATRIX3x3_H diff --git a/pkg/mphysics/mbt/LinearMath/btMatrix3x3.h.i b/pkg/mphysics/mbt/LinearMath/btMatrix3x3.h.i new file mode 100644 index 00000000..d6dddedf --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMatrix3x3.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btMatrix3x3.h ---------------- + +%include "LinearMath/btMatrix3x3.h" + +%{ +#include "LinearMath/btMatrix3x3.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btMatrixX.h b/pkg/mphysics/mbt/LinearMath/btMatrixX.h new file mode 100644 index 00000000..f1b65612 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMatrixX.h @@ -0,0 +1,532 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +///original version written by Erwin Coumans, October 2013 + +#ifndef BT_MATRIX_X_H +#define BT_MATRIX_X_H + +#include "LinearMath/btQuickprof.h" +#include "LinearMath/btAlignedObjectArray.h" +#include + +//#define BT_DEBUG_OSTREAM +#ifdef BT_DEBUG_OSTREAM +#include +#include // std::setw +#endif //BT_DEBUG_OSTREAM + +class btIntSortPredicate +{ +public: + bool operator()(const int& a, const int& b) const + { + return a < b; + } +}; + +template +struct btVectorX +{ + btAlignedObjectArray m_storage; + + btVectorX() + { + } + btVectorX(int numRows) + { + m_storage.resize(numRows); + } + + void resize(int rows) + { + m_storage.resize(rows); + } + int cols() const + { + return 1; + } + int rows() const + { + return m_storage.size(); + } + int size() const + { + return rows(); + } + + T nrm2() const + { + T norm = T(0); + + int nn = rows(); + + { + if (nn == 1) + { + norm = btFabs((*this)[0]); + } + else + { + T scale = 0.0; + T ssq = 1.0; + + /* The following loop is equivalent to this call to the LAPACK + auxiliary routine: CALL SLASSQ( N, X, INCX, SCALE, SSQ ) */ + + for (int ix = 0; ix < nn; ix++) + { + if ((*this)[ix] != 0.0) + { + T absxi = btFabs((*this)[ix]); + if (scale < absxi) + { + T temp; + temp = scale / absxi; + ssq = ssq * (temp * temp) + BT_ONE; + scale = absxi; + } + else + { + T temp; + temp = absxi / scale; + ssq += temp * temp; + } + } + } + norm = scale * sqrt(ssq); + } + } + return norm; + } + void setZero() + { + if (m_storage.size()) + { + // for (int i=0;i + void setElem(btMatrixX& mat, int row, int col, T val) + { + mat.setElem(row,col,val); + } + */ + +template +struct btMatrixX +{ + int m_rows; + int m_cols; + int m_operations; + int m_resizeOperations; + int m_setElemOperations; + + btAlignedObjectArray m_storage; + mutable btAlignedObjectArray > m_rowNonZeroElements1; + + T* getBufferPointerWritable() + { + return m_storage.size() ? &m_storage[0] : 0; + } + + const T* getBufferPointer() const + { + return m_storage.size() ? &m_storage[0] : 0; + } + btMatrixX() + : m_rows(0), + m_cols(0), + m_operations(0), + m_resizeOperations(0), + m_setElemOperations(0) + { + } + btMatrixX(int rows, int cols) + : m_rows(rows), + m_cols(cols), + m_operations(0), + m_resizeOperations(0), + m_setElemOperations(0) + { + resize(rows, cols); + } + void resize(int rows, int cols) + { + m_resizeOperations++; + m_rows = rows; + m_cols = cols; + { +//\1("m_storage.resize"); + m_storage.resize(rows * cols); + } + } + int cols() const + { + return m_cols; + } + int rows() const + { + return m_rows; + } + ///we don't want this read/write operator(), because we cannot keep track of non-zero elements, use setElem instead + /*T& operator() (int row,int col) + { + return m_storage[col*m_rows+row]; + } + */ + + void addElem(int row, int col, T val) + { + if (val) + { + if (m_storage[col + row * m_cols] == 0.f) + { + setElem(row, col, val); + } + else + { + m_storage[row * m_cols + col] += val; + } + } + } + + void setElem(int row, int col, T val) + { + m_setElemOperations++; + m_storage[row * m_cols + col] = val; + } + + void mulElem(int row, int col, T val) + { + m_setElemOperations++; + //mul doesn't change sparsity info + + m_storage[row * m_cols + col] *= val; + } + + void copyLowerToUpperTriangle() + { + int count = 0; + for (int row = 0; row < rows(); row++) + { + for (int col = 0; col < row; col++) + { + setElem(col, row, (*this)(row, col)); + count++; + } + } + //printf("copyLowerToUpperTriangle copied %d elements out of %dx%d=%d\n", count,rows(),cols(),cols()*rows()); + } + + const T& operator()(int row, int col) const + { + return m_storage[col + row * m_cols]; + } + + void setZero() + { + { +//\1("storage=0"); + if (m_storage.size()) + { + btSetZero(&m_storage[0], m_storage.size()); + } + //memset(&m_storage[0],0,sizeof(T)*m_storage.size()); + //for (int i=0;i 0 && numRowsOther > 0 && B && C); + const btScalar* bb = B; + for (int i = 0; i < numRows; i++) + { + const btScalar* cc = C; + for (int j = 0; j < numRowsOther; j++) + { + btScalar sum; + sum = bb[0] * cc[0]; + sum += bb[1] * cc[1]; + sum += bb[2] * cc[2]; + sum += bb[4] * cc[4]; + sum += bb[5] * cc[5]; + sum += bb[6] * cc[6]; + setElem(row + i, col + j, sum); + cc += 8; + } + bb += 8; + } + } + + void setSubMatrix(int rowstart, int colstart, int rowend, int colend, const T value) + { + int numRows = rowend + 1 - rowstart; + int numCols = colend + 1 - colstart; + + for (int row = 0; row < numRows; row++) + { + for (int col = 0; col < numCols; col++) + { + setElem(rowstart + row, colstart + col, value); + } + } + } + + void setSubMatrix(int rowstart, int colstart, int rowend, int colend, const btMatrixX& block) + { + btAssert(rowend + 1 - rowstart == block.rows()); + btAssert(colend + 1 - colstart == block.cols()); + for (int row = 0; row < block.rows(); row++) + { + for (int col = 0; col < block.cols(); col++) + { + setElem(rowstart + row, colstart + col, block(row, col)); + } + } + } + void setSubMatrix(int rowstart, int colstart, int rowend, int colend, const btVectorX& block) + { + btAssert(rowend + 1 - rowstart == block.rows()); + btAssert(colend + 1 - colstart == block.cols()); + for (int row = 0; row < block.rows(); row++) + { + for (int col = 0; col < block.cols(); col++) + { + setElem(rowstart + row, colstart + col, block[row]); + } + } + } + + btMatrixX negative() + { + btMatrixX neg(rows(), cols()); + for (int i = 0; i < rows(); i++) + for (int j = 0; j < cols(); j++) + { + T v = (*this)(i, j); + neg.setElem(i, j, -v); + } + return neg; + } +}; + +typedef btMatrixX btMatrixXf; +typedef btVectorX btVectorXf; + +typedef btMatrixX btMatrixXd; +typedef btVectorX btVectorXd; + +#ifdef BT_DEBUG_OSTREAM +template +std::ostream& operator<<(std::ostream& os, const btMatrixX& mat) +{ + os << " ["; + //printf("%s ---------------------\n",msg); + for (int i = 0; i < mat.rows(); i++) + { + for (int j = 0; j < mat.cols(); j++) + { + os << std::setw(12) << mat(i, j); + } + if (i != mat.rows() - 1) + os << std::endl + << " "; + } + os << " ]"; + //printf("\n---------------------\n"); + + return os; +} +template +std::ostream& operator<<(std::ostream& os, const btVectorX& mat) +{ + os << " ["; + //printf("%s ---------------------\n",msg); + for (int i = 0; i < mat.rows(); i++) + { + os << std::setw(12) << mat[i]; + if (i != mat.rows() - 1) + os << std::endl + << " "; + } + os << " ]"; + //printf("\n---------------------\n"); + + return os; +} + +#endif //BT_DEBUG_OSTREAM + +inline void setElem(btMatrixXd& mat, int row, int col, double val) +{ + mat.setElem(row, col, val); +} + +inline void setElem(btMatrixXf& mat, int row, int col, float val) +{ + mat.setElem(row, col, val); +} + +#ifdef BT_USE_DOUBLE_PRECISION +#define btVectorXu btVectorXd +#define btMatrixXu btMatrixXd +#else +#define btVectorXu btVectorXf +#define btMatrixXu btMatrixXf +#endif //BT_USE_DOUBLE_PRECISION + +#endif //BT_MATRIX_H_H diff --git a/pkg/mphysics/mbt/LinearMath/btMatrixX.h.i b/pkg/mphysics/mbt/LinearMath/btMatrixX.h.i new file mode 100644 index 00000000..00a13e9a --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMatrixX.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btMatrixX.h ---------------- + +%include "LinearMath/btMatrixX.h" + +%{ +#include "LinearMath/btMatrixX.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btMinMax.h b/pkg/mphysics/mbt/LinearMath/btMinMax.h new file mode 100644 index 00000000..cdc54f3f --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMinMax.h @@ -0,0 +1,69 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_GEN_MINMAX_H +#define BT_GEN_MINMAX_H + +#include "btScalar.h" + +template +SIMD_FORCE_INLINE const T& btMin(const T& a, const T& b) +{ + return a < b ? a : b; +} + +template +SIMD_FORCE_INLINE const T& btMax(const T& a, const T& b) +{ + return a > b ? a : b; +} + +template +SIMD_FORCE_INLINE const T& btClamped(const T& a, const T& lb, const T& ub) +{ + return a < lb ? lb : (ub < a ? ub : a); +} + +template +SIMD_FORCE_INLINE void btSetMin(T& a, const T& b) +{ + if (b < a) + { + a = b; + } +} + +template +SIMD_FORCE_INLINE void btSetMax(T& a, const T& b) +{ + if (a < b) + { + a = b; + } +} + +template +SIMD_FORCE_INLINE void btClamp(T& a, const T& lb, const T& ub) +{ + if (a < lb) + { + a = lb; + } + else if (ub < a) + { + a = ub; + } +} + +#endif //BT_GEN_MINMAX_H diff --git a/pkg/mphysics/mbt/LinearMath/btMinMax.h.i b/pkg/mphysics/mbt/LinearMath/btMinMax.h.i new file mode 100644 index 00000000..aecf2d12 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMinMax.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btMinMax.h ---------------- + +%include "LinearMath/btMinMax.h" + +%{ +#include "LinearMath/btMinMax.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btModifiedGramSchmidt.h b/pkg/mphysics/mbt/LinearMath/btModifiedGramSchmidt.h new file mode 100644 index 00000000..33bab8d6 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btModifiedGramSchmidt.h @@ -0,0 +1,83 @@ +// +// btModifiedGramSchmidt.h +// LinearMath +// +// Created by Xuchen Han on 4/4/20. +// + +#ifndef btModifiedGramSchmidt_h +#define btModifiedGramSchmidt_h + +#include "btReducedVector.h" +#include "btAlignedObjectArray.h" +#include +#include +template +class btModifiedGramSchmidt +{ +public: + btAlignedObjectArray m_in; + btAlignedObjectArray m_out; + + btModifiedGramSchmidt(const btAlignedObjectArray& vecs): m_in(vecs) + { + m_out.resize(0); + } + + void solve() + { + m_out.resize(m_in.size()); + for (int i = 0; i < m_in.size(); ++i) + { +// printf("========= starting %d ==========\n", i); + TV v(m_in[i]); +// v.print(); + for (int j = 0; j < i; ++j) + { + v = v - v.proj(m_out[j]); +// v.print(); + } + v.normalize(); + m_out[i] = v; +// v.print(); + } + } + + void test() + { + std::cout << SIMD_EPSILON << std::endl; + printf("=======inputs=========\n"); + for (int i = 0; i < m_out.size(); ++i) + { + m_in[i].print(); + } + printf("=======output=========\n"); + for (int i = 0; i < m_out.size(); ++i) + { + m_out[i].print(); + } + btScalar eps = SIMD_EPSILON; + for (int i = 0; i < m_out.size(); ++i) + { + for (int j = 0; j < m_out.size(); ++j) + { + if (i == j) + { + if (std::abs(1.0-m_out[i].dot(m_out[j])) > eps)// && std::abs(m_out[i].dot(m_out[j])) > eps) + { + printf("vec[%d] is not unit, norm squared = %f\n", i,m_out[i].dot(m_out[j])); + } + } + else + { + if (std::abs(m_out[i].dot(m_out[j])) > eps) + { + printf("vec[%d] and vec[%d] is not orthogonal, dot product = %f\n", i, j, m_out[i].dot(m_out[j])); + } + } + } + } + } +}; +template class btModifiedGramSchmidt; +#endif /* btModifiedGramSchmidt_h */ diff --git a/pkg/mphysics/mbt/LinearMath/btModifiedGramSchmidt.h.i b/pkg/mphysics/mbt/LinearMath/btModifiedGramSchmidt.h.i new file mode 100644 index 00000000..74240c18 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btModifiedGramSchmidt.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btModifiedGramSchmidt.h ---------------- + +%include "LinearMath/btModifiedGramSchmidt.h" + +%{ +#include "LinearMath/btModifiedGramSchmidt.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btMotionState.h b/pkg/mphysics/mbt/LinearMath/btMotionState.h new file mode 100644 index 00000000..87aa6029 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMotionState.h @@ -0,0 +1,36 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_MOTIONSTATE_H +#define BT_MOTIONSTATE_H + +#include "btTransform.h" + +///The btMotionState interface class allows the dynamics world to synchronize and interpolate the updated world transforms with graphics +///For optimizations, potentially only moving objects get synchronized (using setWorldPosition/setWorldOrientation) +class btMotionState +{ +public: + virtual ~btMotionState() + { + } + + virtual void getWorldTransform(btTransform& worldTrans) const = 0; + + //Bullet only calls the update of worldtransform for active objects + virtual void setWorldTransform(const btTransform& worldTrans) = 0; +}; + +#endif //BT_MOTIONSTATE_H diff --git a/pkg/mphysics/mbt/LinearMath/btMotionState.h.i b/pkg/mphysics/mbt/LinearMath/btMotionState.h.i new file mode 100644 index 00000000..264da5b1 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btMotionState.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btMotionState.h ---------------- + +%include "LinearMath/btMotionState.h" + +%{ +#include "LinearMath/btMotionState.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.cpp b/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.cpp new file mode 100644 index 00000000..d9c72a80 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.cpp @@ -0,0 +1,94 @@ +#include "btPolarDecomposition.h" +#include "btMinMax.h" + +namespace +{ +btScalar abs_column_sum(const btMatrix3x3& a, int i) +{ + return btFabs(a[0][i]) + btFabs(a[1][i]) + btFabs(a[2][i]); +} + +btScalar abs_row_sum(const btMatrix3x3& a, int i) +{ + return btFabs(a[i][0]) + btFabs(a[i][1]) + btFabs(a[i][2]); +} + +btScalar p1_norm(const btMatrix3x3& a) +{ + const btScalar sum0 = abs_column_sum(a, 0); + const btScalar sum1 = abs_column_sum(a, 1); + const btScalar sum2 = abs_column_sum(a, 2); + return btMax(btMax(sum0, sum1), sum2); +} + +btScalar pinf_norm(const btMatrix3x3& a) +{ + const btScalar sum0 = abs_row_sum(a, 0); + const btScalar sum1 = abs_row_sum(a, 1); + const btScalar sum2 = abs_row_sum(a, 2); + return btMax(btMax(sum0, sum1), sum2); +} +} // namespace + +btPolarDecomposition::btPolarDecomposition(btScalar tolerance, unsigned int maxIterations) + : m_tolerance(tolerance), m_maxIterations(maxIterations) +{ +} + +unsigned int btPolarDecomposition::decompose(const btMatrix3x3& a, btMatrix3x3& u, btMatrix3x3& h) const +{ + // Use the 'u' and 'h' matrices for intermediate calculations + u = a; + h = a.inverse(); + + for (unsigned int i = 0; i < m_maxIterations; ++i) + { + const btScalar h_1 = p1_norm(h); + const btScalar h_inf = pinf_norm(h); + const btScalar u_1 = p1_norm(u); + const btScalar u_inf = pinf_norm(u); + + const btScalar h_norm = h_1 * h_inf; + const btScalar u_norm = u_1 * u_inf; + + // The matrix is effectively singular so we cannot invert it + if (btFuzzyZero(h_norm) || btFuzzyZero(u_norm)) + break; + + const btScalar gamma = btPow(h_norm / u_norm, 0.25f); + const btScalar inv_gamma = btScalar(1.0) / gamma; + + // Determine the delta to 'u' + const btMatrix3x3 delta = (u * (gamma - btScalar(2.0)) + h.transpose() * inv_gamma) * btScalar(0.5); + + // Update the matrices + u += delta; + h = u.inverse(); + + // Check for convergence + if (p1_norm(delta) <= m_tolerance * u_1) + { + h = u.transpose() * a; + h = (h + h.transpose()) * 0.5; + return i; + } + } + + // The algorithm has failed to converge to the specified tolerance, but we + // want to make sure that the matrices returned are in the right form. + h = u.transpose() * a; + h = (h + h.transpose()) * 0.5; + + return m_maxIterations; +} + +unsigned int btPolarDecomposition::maxIterations() const +{ + return m_maxIterations; +} + +unsigned int polarDecompose(const btMatrix3x3& a, btMatrix3x3& u, btMatrix3x3& h) +{ + static btPolarDecomposition polar; + return polar.decompose(a, u, h); +} diff --git a/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.cpp.i b/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.cpp.i new file mode 100644 index 00000000..dc0a7680 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btPolarDecomposition.cpp ---------------- + +%include "LinearMath/btPolarDecomposition.cpp" + +%{ +#include "LinearMath/btPolarDecomposition.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.h b/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.h new file mode 100644 index 00000000..bf29140a --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.h @@ -0,0 +1,69 @@ +#ifndef POLARDECOMPOSITION_H +#define POLARDECOMPOSITION_H + +#include "btMatrix3x3.h" + +/** + * This class is used to compute the polar decomposition of a matrix. In + * general, the polar decomposition factorizes a matrix, A, into two parts: a + * unitary matrix (U) and a positive, semi-definite Hermitian matrix (H). + * However, in this particular implementation the original matrix, A, is + * required to be a square 3x3 matrix with real elements. This means that U will + * be an orthogonal matrix and H with be a positive-definite, symmetric matrix. + */ +class btPolarDecomposition +{ +public: + /** + * Creates an instance with optional parameters. + * + * @param tolerance - the tolerance used to determine convergence of the + * algorithm + * @param maxIterations - the maximum number of iterations used to achieve + * convergence + */ + btPolarDecomposition(btScalar tolerance = btScalar(0.0001), + unsigned int maxIterations = 16); + + /** + * Decomposes a matrix into orthogonal and symmetric, positive-definite + * parts. If the number of iterations returned by this function is equal to + * the maximum number of iterations, the algorithm has failed to converge. + * + * @param a - the original matrix + * @param u - the resulting orthogonal matrix + * @param h - the resulting symmetric matrix + * + * @return the number of iterations performed by the algorithm. + */ + unsigned int decompose(const btMatrix3x3& a, btMatrix3x3& u, btMatrix3x3& h) const; + + /** + * Returns the maximum number of iterations that this algorithm will perform + * to achieve convergence. + * + * @return maximum number of iterations + */ + unsigned int maxIterations() const; + +private: + btScalar m_tolerance; + unsigned int m_maxIterations; +}; + +/** + * This functions decomposes the matrix 'a' into two parts: an orthogonal matrix + * 'u' and a symmetric, positive-definite matrix 'h'. If the number of + * iterations returned by this function is equal to + * btPolarDecomposition::DEFAULT_MAX_ITERATIONS, the algorithm has failed to + * converge. + * + * @param a - the original matrix + * @param u - the resulting orthogonal matrix + * @param h - the resulting symmetric matrix + * + * @return the number of iterations performed by the algorithm. + */ +unsigned int polarDecompose(const btMatrix3x3& a, btMatrix3x3& u, btMatrix3x3& h); + +#endif // POLARDECOMPOSITION_H diff --git a/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.h.i b/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.h.i new file mode 100644 index 00000000..bdb7afda --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btPolarDecomposition.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btPolarDecomposition.h ---------------- + +%include "LinearMath/btPolarDecomposition.h" + +%{ +#include "LinearMath/btPolarDecomposition.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btPoolAllocator.h b/pkg/mphysics/mbt/LinearMath/btPoolAllocator.h new file mode 100644 index 00000000..816cd627 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btPoolAllocator.h @@ -0,0 +1,130 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef _BT_POOL_ALLOCATOR_H +#define _BT_POOL_ALLOCATOR_H + +#include "btScalar.h" +#include "btAlignedAllocator.h" +#include "btThreads.h" + +///The btPoolAllocator class allows to efficiently allocate a large pool of objects, instead of dynamically allocating them separately. +class btPoolAllocator +{ + int m_elemSize; + int m_maxElements; + int m_freeCount; + void* m_firstFree; + unsigned char* m_pool; + btSpinMutex m_mutex; // only used if BT_THREADSAFE + +public: + btPoolAllocator(int elemSize, int maxElements) + : m_elemSize(elemSize), + m_maxElements(maxElements) + { + m_pool = (unsigned char*)btAlignedAlloc(static_cast(m_elemSize * m_maxElements), 16); + + unsigned char* p = m_pool; + m_firstFree = p; + m_freeCount = m_maxElements; + int count = m_maxElements; + while (--count) + { + *(void**)p = (p + m_elemSize); + p += m_elemSize; + } + *(void**)p = 0; + } + + ~btPoolAllocator() + { + btAlignedFree(m_pool); + } + + int getFreeCount() const + { + return m_freeCount; + } + + int getUsedCount() const + { + return m_maxElements - m_freeCount; + } + + int getMaxCount() const + { + return m_maxElements; + } + + void* allocate(int size) + { + // release mode fix + (void)size; + btMutexLock(&m_mutex); + btAssert(!size || size <= m_elemSize); + //btAssert(m_freeCount>0); // should return null if all full + void* result = m_firstFree; + if (NULL != m_firstFree) + { + m_firstFree = *(void**)m_firstFree; + --m_freeCount; + } + btMutexUnlock(&m_mutex); + return result; + } + + bool validPtr(void* ptr) + { + if (ptr) + { + if (((unsigned char*)ptr >= m_pool && (unsigned char*)ptr < m_pool + m_maxElements * m_elemSize)) + { + return true; + } + } + return false; + } + + void freeMemory(void* ptr) + { + if (ptr) + { + btAssert((unsigned char*)ptr >= m_pool && (unsigned char*)ptr < m_pool + m_maxElements * m_elemSize); + + btMutexLock(&m_mutex); + *(void**)ptr = m_firstFree; + m_firstFree = ptr; + ++m_freeCount; + btMutexUnlock(&m_mutex); + } + } + + int getElementSize() const + { + return m_elemSize; + } + + unsigned char* getPoolAddress() + { + return m_pool; + } + + const unsigned char* getPoolAddress() const + { + return m_pool; + } +}; + +#endif //_BT_POOL_ALLOCATOR_H diff --git a/pkg/mphysics/mbt/LinearMath/btPoolAllocator.h.i b/pkg/mphysics/mbt/LinearMath/btPoolAllocator.h.i new file mode 100644 index 00000000..41dd71c8 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btPoolAllocator.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btPoolAllocator.h ---------------- + +%include "LinearMath/btPoolAllocator.h" + +%{ +#include "LinearMath/btPoolAllocator.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btQuadWord.h b/pkg/mphysics/mbt/LinearMath/btQuadWord.h new file mode 100644 index 00000000..851596b1 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btQuadWord.h @@ -0,0 +1,238 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SIMD_QUADWORD_H +#define BT_SIMD_QUADWORD_H + +#include "btScalar.h" +#include "btMinMax.h" + +#if defined(__CELLOS_LV2) && defined(__SPU__) +#include +#endif + +/**@brief The btQuadWord class is base class for btVector3 and btQuaternion. + * Some issues under PS3 Linux with IBM 2.1 SDK, gcc compiler prevent from using aligned quadword. + */ +#ifndef USE_LIBSPE2 +ATTRIBUTE_ALIGNED16(class) +btQuadWord +#else +class btQuadWord +#endif +{ +protected: +#if defined(__SPU__) && defined(__CELLOS_LV2__) + union { + vec_float4 mVec128; + btScalar m_floats[4]; + }; + +public: + vec_float4 get128() const + { + return mVec128; + } + +protected: +#else //__CELLOS_LV2__ __SPU__ + +#if defined(BT_USE_SSE) || defined(BT_USE_NEON) + union { + btSimdFloat4 mVec128; + btScalar m_floats[4]; + }; + +public: + SIMD_FORCE_INLINE btSimdFloat4 get128() const + { + return mVec128; + } + SIMD_FORCE_INLINE void set128(btSimdFloat4 v128) + { + mVec128 = v128; + } +#else + btScalar m_floats[4]; +#endif // BT_USE_SSE + +#endif //__CELLOS_LV2__ __SPU__ + +public: +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + + // Set Vector + SIMD_FORCE_INLINE btQuadWord(const btSimdFloat4 vec) + { + mVec128 = vec; + } + + // Copy constructor + SIMD_FORCE_INLINE btQuadWord(const btQuadWord& rhs) + { + mVec128 = rhs.mVec128; + } + + // Assignment Operator + SIMD_FORCE_INLINE btQuadWord& + operator=(const btQuadWord& v) + { + mVec128 = v.mVec128; + + return *this; + } + +#endif + + /**@brief Return the x value */ + SIMD_FORCE_INLINE const btScalar& getX() const { return m_floats[0]; } + /**@brief Return the y value */ + SIMD_FORCE_INLINE const btScalar& getY() const { return m_floats[1]; } + /**@brief Return the z value */ + SIMD_FORCE_INLINE const btScalar& getZ() const { return m_floats[2]; } + /**@brief Set the x value */ + SIMD_FORCE_INLINE void setX(btScalar _x) { m_floats[0] = _x; }; + /**@brief Set the y value */ + SIMD_FORCE_INLINE void setY(btScalar _y) { m_floats[1] = _y; }; + /**@brief Set the z value */ + SIMD_FORCE_INLINE void setZ(btScalar _z) { m_floats[2] = _z; }; + /**@brief Set the w value */ + SIMD_FORCE_INLINE void setW(btScalar _w) { m_floats[3] = _w; }; + /**@brief Return the x value */ + SIMD_FORCE_INLINE const btScalar& x() const { return m_floats[0]; } + /**@brief Return the y value */ + SIMD_FORCE_INLINE const btScalar& y() const { return m_floats[1]; } + /**@brief Return the z value */ + SIMD_FORCE_INLINE const btScalar& z() const { return m_floats[2]; } + /**@brief Return the w value */ + SIMD_FORCE_INLINE const btScalar& w() const { return m_floats[3]; } + + //SIMD_FORCE_INLINE btScalar& operator[](int i) { return (&m_floats[0])[i]; } + //SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; } + ///operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons. + SIMD_FORCE_INLINE operator btScalar*() { return &m_floats[0]; } + SIMD_FORCE_INLINE operator const btScalar*() const { return &m_floats[0]; } + + SIMD_FORCE_INLINE bool operator==(const btQuadWord& other) const + { +#ifdef BT_USE_SSE + return (0xf == _mm_movemask_ps((__m128)_mm_cmpeq_ps(mVec128, other.mVec128))); +#else + return ((m_floats[3] == other.m_floats[3]) && + (m_floats[2] == other.m_floats[2]) && + (m_floats[1] == other.m_floats[1]) && + (m_floats[0] == other.m_floats[0])); +#endif + } + + SIMD_FORCE_INLINE bool operator!=(const btQuadWord& other) const + { + return !(*this == other); + } + + /**@brief Set x,y,z and zero w + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + SIMD_FORCE_INLINE void setValue(const btScalar& _x, const btScalar& _y, const btScalar& _z) + { + m_floats[0] = _x; + m_floats[1] = _y; + m_floats[2] = _z; + m_floats[3] = 0.f; + } + + /* void getValue(btScalar *m) const + { + m[0] = m_floats[0]; + m[1] = m_floats[1]; + m[2] = m_floats[2]; + } +*/ + /**@brief Set the values + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + SIMD_FORCE_INLINE void setValue(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w) + { + m_floats[0] = _x; + m_floats[1] = _y; + m_floats[2] = _z; + m_floats[3] = _w; + } + /**@brief No initialization constructor */ + SIMD_FORCE_INLINE btQuadWord() + // :m_floats[0](btScalar(0.)),m_floats[1](btScalar(0.)),m_floats[2](btScalar(0.)),m_floats[3](btScalar(0.)) + { + } + + /**@brief Three argument constructor (zeros w) + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + SIMD_FORCE_INLINE btQuadWord(const btScalar& _x, const btScalar& _y, const btScalar& _z) + { + m_floats[0] = _x, m_floats[1] = _y, m_floats[2] = _z, m_floats[3] = 0.0f; + } + + /**@brief Initializing constructor + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + SIMD_FORCE_INLINE btQuadWord(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w) + { + m_floats[0] = _x, m_floats[1] = _y, m_floats[2] = _z, m_floats[3] = _w; + } + + /**@brief Set each element to the max of the current values and the values of another btQuadWord + * @param other The other btQuadWord to compare with + */ + SIMD_FORCE_INLINE void setMax(const btQuadWord& other) + { +#ifdef BT_USE_SSE + mVec128 = _mm_max_ps(mVec128, other.mVec128); +#elif defined(BT_USE_NEON) + mVec128 = vmaxq_f32(mVec128, other.mVec128); +#else + btSetMax(m_floats[0], other.m_floats[0]); + btSetMax(m_floats[1], other.m_floats[1]); + btSetMax(m_floats[2], other.m_floats[2]); + btSetMax(m_floats[3], other.m_floats[3]); +#endif + } + /**@brief Set each element to the min of the current values and the values of another btQuadWord + * @param other The other btQuadWord to compare with + */ + SIMD_FORCE_INLINE void setMin(const btQuadWord& other) + { +#ifdef BT_USE_SSE + mVec128 = _mm_min_ps(mVec128, other.mVec128); +#elif defined(BT_USE_NEON) + mVec128 = vminq_f32(mVec128, other.mVec128); +#else + btSetMin(m_floats[0], other.m_floats[0]); + btSetMin(m_floats[1], other.m_floats[1]); + btSetMin(m_floats[2], other.m_floats[2]); + btSetMin(m_floats[3], other.m_floats[3]); +#endif + } +}; + +#endif //BT_SIMD_QUADWORD_H diff --git a/pkg/mphysics/mbt/LinearMath/btQuadWord.h.i b/pkg/mphysics/mbt/LinearMath/btQuadWord.h.i new file mode 100644 index 00000000..fc26a046 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btQuadWord.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btQuadWord.h ---------------- + +%include "LinearMath/btQuadWord.h" + +%{ +#include "LinearMath/btQuadWord.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btQuaternion.h b/pkg/mphysics/mbt/LinearMath/btQuaternion.h new file mode 100644 index 00000000..40d6e145 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btQuaternion.h @@ -0,0 +1,1021 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SIMD__QUATERNION_H_ +#define BT_SIMD__QUATERNION_H_ + +#include "btVector3.h" +#include "btQuadWord.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define btQuaternionData btQuaternionDoubleData +#define btQuaternionDataName "btQuaternionDoubleData" +#else +#define btQuaternionData btQuaternionFloatData +#define btQuaternionDataName "btQuaternionFloatData" +#endif //BT_USE_DOUBLE_PRECISION + +#ifdef BT_USE_SSE + +//const __m128 ATTRIBUTE_ALIGNED16(vOnes) = {1.0f, 1.0f, 1.0f, 1.0f}; +#define vOnes (_mm_set_ps(1.0f, 1.0f, 1.0f, 1.0f)) + +#endif + +#if defined(BT_USE_SSE) + +#define vQInv (_mm_set_ps(+0.0f, -0.0f, -0.0f, -0.0f)) +#define vPPPM (_mm_set_ps(-0.0f, +0.0f, +0.0f, +0.0f)) + +#elif defined(BT_USE_NEON) + +const btSimdFloat4 ATTRIBUTE_ALIGNED16(vQInv) = {-0.0f, -0.0f, -0.0f, +0.0f}; +const btSimdFloat4 ATTRIBUTE_ALIGNED16(vPPPM) = {+0.0f, +0.0f, +0.0f, -0.0f}; + +#endif + +/**@brief The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatrix3x3, btVector3 and btTransform. */ +class btQuaternion : public btQuadWord +{ +public: + /**@brief No initialization constructor */ + btQuaternion() {} + +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + // Set Vector + SIMD_FORCE_INLINE btQuaternion(const btSimdFloat4 vec) + { + mVec128 = vec; + } + + // Copy constructor + SIMD_FORCE_INLINE btQuaternion(const btQuaternion& rhs) + { + mVec128 = rhs.mVec128; + } + + // Assignment Operator + SIMD_FORCE_INLINE btQuaternion& + operator=(const btQuaternion& v) + { + mVec128 = v.mVec128; + + return *this; + } + +#endif + + // template + // explicit Quaternion(const btScalar *v) : Tuple4(v) {} + /**@brief Constructor from scalars */ + btQuaternion(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w) + : btQuadWord(_x, _y, _z, _w) + { + } + /**@brief Axis angle Constructor + * @param axis The axis which the rotation is around + * @param angle The magnitude of the rotation around the angle (Radians) */ + btQuaternion(const btVector3& _axis, const btScalar& _angle) + { + setRotation(_axis, _angle); + } + /**@brief Constructor from Euler angles + * @param yaw Angle around Y unless BT_EULER_DEFAULT_ZYX defined then Z + * @param pitch Angle around X unless BT_EULER_DEFAULT_ZYX defined then Y + * @param roll Angle around Z unless BT_EULER_DEFAULT_ZYX defined then X */ + btQuaternion(const btScalar& yaw, const btScalar& pitch, const btScalar& roll) + { +#ifndef BT_EULER_DEFAULT_ZYX + setEuler(yaw, pitch, roll); +#else + setEulerZYX(yaw, pitch, roll); +#endif + } + /**@brief Set the rotation using axis angle notation + * @param axis The axis around which to rotate + * @param angle The magnitude of the rotation in Radians */ + void setRotation(const btVector3& axis, const btScalar& _angle) + { + btScalar d = axis.length(); + btAssert(d != btScalar(0.0)); + btScalar s = btSin(_angle * btScalar(0.5)) / d; + setValue(axis.x() * s, axis.y() * s, axis.z() * s, + btCos(_angle * btScalar(0.5))); + } + /**@brief Set the quaternion using Euler angles + * @param yaw Angle around Y + * @param pitch Angle around X + * @param roll Angle around Z */ + void setEuler(const btScalar& yaw, const btScalar& pitch, const btScalar& roll) + { + btScalar halfYaw = btScalar(yaw) * btScalar(0.5); + btScalar halfPitch = btScalar(pitch) * btScalar(0.5); + btScalar halfRoll = btScalar(roll) * btScalar(0.5); + btScalar cosYaw = btCos(halfYaw); + btScalar sinYaw = btSin(halfYaw); + btScalar cosPitch = btCos(halfPitch); + btScalar sinPitch = btSin(halfPitch); + btScalar cosRoll = btCos(halfRoll); + btScalar sinRoll = btSin(halfRoll); + setValue(cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw, + cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw, + sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw, + cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw); + } + /**@brief Set the quaternion using euler angles + * @param yaw Angle around Z + * @param pitch Angle around Y + * @param roll Angle around X */ + void setEulerZYX(const btScalar& yawZ, const btScalar& pitchY, const btScalar& rollX) + { + btScalar halfYaw = btScalar(yawZ) * btScalar(0.5); + btScalar halfPitch = btScalar(pitchY) * btScalar(0.5); + btScalar halfRoll = btScalar(rollX) * btScalar(0.5); + btScalar cosYaw = btCos(halfYaw); + btScalar sinYaw = btSin(halfYaw); + btScalar cosPitch = btCos(halfPitch); + btScalar sinPitch = btSin(halfPitch); + btScalar cosRoll = btCos(halfRoll); + btScalar sinRoll = btSin(halfRoll); + setValue(sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw, //x + cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw, //y + cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw, //z + cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw); //formerly yzx + } + + /**@brief Get the euler angles from this quaternion + * @param yaw Angle around Z + * @param pitch Angle around Y + * @param roll Angle around X */ + void getEulerZYX(btScalar& yawZ, btScalar& pitchY, btScalar& rollX) const + { + btScalar squ; + btScalar sqx; + btScalar sqy; + btScalar sqz; + btScalar sarg; + sqx = m_floats[0] * m_floats[0]; + sqy = m_floats[1] * m_floats[1]; + sqz = m_floats[2] * m_floats[2]; + squ = m_floats[3] * m_floats[3]; + sarg = btScalar(-2.) * (m_floats[0] * m_floats[2] - m_floats[3] * m_floats[1]); + + // If the pitch angle is PI/2 or -PI/2, we can only compute + // the sum roll + yaw. However, any combination that gives + // the right sum will produce the correct orientation, so we + // set rollX = 0 and compute yawZ. + if (sarg <= -btScalar(0.99999)) + { + pitchY = btScalar(-0.5) * SIMD_PI; + rollX = 0; + yawZ = btScalar(2) * btAtan2(m_floats[0], -m_floats[1]); + } + else if (sarg >= btScalar(0.99999)) + { + pitchY = btScalar(0.5) * SIMD_PI; + rollX = 0; + yawZ = btScalar(2) * btAtan2(-m_floats[0], m_floats[1]); + } + else + { + pitchY = btAsin(sarg); + rollX = btAtan2(2 * (m_floats[1] * m_floats[2] + m_floats[3] * m_floats[0]), squ - sqx - sqy + sqz); + yawZ = btAtan2(2 * (m_floats[0] * m_floats[1] + m_floats[3] * m_floats[2]), squ + sqx - sqy - sqz); + } + } + + /**@brief Add two quaternions + * @param q The quaternion to add to this one */ + SIMD_FORCE_INLINE btQuaternion& operator+=(const btQuaternion& q) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + mVec128 = _mm_add_ps(mVec128, q.mVec128); +#elif defined(BT_USE_NEON) + mVec128 = vaddq_f32(mVec128, q.mVec128); +#else + m_floats[0] += q.x(); + m_floats[1] += q.y(); + m_floats[2] += q.z(); + m_floats[3] += q.m_floats[3]; +#endif + return *this; + } + + /**@brief Subtract out a quaternion + * @param q The quaternion to subtract from this one */ + btQuaternion& operator-=(const btQuaternion& q) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + mVec128 = _mm_sub_ps(mVec128, q.mVec128); +#elif defined(BT_USE_NEON) + mVec128 = vsubq_f32(mVec128, q.mVec128); +#else + m_floats[0] -= q.x(); + m_floats[1] -= q.y(); + m_floats[2] -= q.z(); + m_floats[3] -= q.m_floats[3]; +#endif + return *this; + } + + /**@brief Scale this quaternion + * @param s The scalar to scale by */ + btQuaternion& operator*=(const btScalar& s) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vs = _mm_load_ss(&s); // (S 0 0 0) + vs = bt_pshufd_ps(vs, 0); // (S S S S) + mVec128 = _mm_mul_ps(mVec128, vs); +#elif defined(BT_USE_NEON) + mVec128 = vmulq_n_f32(mVec128, s); +#else + m_floats[0] *= s; + m_floats[1] *= s; + m_floats[2] *= s; + m_floats[3] *= s; +#endif + return *this; + } + + /**@brief Multiply this quaternion by q on the right + * @param q The other quaternion + * Equivilant to this = this * q */ + btQuaternion& operator*=(const btQuaternion& q) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vQ2 = q.get128(); + + __m128 A1 = bt_pshufd_ps(mVec128, BT_SHUFFLE(0, 1, 2, 0)); + __m128 B1 = bt_pshufd_ps(vQ2, BT_SHUFFLE(3, 3, 3, 0)); + + A1 = A1 * B1; + + __m128 A2 = bt_pshufd_ps(mVec128, BT_SHUFFLE(1, 2, 0, 1)); + __m128 B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(2, 0, 1, 1)); + + A2 = A2 * B2; + + B1 = bt_pshufd_ps(mVec128, BT_SHUFFLE(2, 0, 1, 2)); + B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(1, 2, 0, 2)); + + B1 = B1 * B2; // A3 *= B3 + + mVec128 = bt_splat_ps(mVec128, 3); // A0 + mVec128 = mVec128 * vQ2; // A0 * B0 + + A1 = A1 + A2; // AB12 + mVec128 = mVec128 - B1; // AB03 = AB0 - AB3 + A1 = _mm_xor_ps(A1, vPPPM); // change sign of the last element + mVec128 = mVec128 + A1; // AB03 + AB12 + +#elif defined(BT_USE_NEON) + + float32x4_t vQ1 = mVec128; + float32x4_t vQ2 = q.get128(); + float32x4_t A0, A1, B1, A2, B2, A3, B3; + float32x2_t vQ1zx, vQ2wx, vQ1yz, vQ2zx, vQ2yz, vQ2xz; + + { + float32x2x2_t tmp; + tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1)); // {z x}, {w y} + vQ1zx = tmp.val[0]; + + tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2)); // {z x}, {w y} + vQ2zx = tmp.val[0]; + } + vQ2wx = vext_f32(vget_high_f32(vQ2), vget_low_f32(vQ2), 1); + + vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1); + + vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1); + vQ2xz = vext_f32(vQ2zx, vQ2zx, 1); + + A1 = vcombine_f32(vget_low_f32(vQ1), vQ1zx); // X Y z x + B1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ2), 1), vQ2wx); // W W W X + + A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1)); + B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1)); + + A3 = vcombine_f32(vQ1zx, vQ1yz); // Z X Y Z + B3 = vcombine_f32(vQ2yz, vQ2xz); // Y Z x z + + A1 = vmulq_f32(A1, B1); + A2 = vmulq_f32(A2, B2); + A3 = vmulq_f32(A3, B3); // A3 *= B3 + A0 = vmulq_lane_f32(vQ2, vget_high_f32(vQ1), 1); // A0 * B0 + + A1 = vaddq_f32(A1, A2); // AB12 = AB1 + AB2 + A0 = vsubq_f32(A0, A3); // AB03 = AB0 - AB3 + + // change the sign of the last element + A1 = (btSimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM); + A0 = vaddq_f32(A0, A1); // AB03 + AB12 + + mVec128 = A0; +#else + setValue( + m_floats[3] * q.x() + m_floats[0] * q.m_floats[3] + m_floats[1] * q.z() - m_floats[2] * q.y(), + m_floats[3] * q.y() + m_floats[1] * q.m_floats[3] + m_floats[2] * q.x() - m_floats[0] * q.z(), + m_floats[3] * q.z() + m_floats[2] * q.m_floats[3] + m_floats[0] * q.y() - m_floats[1] * q.x(), + m_floats[3] * q.m_floats[3] - m_floats[0] * q.x() - m_floats[1] * q.y() - m_floats[2] * q.z()); +#endif + return *this; + } + /**@brief Return the dot product between this quaternion and another + * @param q The other quaternion */ + btScalar dot(const btQuaternion& q) const + { +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vd; + + vd = _mm_mul_ps(mVec128, q.mVec128); + + __m128 t = _mm_movehl_ps(vd, vd); + vd = _mm_add_ps(vd, t); + t = _mm_shuffle_ps(vd, vd, 0x55); + vd = _mm_add_ss(vd, t); + + return _mm_cvtss_f32(vd); +#elif defined(BT_USE_NEON) + float32x4_t vd = vmulq_f32(mVec128, q.mVec128); + float32x2_t x = vpadd_f32(vget_low_f32(vd), vget_high_f32(vd)); + x = vpadd_f32(x, x); + return vget_lane_f32(x, 0); +#else + return m_floats[0] * q.x() + + m_floats[1] * q.y() + + m_floats[2] * q.z() + + m_floats[3] * q.m_floats[3]; +#endif + } + + /**@brief Return the length squared of the quaternion */ + btScalar length2() const + { + return dot(*this); + } + + /**@brief Return the length of the quaternion */ + btScalar length() const + { + return btSqrt(length2()); + } + btQuaternion& safeNormalize() + { + btScalar l2 = length2(); + if (l2 > SIMD_EPSILON) + { + normalize(); + } + return *this; + } + /**@brief Normalize the quaternion + * Such that x^2 + y^2 + z^2 +w^2 = 1 */ + btQuaternion& normalize() + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vd; + + vd = _mm_mul_ps(mVec128, mVec128); + + __m128 t = _mm_movehl_ps(vd, vd); + vd = _mm_add_ps(vd, t); + t = _mm_shuffle_ps(vd, vd, 0x55); + vd = _mm_add_ss(vd, t); + + vd = _mm_sqrt_ss(vd); + vd = _mm_div_ss(vOnes, vd); + vd = bt_pshufd_ps(vd, 0); // splat + mVec128 = _mm_mul_ps(mVec128, vd); + + return *this; +#else + return *this /= length(); +#endif + } + + /**@brief Return a scaled version of this quaternion + * @param s The scale factor */ + SIMD_FORCE_INLINE btQuaternion + operator*(const btScalar& s) const + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vs = _mm_load_ss(&s); // (S 0 0 0) + vs = bt_pshufd_ps(vs, 0x00); // (S S S S) + + return btQuaternion(_mm_mul_ps(mVec128, vs)); +#elif defined(BT_USE_NEON) + return btQuaternion(vmulq_n_f32(mVec128, s)); +#else + return btQuaternion(x() * s, y() * s, z() * s, m_floats[3] * s); +#endif + } + + /**@brief Return an inversely scaled versionof this quaternion + * @param s The inverse scale factor */ + btQuaternion operator/(const btScalar& s) const + { + btAssert(s != btScalar(0.0)); + return *this * (btScalar(1.0) / s); + } + + /**@brief Inversely scale this quaternion + * @param s The scale factor */ + btQuaternion& operator/=(const btScalar& s) + { + btAssert(s != btScalar(0.0)); + return *this *= btScalar(1.0) / s; + } + + /**@brief Return a normalized version of this quaternion */ + btQuaternion normalized() const + { + return *this / length(); + } + /**@brief Return the ***half*** angle between this quaternion and the other + * @param q The other quaternion */ + btScalar angle(const btQuaternion& q) const + { + btScalar s = btSqrt(length2() * q.length2()); + btAssert(s != btScalar(0.0)); + return btAcos(dot(q) / s); + } + + /**@brief Return the angle between this quaternion and the other along the shortest path + * @param q The other quaternion */ + btScalar angleShortestPath(const btQuaternion& q) const + { + btScalar s = btSqrt(length2() * q.length2()); + btAssert(s != btScalar(0.0)); + if (dot(q) < 0) // Take care of long angle case see http://en.wikipedia.org/wiki/Slerp + return btAcos(dot(-q) / s) * btScalar(2.0); + else + return btAcos(dot(q) / s) * btScalar(2.0); + } + + /**@brief Return the angle [0, 2Pi] of rotation represented by this quaternion */ + btScalar getAngle() const + { + btScalar s = btScalar(2.) * btAcos(m_floats[3]); + return s; + } + + /**@brief Return the angle [0, Pi] of rotation represented by this quaternion along the shortest path */ + btScalar getAngleShortestPath() const + { + btScalar s; + if (m_floats[3] >= 0) + s = btScalar(2.) * btAcos(m_floats[3]); + else + s = btScalar(2.) * btAcos(-m_floats[3]); + return s; + } + + /**@brief Return the axis of the rotation represented by this quaternion */ + btVector3 getAxis() const + { + btScalar s_squared = 1.f - m_floats[3] * m_floats[3]; + + if (s_squared < btScalar(10.) * SIMD_EPSILON) //Check for divide by zero + return btVector3(1.0, 0.0, 0.0); // Arbitrary + btScalar s = 1.f / btSqrt(s_squared); + return btVector3(m_floats[0] * s, m_floats[1] * s, m_floats[2] * s); + } + + /**@brief Return the inverse of this quaternion */ + btQuaternion inverse() const + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + return btQuaternion(_mm_xor_ps(mVec128, vQInv)); +#elif defined(BT_USE_NEON) + return btQuaternion((btSimdFloat4)veorq_s32((int32x4_t)mVec128, (int32x4_t)vQInv)); +#else + return btQuaternion(-m_floats[0], -m_floats[1], -m_floats[2], m_floats[3]); +#endif + } + + /**@brief Return the sum of this quaternion and the other + * @param q2 The other quaternion */ + SIMD_FORCE_INLINE btQuaternion + operator+(const btQuaternion& q2) const + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + return btQuaternion(_mm_add_ps(mVec128, q2.mVec128)); +#elif defined(BT_USE_NEON) + return btQuaternion(vaddq_f32(mVec128, q2.mVec128)); +#else + const btQuaternion& q1 = *this; + return btQuaternion(q1.x() + q2.x(), q1.y() + q2.y(), q1.z() + q2.z(), q1.m_floats[3] + q2.m_floats[3]); +#endif + } + + /**@brief Return the difference between this quaternion and the other + * @param q2 The other quaternion */ + SIMD_FORCE_INLINE btQuaternion + operator-(const btQuaternion& q2) const + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + return btQuaternion(_mm_sub_ps(mVec128, q2.mVec128)); +#elif defined(BT_USE_NEON) + return btQuaternion(vsubq_f32(mVec128, q2.mVec128)); +#else + const btQuaternion& q1 = *this; + return btQuaternion(q1.x() - q2.x(), q1.y() - q2.y(), q1.z() - q2.z(), q1.m_floats[3] - q2.m_floats[3]); +#endif + } + + /**@brief Return the negative of this quaternion + * This simply negates each element */ + SIMD_FORCE_INLINE btQuaternion operator-() const + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + return btQuaternion(_mm_xor_ps(mVec128, btvMzeroMask)); +#elif defined(BT_USE_NEON) + return btQuaternion((btSimdFloat4)veorq_s32((int32x4_t)mVec128, (int32x4_t)btvMzeroMask)); +#else + const btQuaternion& q2 = *this; + return btQuaternion(-q2.x(), -q2.y(), -q2.z(), -q2.m_floats[3]); +#endif + } + /**@todo document this and it's use */ + SIMD_FORCE_INLINE btQuaternion farthest(const btQuaternion& qd) const + { + btQuaternion diff, sum; + diff = *this - qd; + sum = *this + qd; + if (diff.dot(diff) > sum.dot(sum)) + return qd; + return (-qd); + } + + /**@todo document this and it's use */ + SIMD_FORCE_INLINE btQuaternion nearest(const btQuaternion& qd) const + { + btQuaternion diff, sum; + diff = *this - qd; + sum = *this + qd; + if (diff.dot(diff) < sum.dot(sum)) + return qd; + return (-qd); + } + + /**@brief Return the quaternion which is the result of Spherical Linear Interpolation between this and the other quaternion + * @param q The other quaternion to interpolate with + * @param t The ratio between this and q to interpolate. If t = 0 the result is this, if t=1 the result is q. + * Slerp interpolates assuming constant velocity. */ + btQuaternion slerp(const btQuaternion& q, const btScalar& t) const + { + const btScalar magnitude = btSqrt(length2() * q.length2()); + btAssert(magnitude > btScalar(0)); + + const btScalar product = dot(q) / magnitude; + const btScalar absproduct = btFabs(product); + + if (absproduct < btScalar(1.0 - SIMD_EPSILON)) + { + // Take care of long angle case see http://en.wikipedia.org/wiki/Slerp + const btScalar theta = btAcos(absproduct); + const btScalar d = btSin(theta); + btAssert(d > btScalar(0)); + + const btScalar sign = (product < 0) ? btScalar(-1) : btScalar(1); + const btScalar s0 = btSin((btScalar(1.0) - t) * theta) / d; + const btScalar s1 = btSin(sign * t * theta) / d; + + return btQuaternion( + (m_floats[0] * s0 + q.x() * s1), + (m_floats[1] * s0 + q.y() * s1), + (m_floats[2] * s0 + q.z() * s1), + (m_floats[3] * s0 + q.w() * s1)); + } + else + { + return *this; + } + } + + static const btQuaternion& getIdentity() + { + static const btQuaternion identityQuat(btScalar(0.), btScalar(0.), btScalar(0.), btScalar(1.)); + return identityQuat; + } + + SIMD_FORCE_INLINE const btScalar& getW() const { return m_floats[3]; } + + SIMD_FORCE_INLINE void serialize(struct btQuaternionData& dataOut) const; + + SIMD_FORCE_INLINE void deSerialize(const struct btQuaternionFloatData& dataIn); + + SIMD_FORCE_INLINE void deSerialize(const struct btQuaternionDoubleData& dataIn); + + SIMD_FORCE_INLINE void serializeFloat(struct btQuaternionFloatData& dataOut) const; + + SIMD_FORCE_INLINE void deSerializeFloat(const struct btQuaternionFloatData& dataIn); + + SIMD_FORCE_INLINE void serializeDouble(struct btQuaternionDoubleData& dataOut) const; + + SIMD_FORCE_INLINE void deSerializeDouble(const struct btQuaternionDoubleData& dataIn); +}; + +/**@brief Return the product of two quaternions */ +SIMD_FORCE_INLINE btQuaternion +operator*(const btQuaternion& q1, const btQuaternion& q2) +{ +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vQ1 = q1.get128(); + __m128 vQ2 = q2.get128(); + __m128 A0, A1, B1, A2, B2; + + A1 = bt_pshufd_ps(vQ1, BT_SHUFFLE(0, 1, 2, 0)); // X Y z x // vtrn + B1 = bt_pshufd_ps(vQ2, BT_SHUFFLE(3, 3, 3, 0)); // W W W X // vdup vext + + A1 = A1 * B1; + + A2 = bt_pshufd_ps(vQ1, BT_SHUFFLE(1, 2, 0, 1)); // Y Z X Y // vext + B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(2, 0, 1, 1)); // z x Y Y // vtrn vdup + + A2 = A2 * B2; + + B1 = bt_pshufd_ps(vQ1, BT_SHUFFLE(2, 0, 1, 2)); // z x Y Z // vtrn vext + B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(1, 2, 0, 2)); // Y Z x z // vext vtrn + + B1 = B1 * B2; // A3 *= B3 + + A0 = bt_splat_ps(vQ1, 3); // A0 + A0 = A0 * vQ2; // A0 * B0 + + A1 = A1 + A2; // AB12 + A0 = A0 - B1; // AB03 = AB0 - AB3 + + A1 = _mm_xor_ps(A1, vPPPM); // change sign of the last element + A0 = A0 + A1; // AB03 + AB12 + + return btQuaternion(A0); + +#elif defined(BT_USE_NEON) + + float32x4_t vQ1 = q1.get128(); + float32x4_t vQ2 = q2.get128(); + float32x4_t A0, A1, B1, A2, B2, A3, B3; + float32x2_t vQ1zx, vQ2wx, vQ1yz, vQ2zx, vQ2yz, vQ2xz; + + { + float32x2x2_t tmp; + tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1)); // {z x}, {w y} + vQ1zx = tmp.val[0]; + + tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2)); // {z x}, {w y} + vQ2zx = tmp.val[0]; + } + vQ2wx = vext_f32(vget_high_f32(vQ2), vget_low_f32(vQ2), 1); + + vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1); + + vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1); + vQ2xz = vext_f32(vQ2zx, vQ2zx, 1); + + A1 = vcombine_f32(vget_low_f32(vQ1), vQ1zx); // X Y z x + B1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ2), 1), vQ2wx); // W W W X + + A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1)); + B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1)); + + A3 = vcombine_f32(vQ1zx, vQ1yz); // Z X Y Z + B3 = vcombine_f32(vQ2yz, vQ2xz); // Y Z x z + + A1 = vmulq_f32(A1, B1); + A2 = vmulq_f32(A2, B2); + A3 = vmulq_f32(A3, B3); // A3 *= B3 + A0 = vmulq_lane_f32(vQ2, vget_high_f32(vQ1), 1); // A0 * B0 + + A1 = vaddq_f32(A1, A2); // AB12 = AB1 + AB2 + A0 = vsubq_f32(A0, A3); // AB03 = AB0 - AB3 + + // change the sign of the last element + A1 = (btSimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM); + A0 = vaddq_f32(A0, A1); // AB03 + AB12 + + return btQuaternion(A0); + +#else + return btQuaternion( + q1.w() * q2.x() + q1.x() * q2.w() + q1.y() * q2.z() - q1.z() * q2.y(), + q1.w() * q2.y() + q1.y() * q2.w() + q1.z() * q2.x() - q1.x() * q2.z(), + q1.w() * q2.z() + q1.z() * q2.w() + q1.x() * q2.y() - q1.y() * q2.x(), + q1.w() * q2.w() - q1.x() * q2.x() - q1.y() * q2.y() - q1.z() * q2.z()); +#endif +} + +SIMD_FORCE_INLINE btQuaternion +operator*(const btQuaternion& q, const btVector3& w) +{ +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vQ1 = q.get128(); + __m128 vQ2 = w.get128(); + __m128 A1, B1, A2, B2, A3, B3; + + A1 = bt_pshufd_ps(vQ1, BT_SHUFFLE(3, 3, 3, 0)); + B1 = bt_pshufd_ps(vQ2, BT_SHUFFLE(0, 1, 2, 0)); + + A1 = A1 * B1; + + A2 = bt_pshufd_ps(vQ1, BT_SHUFFLE(1, 2, 0, 1)); + B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(2, 0, 1, 1)); + + A2 = A2 * B2; + + A3 = bt_pshufd_ps(vQ1, BT_SHUFFLE(2, 0, 1, 2)); + B3 = bt_pshufd_ps(vQ2, BT_SHUFFLE(1, 2, 0, 2)); + + A3 = A3 * B3; // A3 *= B3 + + A1 = A1 + A2; // AB12 + A1 = _mm_xor_ps(A1, vPPPM); // change sign of the last element + A1 = A1 - A3; // AB123 = AB12 - AB3 + + return btQuaternion(A1); + +#elif defined(BT_USE_NEON) + + float32x4_t vQ1 = q.get128(); + float32x4_t vQ2 = w.get128(); + float32x4_t A1, B1, A2, B2, A3, B3; + float32x2_t vQ1wx, vQ2zx, vQ1yz, vQ2yz, vQ1zx, vQ2xz; + + vQ1wx = vext_f32(vget_high_f32(vQ1), vget_low_f32(vQ1), 1); + { + float32x2x2_t tmp; + + tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2)); // {z x}, {w y} + vQ2zx = tmp.val[0]; + + tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1)); // {z x}, {w y} + vQ1zx = tmp.val[0]; + } + + vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1); + + vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1); + vQ2xz = vext_f32(vQ2zx, vQ2zx, 1); + + A1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ1), 1), vQ1wx); // W W W X + B1 = vcombine_f32(vget_low_f32(vQ2), vQ2zx); // X Y z x + + A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1)); + B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1)); + + A3 = vcombine_f32(vQ1zx, vQ1yz); // Z X Y Z + B3 = vcombine_f32(vQ2yz, vQ2xz); // Y Z x z + + A1 = vmulq_f32(A1, B1); + A2 = vmulq_f32(A2, B2); + A3 = vmulq_f32(A3, B3); // A3 *= B3 + + A1 = vaddq_f32(A1, A2); // AB12 = AB1 + AB2 + + // change the sign of the last element + A1 = (btSimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM); + + A1 = vsubq_f32(A1, A3); // AB123 = AB12 - AB3 + + return btQuaternion(A1); + +#else + return btQuaternion( + q.w() * w.x() + q.y() * w.z() - q.z() * w.y(), + q.w() * w.y() + q.z() * w.x() - q.x() * w.z(), + q.w() * w.z() + q.x() * w.y() - q.y() * w.x(), + -q.x() * w.x() - q.y() * w.y() - q.z() * w.z()); +#endif +} + +SIMD_FORCE_INLINE btQuaternion +operator*(const btVector3& w, const btQuaternion& q) +{ +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vQ1 = w.get128(); + __m128 vQ2 = q.get128(); + __m128 A1, B1, A2, B2, A3, B3; + + A1 = bt_pshufd_ps(vQ1, BT_SHUFFLE(0, 1, 2, 0)); // X Y z x + B1 = bt_pshufd_ps(vQ2, BT_SHUFFLE(3, 3, 3, 0)); // W W W X + + A1 = A1 * B1; + + A2 = bt_pshufd_ps(vQ1, BT_SHUFFLE(1, 2, 0, 1)); + B2 = bt_pshufd_ps(vQ2, BT_SHUFFLE(2, 0, 1, 1)); + + A2 = A2 * B2; + + A3 = bt_pshufd_ps(vQ1, BT_SHUFFLE(2, 0, 1, 2)); + B3 = bt_pshufd_ps(vQ2, BT_SHUFFLE(1, 2, 0, 2)); + + A3 = A3 * B3; // A3 *= B3 + + A1 = A1 + A2; // AB12 + A1 = _mm_xor_ps(A1, vPPPM); // change sign of the last element + A1 = A1 - A3; // AB123 = AB12 - AB3 + + return btQuaternion(A1); + +#elif defined(BT_USE_NEON) + + float32x4_t vQ1 = w.get128(); + float32x4_t vQ2 = q.get128(); + float32x4_t A1, B1, A2, B2, A3, B3; + float32x2_t vQ1zx, vQ2wx, vQ1yz, vQ2zx, vQ2yz, vQ2xz; + + { + float32x2x2_t tmp; + + tmp = vtrn_f32(vget_high_f32(vQ1), vget_low_f32(vQ1)); // {z x}, {w y} + vQ1zx = tmp.val[0]; + + tmp = vtrn_f32(vget_high_f32(vQ2), vget_low_f32(vQ2)); // {z x}, {w y} + vQ2zx = tmp.val[0]; + } + vQ2wx = vext_f32(vget_high_f32(vQ2), vget_low_f32(vQ2), 1); + + vQ1yz = vext_f32(vget_low_f32(vQ1), vget_high_f32(vQ1), 1); + + vQ2yz = vext_f32(vget_low_f32(vQ2), vget_high_f32(vQ2), 1); + vQ2xz = vext_f32(vQ2zx, vQ2zx, 1); + + A1 = vcombine_f32(vget_low_f32(vQ1), vQ1zx); // X Y z x + B1 = vcombine_f32(vdup_lane_f32(vget_high_f32(vQ2), 1), vQ2wx); // W W W X + + A2 = vcombine_f32(vQ1yz, vget_low_f32(vQ1)); + B2 = vcombine_f32(vQ2zx, vdup_lane_f32(vget_low_f32(vQ2), 1)); + + A3 = vcombine_f32(vQ1zx, vQ1yz); // Z X Y Z + B3 = vcombine_f32(vQ2yz, vQ2xz); // Y Z x z + + A1 = vmulq_f32(A1, B1); + A2 = vmulq_f32(A2, B2); + A3 = vmulq_f32(A3, B3); // A3 *= B3 + + A1 = vaddq_f32(A1, A2); // AB12 = AB1 + AB2 + + // change the sign of the last element + A1 = (btSimdFloat4)veorq_s32((int32x4_t)A1, (int32x4_t)vPPPM); + + A1 = vsubq_f32(A1, A3); // AB123 = AB12 - AB3 + + return btQuaternion(A1); + +#else + return btQuaternion( + +w.x() * q.w() + w.y() * q.z() - w.z() * q.y(), + +w.y() * q.w() + w.z() * q.x() - w.x() * q.z(), + +w.z() * q.w() + w.x() * q.y() - w.y() * q.x(), + -w.x() * q.x() - w.y() * q.y() - w.z() * q.z()); +#endif +} + +/**@brief Calculate the dot product between two quaternions */ +SIMD_FORCE_INLINE btScalar +dot(const btQuaternion& q1, const btQuaternion& q2) +{ + return q1.dot(q2); +} + +/**@brief Return the length of a quaternion */ +SIMD_FORCE_INLINE btScalar +length(const btQuaternion& q) +{ + return q.length(); +} + +/**@brief Return the angle between two quaternions*/ +SIMD_FORCE_INLINE btScalar +btAngle(const btQuaternion& q1, const btQuaternion& q2) +{ + return q1.angle(q2); +} + +/**@brief Return the inverse of a quaternion*/ +SIMD_FORCE_INLINE btQuaternion +inverse(const btQuaternion& q) +{ + return q.inverse(); +} + +/**@brief Return the result of spherical linear interpolation betwen two quaternions + * @param q1 The first quaternion + * @param q2 The second quaternion + * @param t The ration between q1 and q2. t = 0 return q1, t=1 returns q2 + * Slerp assumes constant velocity between positions. */ +SIMD_FORCE_INLINE btQuaternion +slerp(const btQuaternion& q1, const btQuaternion& q2, const btScalar& t) +{ + return q1.slerp(q2, t); +} + +SIMD_FORCE_INLINE btVector3 +quatRotate(const btQuaternion& rotation, const btVector3& v) +{ + btQuaternion q = rotation * v; + q *= rotation.inverse(); +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + return btVector3(_mm_and_ps(q.get128(), btvFFF0fMask)); +#elif defined(BT_USE_NEON) + return btVector3((float32x4_t)vandq_s32((int32x4_t)q.get128(), btvFFF0Mask)); +#else + return btVector3(q.getX(), q.getY(), q.getZ()); +#endif +} + +SIMD_FORCE_INLINE btQuaternion +shortestArcQuat(const btVector3& v0, const btVector3& v1) // Game Programming Gems 2.10. make sure v0,v1 are normalized +{ + btVector3 c = v0.cross(v1); + btScalar d = v0.dot(v1); + + if (d < -1.0 + SIMD_EPSILON) + { + btVector3 n, unused; + btPlaneSpace1(v0, n, unused); + return btQuaternion(n.x(), n.y(), n.z(), 0.0f); // just pick any vector that is orthogonal to v0 + } + + btScalar s = btSqrt((1.0f + d) * 2.0f); + btScalar rs = 1.0f / s; + + return btQuaternion(c.getX() * rs, c.getY() * rs, c.getZ() * rs, s * 0.5f); +} + +SIMD_FORCE_INLINE btQuaternion +shortestArcQuatNormalize2(btVector3& v0, btVector3& v1) +{ + v0.normalize(); + v1.normalize(); + return shortestArcQuat(v0, v1); +} + +struct btQuaternionFloatData +{ + float m_floats[4]; +}; + +struct btQuaternionDoubleData +{ + double m_floats[4]; +}; + +SIMD_FORCE_INLINE void btQuaternion::serializeFloat(struct btQuaternionFloatData& dataOut) const +{ + ///could also do a memcpy, check if it is worth it + for (int i = 0; i < 4; i++) + dataOut.m_floats[i] = float(m_floats[i]); +} + +SIMD_FORCE_INLINE void btQuaternion::deSerializeFloat(const struct btQuaternionFloatData& dataIn) +{ + for (int i = 0; i < 4; i++) + m_floats[i] = btScalar(dataIn.m_floats[i]); +} + +SIMD_FORCE_INLINE void btQuaternion::serializeDouble(struct btQuaternionDoubleData& dataOut) const +{ + ///could also do a memcpy, check if it is worth it + for (int i = 0; i < 4; i++) + dataOut.m_floats[i] = double(m_floats[i]); +} + +SIMD_FORCE_INLINE void btQuaternion::deSerializeDouble(const struct btQuaternionDoubleData& dataIn) +{ + for (int i = 0; i < 4; i++) + m_floats[i] = btScalar(dataIn.m_floats[i]); +} + +SIMD_FORCE_INLINE void btQuaternion::serialize(struct btQuaternionData& dataOut) const +{ + ///could also do a memcpy, check if it is worth it + for (int i = 0; i < 4; i++) + dataOut.m_floats[i] = m_floats[i]; +} + +SIMD_FORCE_INLINE void btQuaternion::deSerialize(const struct btQuaternionFloatData& dataIn) +{ + for (int i = 0; i < 4; i++) + m_floats[i] = (btScalar)dataIn.m_floats[i]; +} + +SIMD_FORCE_INLINE void btQuaternion::deSerialize(const struct btQuaternionDoubleData& dataIn) +{ + for (int i = 0; i < 4; i++) + m_floats[i] = (btScalar)dataIn.m_floats[i]; +} + +#endif //BT_SIMD__QUATERNION_H_ diff --git a/pkg/mphysics/mbt/LinearMath/btQuaternion.h.i b/pkg/mphysics/mbt/LinearMath/btQuaternion.h.i new file mode 100644 index 00000000..64fd4676 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btQuaternion.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btQuaternion.h ---------------- + +%include "LinearMath/btQuaternion.h" + +%{ +#include "LinearMath/btQuaternion.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btQuickprof.cpp b/pkg/mphysics/mbt/LinearMath/btQuickprof.cpp new file mode 100644 index 00000000..33b51eb7 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btQuickprof.cpp @@ -0,0 +1,805 @@ +/* + +*************************************************************************************************** +** +** profile.cpp +** +** Real-Time Hierarchical Profiling for Game Programming Gems 3 +** +** by Greg Hjelstrom & Byon Garrabrant +** +***************************************************************************************************/ + +// Credits: The Clock class was inspired by the Timer classes in +// Ogre (www.ogre3d.org). + +#include "btQuickprof.h" +#include "btThreads.h" + +#ifdef __CELLOS_LV2__ +#include +#include +#include +#endif + +#if defined(SUNOS) || defined(__SUNOS__) +#include +#endif +#ifdef __APPLE__ +#include +#include +#endif + +#if defined(WIN32) || defined(_WIN32) + +#define BT_USE_WINDOWS_TIMERS +#define WIN32_LEAN_AND_MEAN +#define NOWINRES +#define NOMCX +#define NOIME + +#ifdef _XBOX +#include +#else //_XBOX +#include + +#if WINVER < 0x0602 +#define GetTickCount64 GetTickCount +#endif + +#endif //_XBOX + +#include + +#else //_WIN32 +#include + +#ifdef BT_LINUX_REALTIME +//required linking against rt (librt) +#include +#endif //BT_LINUX_REALTIME + +#endif //_WIN32 + +#define mymin(a, b) (a > b ? a : b) + +struct btClockData +{ +#ifdef BT_USE_WINDOWS_TIMERS + LARGE_INTEGER mClockFrequency; + LONGLONG mStartTick; + LARGE_INTEGER mStartTime; +#else +#ifdef __CELLOS_LV2__ + uint64_t mStartTime; +#else +#ifdef __APPLE__ + uint64_t mStartTimeNano; +#endif + struct timeval mStartTime; +#endif +#endif //__CELLOS_LV2__ +}; + +///The btClock is a portable basic clock that measures accurate time in seconds, use for profiling. +btClock::btClock() +{ + m_data = new btClockData; +#ifdef BT_USE_WINDOWS_TIMERS + QueryPerformanceFrequency(&m_data->mClockFrequency); +#endif + reset(); +} + +btClock::~btClock() +{ + delete m_data; +} + +btClock::btClock(const btClock& other) +{ + m_data = new btClockData; + *m_data = *other.m_data; +} + +btClock& btClock::operator=(const btClock& other) +{ + *m_data = *other.m_data; + return *this; +} + +/// Resets the initial reference time. +void btClock::reset() +{ +#ifdef BT_USE_WINDOWS_TIMERS + QueryPerformanceCounter(&m_data->mStartTime); + m_data->mStartTick = GetTickCount64(); +#else +#ifdef __CELLOS_LV2__ + + typedef uint64_t ClockSize; + ClockSize newTime; + //__asm __volatile__( "mftb %0" : "=r" (newTime) : : "memory"); + SYS_TIMEBASE_GET(newTime); + m_data->mStartTime = newTime; +#else +#ifdef __APPLE__ + m_data->mStartTimeNano = mach_absolute_time(); +#endif + gettimeofday(&m_data->mStartTime, 0); +#endif +#endif +} + +/// Returns the time in ms since the last call to reset or since +/// the btClock was created. +unsigned long long int btClock::getTimeMilliseconds() +{ +#ifdef BT_USE_WINDOWS_TIMERS + LARGE_INTEGER currentTime; + QueryPerformanceCounter(¤tTime); + LONGLONG elapsedTime = currentTime.QuadPart - + m_data->mStartTime.QuadPart; + // Compute the number of millisecond ticks elapsed. + unsigned long msecTicks = (unsigned long)(1000 * elapsedTime / + m_data->mClockFrequency.QuadPart); + + return msecTicks; +#else + +#ifdef __CELLOS_LV2__ + uint64_t freq = sys_time_get_timebase_frequency(); + double dFreq = ((double)freq) / 1000.0; + typedef uint64_t ClockSize; + ClockSize newTime; + SYS_TIMEBASE_GET(newTime); + //__asm __volatile__( "mftb %0" : "=r" (newTime) : : "memory"); + + return (unsigned long int)((double(newTime - m_data->mStartTime)) / dFreq); +#else + + struct timeval currentTime; + gettimeofday(¤tTime, 0); + return (currentTime.tv_sec - m_data->mStartTime.tv_sec) * 1000 + + (currentTime.tv_usec - m_data->mStartTime.tv_usec) / 1000; +#endif //__CELLOS_LV2__ +#endif +} + +/// Returns the time in us since the last call to reset or since +/// the Clock was created. +unsigned long long int btClock::getTimeMicroseconds() +{ +#ifdef BT_USE_WINDOWS_TIMERS + //see https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx + LARGE_INTEGER currentTime, elapsedTime; + + QueryPerformanceCounter(¤tTime); + elapsedTime.QuadPart = currentTime.QuadPart - + m_data->mStartTime.QuadPart; + elapsedTime.QuadPart *= 1000000; + elapsedTime.QuadPart /= m_data->mClockFrequency.QuadPart; + + return (unsigned long long)elapsedTime.QuadPart; +#else + +#ifdef __CELLOS_LV2__ + uint64_t freq = sys_time_get_timebase_frequency(); + double dFreq = ((double)freq) / 1000000.0; + typedef uint64_t ClockSize; + ClockSize newTime; + //__asm __volatile__( "mftb %0" : "=r" (newTime) : : "memory"); + SYS_TIMEBASE_GET(newTime); + + return (unsigned long int)((double(newTime - m_data->mStartTime)) / dFreq); +#else + + struct timeval currentTime; + gettimeofday(¤tTime, 0); + return (currentTime.tv_sec - m_data->mStartTime.tv_sec) * 1000000 + + (currentTime.tv_usec - m_data->mStartTime.tv_usec); +#endif //__CELLOS_LV2__ +#endif +} + +unsigned long long int btClock::getTimeNanoseconds() +{ +#ifdef BT_USE_WINDOWS_TIMERS + //see https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx + LARGE_INTEGER currentTime, elapsedTime; + + QueryPerformanceCounter(¤tTime); + elapsedTime.QuadPart = currentTime.QuadPart - + m_data->mStartTime.QuadPart; + elapsedTime.QuadPart *= 1000000000; + elapsedTime.QuadPart /= m_data->mClockFrequency.QuadPart; + + return (unsigned long long)elapsedTime.QuadPart; +#else + +#ifdef __CELLOS_LV2__ + uint64_t freq = sys_time_get_timebase_frequency(); + double dFreq = ((double)freq) / 1e9; + typedef uint64_t ClockSize; + ClockSize newTime; + //__asm __volatile__( "mftb %0" : "=r" (newTime) : : "memory"); + SYS_TIMEBASE_GET(newTime); + + return (unsigned long int)((double(newTime - m_data->mStartTime)) / dFreq); +#else +#ifdef __APPLE__ + uint64_t ticks = mach_absolute_time() - m_data->mStartTimeNano; + static long double conversion = 0.0L; + if (0.0L == conversion) + { + // attempt to get conversion to nanoseconds + mach_timebase_info_data_t info; + int err = mach_timebase_info(&info); + if (err) + { + btAssert(0); + conversion = 1.; + } + conversion = info.numer / info.denom; + } + return (ticks * conversion); + +#else //__APPLE__ + +#ifdef BT_LINUX_REALTIME + timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + return 1000000000 * ts.tv_sec + ts.tv_nsec; +#else + struct timeval currentTime; + gettimeofday(¤tTime, 0); + return (currentTime.tv_sec - m_data->mStartTime.tv_sec) * 1e9 + + (currentTime.tv_usec - m_data->mStartTime.tv_usec) * 1000; +#endif //BT_LINUX_REALTIME + +#endif //__APPLE__ +#endif //__CELLOS_LV2__ +#endif +} + +/// Returns the time in s since the last call to reset or since +/// the Clock was created. +btScalar btClock::getTimeSeconds() +{ + static const btScalar microseconds_to_seconds = btScalar(0.000001); + return btScalar(getTimeMicroseconds()) * microseconds_to_seconds; +} + +#ifndef BT_NO_PROFILE + +static btClock gProfileClock; + +inline void Profile_Get_Ticks(unsigned long int* ticks) +{ + *ticks = (unsigned long int)gProfileClock.getTimeMicroseconds(); +} + +inline float Profile_Get_Tick_Rate(void) +{ + // return 1000000.f; + return 1000.f; +} + +/*************************************************************************************************** +** +** CProfileNode +** +***************************************************************************************************/ + +/*********************************************************************************************** + * INPUT: * + * name - pointer to a static string which is the name of this profile node * + * parent - parent pointer * + * * + * WARNINGS: * + * The name is assumed to be a static pointer, only the pointer is stored and compared for * + * efficiency reasons. * + *=============================================================================================*/ +CProfileNode::CProfileNode(const char* name, CProfileNode* parent) : Name(name), + TotalCalls(0), + TotalTime(0), + StartTime(0), + RecursionCounter(0), + Parent(parent), + Child(NULL), + Sibling(NULL), + m_userPtr(0) +{ + Reset(); +} + +void CProfileNode::CleanupMemory() +{ + delete (Child); + Child = NULL; + delete (Sibling); + Sibling = NULL; +} + +CProfileNode::~CProfileNode(void) +{ + CleanupMemory(); +} + +/*********************************************************************************************** + * INPUT: * + * name - static string pointer to the name of the node we are searching for * + * * + * WARNINGS: * + * All profile names are assumed to be static strings so this function uses pointer compares * + * to find the named node. * + *=============================================================================================*/ +CProfileNode* CProfileNode::Get_Sub_Node(const char* name) +{ + // Try to find this sub node + CProfileNode* child = Child; + while (child) + { + if (child->Name == name) + { + return child; + } + child = child->Sibling; + } + + // We didn't find it, so add it + + CProfileNode* node = new CProfileNode(name, this); + node->Sibling = Child; + Child = node; + return node; +} + +void CProfileNode::Reset(void) +{ + TotalCalls = 0; + TotalTime = 0.0f; + + if (Child) + { + Child->Reset(); + } + if (Sibling) + { + Sibling->Reset(); + } +} + +void CProfileNode::Call(void) +{ + TotalCalls++; + if (RecursionCounter++ == 0) + { + Profile_Get_Ticks(&StartTime); + } +} + +bool CProfileNode::Return(void) +{ + if (--RecursionCounter == 0 && TotalCalls != 0) + { + unsigned long int time; + Profile_Get_Ticks(&time); + + time -= StartTime; + TotalTime += (float)time / Profile_Get_Tick_Rate(); + } + return (RecursionCounter == 0); +} + +/*************************************************************************************************** +** +** CProfileIterator +** +***************************************************************************************************/ +CProfileIterator::CProfileIterator(CProfileNode* start) +{ + CurrentParent = start; + CurrentChild = CurrentParent->Get_Child(); +} + +void CProfileIterator::First(void) +{ + CurrentChild = CurrentParent->Get_Child(); +} + +void CProfileIterator::Next(void) +{ + CurrentChild = CurrentChild->Get_Sibling(); +} + +bool CProfileIterator::Is_Done(void) +{ + return CurrentChild == NULL; +} + +void CProfileIterator::Enter_Child(int index) +{ + CurrentChild = CurrentParent->Get_Child(); + while ((CurrentChild != NULL) && (index != 0)) + { + index--; + CurrentChild = CurrentChild->Get_Sibling(); + } + + if (CurrentChild != NULL) + { + CurrentParent = CurrentChild; + CurrentChild = CurrentParent->Get_Child(); + } +} + +void CProfileIterator::Enter_Parent(void) +{ + if (CurrentParent->Get_Parent() != NULL) + { + CurrentParent = CurrentParent->Get_Parent(); + } + CurrentChild = CurrentParent->Get_Child(); +} + +/*************************************************************************************************** +** +** CProfileManager +** +***************************************************************************************************/ + +CProfileNode gRoots[BT_QUICKPROF_MAX_THREAD_COUNT] = { + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), + CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL), CProfileNode("Root", NULL)}; + +CProfileNode* gCurrentNodes[BT_QUICKPROF_MAX_THREAD_COUNT] = + { + &gRoots[0], + &gRoots[1], + &gRoots[2], + &gRoots[3], + &gRoots[4], + &gRoots[5], + &gRoots[6], + &gRoots[7], + &gRoots[8], + &gRoots[9], + &gRoots[10], + &gRoots[11], + &gRoots[12], + &gRoots[13], + &gRoots[14], + &gRoots[15], + &gRoots[16], + &gRoots[17], + &gRoots[18], + &gRoots[19], + &gRoots[20], + &gRoots[21], + &gRoots[22], + &gRoots[23], + &gRoots[24], + &gRoots[25], + &gRoots[26], + &gRoots[27], + &gRoots[28], + &gRoots[29], + &gRoots[30], + &gRoots[31], + &gRoots[32], + &gRoots[33], + &gRoots[34], + &gRoots[35], + &gRoots[36], + &gRoots[37], + &gRoots[38], + &gRoots[39], + &gRoots[40], + &gRoots[41], + &gRoots[42], + &gRoots[43], + &gRoots[44], + &gRoots[45], + &gRoots[46], + &gRoots[47], + &gRoots[48], + &gRoots[49], + &gRoots[50], + &gRoots[51], + &gRoots[52], + &gRoots[53], + &gRoots[54], + &gRoots[55], + &gRoots[56], + &gRoots[57], + &gRoots[58], + &gRoots[59], + &gRoots[60], + &gRoots[61], + &gRoots[62], + &gRoots[63], +}; + +int CProfileManager::FrameCounter = 0; +unsigned long int CProfileManager::ResetTime = 0; + +CProfileIterator* CProfileManager::Get_Iterator(void) +{ + int threadIndex = btQuickprofGetCurrentThreadIndex2(); + if ((threadIndex < 0) || threadIndex >= BT_QUICKPROF_MAX_THREAD_COUNT) + return 0; + + return new CProfileIterator(&gRoots[threadIndex]); +} + +void CProfileManager::CleanupMemory(void) +{ + for (int i = 0; i < BT_QUICKPROF_MAX_THREAD_COUNT; i++) + { + gRoots[i].CleanupMemory(); + } +} + +/*********************************************************************************************** + * CProfileManager::Start_Profile -- Begin a named profile * + * * + * Steps one level deeper into the tree, if a child already exists with the specified name * + * then it accumulates the profiling; otherwise a new child node is added to the profile tree. * + * * + * INPUT: * + * name - name of this profiling record * + * * + * WARNINGS: * + * The string used is assumed to be a static string; pointer compares are used throughout * + * the profiling code for efficiency. * + *=============================================================================================*/ +void CProfileManager::Start_Profile(const char* name) +{ + int threadIndex = btQuickprofGetCurrentThreadIndex2(); + if ((threadIndex < 0) || threadIndex >= BT_QUICKPROF_MAX_THREAD_COUNT) + return; + + if (name != gCurrentNodes[threadIndex]->Get_Name()) + { + gCurrentNodes[threadIndex] = gCurrentNodes[threadIndex]->Get_Sub_Node(name); + } + + gCurrentNodes[threadIndex]->Call(); +} + +/*********************************************************************************************** + * CProfileManager::Stop_Profile -- Stop timing and record the results. * + *=============================================================================================*/ +void CProfileManager::Stop_Profile(void) +{ + int threadIndex = btQuickprofGetCurrentThreadIndex2(); + if ((threadIndex < 0) || threadIndex >= BT_QUICKPROF_MAX_THREAD_COUNT) + return; + + // Return will indicate whether we should back up to our parent (we may + // be profiling a recursive function) + if (gCurrentNodes[threadIndex]->Return()) + { + gCurrentNodes[threadIndex] = gCurrentNodes[threadIndex]->Get_Parent(); + } +} + +/*********************************************************************************************** + * CProfileManager::Reset -- Reset the contents of the profiling system * + * * + * This resets everything except for the tree structure. All of the timing data is reset. * + *=============================================================================================*/ +void CProfileManager::Reset(void) +{ + gProfileClock.reset(); + int threadIndex = btQuickprofGetCurrentThreadIndex2(); + if ((threadIndex < 0) || threadIndex >= BT_QUICKPROF_MAX_THREAD_COUNT) + return; + gRoots[threadIndex].Reset(); + gRoots[threadIndex].Call(); + FrameCounter = 0; + Profile_Get_Ticks(&ResetTime); +} + +/*********************************************************************************************** + * CProfileManager::Increment_Frame_Counter -- Increment the frame counter * + *=============================================================================================*/ +void CProfileManager::Increment_Frame_Counter(void) +{ + FrameCounter++; +} + +/*********************************************************************************************** + * CProfileManager::Get_Time_Since_Reset -- returns the elapsed time since last reset * + *=============================================================================================*/ +float CProfileManager::Get_Time_Since_Reset(void) +{ + unsigned long int time; + Profile_Get_Ticks(&time); + time -= ResetTime; + return (float)time / Profile_Get_Tick_Rate(); +} + +#include + +void CProfileManager::dumpRecursive(CProfileIterator* profileIterator, int spacing) +{ + profileIterator->First(); + if (profileIterator->Is_Done()) + return; + + float accumulated_time = 0, parent_time = profileIterator->Is_Root() ? CProfileManager::Get_Time_Since_Reset() : profileIterator->Get_Current_Parent_Total_Time(); + int i; + int frames_since_reset = CProfileManager::Get_Frame_Count_Since_Reset(); + for (i = 0; i < spacing; i++) printf("."); + printf("----------------------------------\n"); + for (i = 0; i < spacing; i++) printf("."); + printf("Profiling: %s (total running time: %.3f ms) ---\n", profileIterator->Get_Current_Parent_Name(), parent_time); + float totalTime = 0.f; + + int numChildren = 0; + + for (i = 0; !profileIterator->Is_Done(); i++, profileIterator->Next()) + { + numChildren++; + float current_total_time = profileIterator->Get_Current_Total_Time(); + accumulated_time += current_total_time; + float fraction = parent_time > SIMD_EPSILON ? (current_total_time / parent_time) * 100 : 0.f; + { + int i; + for (i = 0; i < spacing; i++) printf("."); + } + printf("%d -- %s (%.2f %%) :: %.3f ms / frame (%d calls)\n", i, profileIterator->Get_Current_Name(), fraction, (current_total_time / (double)frames_since_reset), profileIterator->Get_Current_Total_Calls()); + totalTime += current_total_time; + //recurse into children + } + + if (parent_time < accumulated_time) + { + //printf("what's wrong\n"); + } + for (i = 0; i < spacing; i++) printf("."); + printf("%s (%.3f %%) :: %.3f ms\n", "Unaccounted:", parent_time > SIMD_EPSILON ? ((parent_time - accumulated_time) / parent_time) * 100 : 0.f, parent_time - accumulated_time); + + for (i = 0; i < numChildren; i++) + { + profileIterator->Enter_Child(i); + dumpRecursive(profileIterator, spacing + 3); + profileIterator->Enter_Parent(); + } +} + +void CProfileManager::dumpAll() +{ + CProfileIterator* profileIterator = 0; + profileIterator = CProfileManager::Get_Iterator(); + + dumpRecursive(profileIterator, 0); + + CProfileManager::Release_Iterator(profileIterator); +} + + +void btEnterProfileZoneDefault(const char* name) +{ +} +void btLeaveProfileZoneDefault() +{ +} + +#else +void btEnterProfileZoneDefault(const char* name) +{ +} +void btLeaveProfileZoneDefault() +{ +} +#endif //BT_NO_PROFILE + + +// clang-format off +#if defined(_WIN32) && (defined(__MINGW32__) || defined(__MINGW64__)) + #define BT_HAVE_TLS 1 +#elif __APPLE__ && !TARGET_OS_IPHONE + // TODO: Modern versions of iOS support TLS now with updated version checking. + #define BT_HAVE_TLS 1 +#elif __linux__ + #define BT_HAVE_TLS 1 +#elif defined(__FreeBSD__) || defined(__NetBSD__) + // TODO: At the moment disabling purposely OpenBSD, albeit tls support exists but not fully functioning + #define BT_HAVE_TLS 1 +#endif + +// __thread is broken on Andorid clang until r12b. See +// https://github.com/android-ndk/ndk/issues/8 +#if defined(__ANDROID__) && defined(__clang__) + #if __has_include() + #include + #endif // __has_include() + #if defined(__NDK_MAJOR__) && \ + ((__NDK_MAJOR__ < 12) || ((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1))) + #undef BT_HAVE_TLS + #endif +#endif // defined(__ANDROID__) && defined(__clang__) +// clang-format on + +unsigned int btQuickprofGetCurrentThreadIndex2() +{ + const unsigned int kNullIndex = ~0U; + +#if BT_THREADSAFE + return btGetCurrentThreadIndex(); +#else +#if defined(BT_HAVE_TLS) + static __thread unsigned int sThreadIndex = kNullIndex; +#elif defined(_WIN32) + __declspec(thread) static unsigned int sThreadIndex = kNullIndex; +#else + unsigned int sThreadIndex = 0; + return -1; +#endif + + static int gThreadCounter = 0; + + if (sThreadIndex == kNullIndex) + { + sThreadIndex = gThreadCounter++; + } + return sThreadIndex; +#endif //BT_THREADSAFE +} + +static btEnterProfileZoneFunc* bts_enterFunc = btEnterProfileZoneDefault; +static btLeaveProfileZoneFunc* bts_leaveFunc = btLeaveProfileZoneDefault; + +void btEnterProfileZone(const char* name) +{ + (bts_enterFunc)(name); +} +void btLeaveProfileZone() +{ + (bts_leaveFunc)(); +} + +btEnterProfileZoneFunc* btGetCurrentEnterProfileZoneFunc() +{ + return bts_enterFunc; +} +btLeaveProfileZoneFunc* btGetCurrentLeaveProfileZoneFunc() +{ + return bts_leaveFunc; +} + +void btSetCustomEnterProfileZoneFunc(btEnterProfileZoneFunc* enterFunc) +{ + bts_enterFunc = enterFunc; +} +void btSetCustomLeaveProfileZoneFunc(btLeaveProfileZoneFunc* leaveFunc) +{ + bts_leaveFunc = leaveFunc; +} + +CProfileSample::CProfileSample(const char* name) +{ + btEnterProfileZone(name); +} + +CProfileSample::~CProfileSample(void) +{ + btLeaveProfileZone(); +} diff --git a/pkg/mphysics/mbt/LinearMath/btQuickprof.cpp.i b/pkg/mphysics/mbt/LinearMath/btQuickprof.cpp.i new file mode 100644 index 00000000..c3cddc8d --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btQuickprof.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btQuickprof.cpp ---------------- + +%include "LinearMath/btQuickprof.cpp" + +%{ +#include "LinearMath/btQuickprof.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btQuickprof.h b/pkg/mphysics/mbt/LinearMath/btQuickprof.h new file mode 100644 index 00000000..990d401d --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btQuickprof.h @@ -0,0 +1,200 @@ + +/*************************************************************************************************** +** +** Real-Time Hierarchical Profiling for Game Programming Gems 3 +** +** by Greg Hjelstrom & Byon Garrabrant +** +***************************************************************************************************/ + +// Credits: The Clock class was inspired by the Timer classes in +// Ogre (www.ogre3d.org). + +#ifndef BT_QUICK_PROF_H +#define BT_QUICK_PROF_H + +#include "btScalar.h" +#define USE_BT_CLOCK 1 + +#ifdef USE_BT_CLOCK + +///The btClock is a portable basic clock that measures accurate time in seconds, use for profiling. +class btClock +{ +public: + btClock(); + + btClock(const btClock& other); + btClock& operator=(const btClock& other); + + ~btClock(); + + /// Resets the initial reference time. + void reset(); + + /// Returns the time in ms since the last call to reset or since + /// the btClock was created. + unsigned long long int getTimeMilliseconds(); + + /// Returns the time in us since the last call to reset or since + /// the Clock was created. + unsigned long long int getTimeMicroseconds(); + + unsigned long long int getTimeNanoseconds(); + + /// Returns the time in s since the last call to reset or since + /// the Clock was created. + btScalar getTimeSeconds(); + +private: + struct btClockData* m_data; +}; + +#endif //USE_BT_CLOCK + +typedef void(btEnterProfileZoneFunc)(const char* msg); +typedef void(btLeaveProfileZoneFunc)(); + +btEnterProfileZoneFunc* btGetCurrentEnterProfileZoneFunc(); +btLeaveProfileZoneFunc* btGetCurrentLeaveProfileZoneFunc(); + +void btSetCustomEnterProfileZoneFunc(btEnterProfileZoneFunc* enterFunc); +void btSetCustomLeaveProfileZoneFunc(btLeaveProfileZoneFunc* leaveFunc); + +#ifndef BT_ENABLE_PROFILE +#define BT_NO_PROFILE 1 +#endif //BT_NO_PROFILE + +const unsigned int BT_QUICKPROF_MAX_THREAD_COUNT = 64; + +//btQuickprofGetCurrentThreadIndex will return -1 if thread index cannot be determined, +//otherwise returns thread index in range [0..maxThreads] +unsigned int btQuickprofGetCurrentThreadIndex2(); + +#ifndef BT_NO_PROFILE + + +#include //@todo remove this, backwards compatibility + +#include "btAlignedAllocator.h" +#include + +///A node in the Profile Hierarchy Tree +class CProfileNode +{ +public: + CProfileNode(const char* name, CProfileNode* parent); + ~CProfileNode(void); + + CProfileNode* Get_Sub_Node(const char* name); + + CProfileNode* Get_Parent(void) { return Parent; } + CProfileNode* Get_Sibling(void) { return Sibling; } + CProfileNode* Get_Child(void) { return Child; } + + void CleanupMemory(); + void Reset(void); + void Call(void); + bool Return(void); + + const char* Get_Name(void) { return Name; } + int Get_Total_Calls(void) { return TotalCalls; } + float Get_Total_Time(void) { return TotalTime; } + void* GetUserPointer() const { return m_userPtr; } + void SetUserPointer(void* ptr) { m_userPtr = ptr; } + +protected: + const char* Name; + int TotalCalls; + float TotalTime; + unsigned long int StartTime; + int RecursionCounter; + + CProfileNode* Parent; + CProfileNode* Child; + CProfileNode* Sibling; + void* m_userPtr; +}; + +///An iterator to navigate through the tree +class CProfileIterator +{ +public: + // Access all the children of the current parent + void First(void); + void Next(void); + bool Is_Done(void); + bool Is_Root(void) { return (CurrentParent->Get_Parent() == 0); } + + void Enter_Child(int index); // Make the given child the new parent + void Enter_Largest_Child(void); // Make the largest child the new parent + void Enter_Parent(void); // Make the current parent's parent the new parent + + // Access the current child + const char* Get_Current_Name(void) { return CurrentChild->Get_Name(); } + int Get_Current_Total_Calls(void) { return CurrentChild->Get_Total_Calls(); } + float Get_Current_Total_Time(void) { return CurrentChild->Get_Total_Time(); } + + void* Get_Current_UserPointer(void) { return CurrentChild->GetUserPointer(); } + void Set_Current_UserPointer(void* ptr) { CurrentChild->SetUserPointer(ptr); } + // Access the current parent + const char* Get_Current_Parent_Name(void) { return CurrentParent->Get_Name(); } + int Get_Current_Parent_Total_Calls(void) { return CurrentParent->Get_Total_Calls(); } + float Get_Current_Parent_Total_Time(void) { return CurrentParent->Get_Total_Time(); } + +protected: + CProfileNode* CurrentParent; + CProfileNode* CurrentChild; + + CProfileIterator(CProfileNode* start); + friend class CProfileManager; +}; + +///The Manager for the Profile system +class CProfileManager +{ +public: + static void Start_Profile(const char* name); + static void Stop_Profile(void); + + static void CleanupMemory(void); + // { + // Root.CleanupMemory(); + // } + + static void Reset(void); + static void Increment_Frame_Counter(void); + static int Get_Frame_Count_Since_Reset(void) { return FrameCounter; } + static float Get_Time_Since_Reset(void); + + static CProfileIterator* Get_Iterator(void); + // { + // + // return new CProfileIterator( &Root ); + // } + static void Release_Iterator(CProfileIterator* iterator) { delete (iterator); } + + static void dumpRecursive(CProfileIterator* profileIterator, int spacing); + + static void dumpAll(); + +private: + static int FrameCounter; + static unsigned long int ResetTime; +}; + +#endif //#ifndef BT_NO_PROFILE + +///ProfileSampleClass is a simple way to profile a function's scope +///Use the BT_PROFILE macro at the start of scope to time +class CProfileSample +{ +public: + CProfileSample(const char* name); + + ~CProfileSample(void); +}; + +#define BT_PROFILE(name) CProfileSample __profile(name) + +#endif //BT_QUICK_PROF_H diff --git a/pkg/mphysics/mbt/LinearMath/btQuickprof.h.i b/pkg/mphysics/mbt/LinearMath/btQuickprof.h.i new file mode 100644 index 00000000..0ae4d2d5 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btQuickprof.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btQuickprof.h ---------------- + +%include "LinearMath/btQuickprof.h" + +%{ +#include "LinearMath/btQuickprof.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btRandom.h b/pkg/mphysics/mbt/LinearMath/btRandom.h new file mode 100644 index 00000000..77531300 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btRandom.h @@ -0,0 +1,39 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_GEN_RANDOM_H +#define BT_GEN_RANDOM_H + +#ifdef MT19937 + +#include +#include + +#define GEN_RAND_MAX UINT_MAX + +SIMD_FORCE_INLINE void GEN_srand(unsigned int seed) { init_genrand(seed); } +SIMD_FORCE_INLINE unsigned int GEN_rand() { return genrand_int32(); } + +#else + +#include + +#define GEN_RAND_MAX RAND_MAX + +SIMD_FORCE_INLINE void GEN_srand(unsigned int seed) { srand(seed); } +SIMD_FORCE_INLINE unsigned int GEN_rand() { return rand(); } + +#endif + +#endif //BT_GEN_RANDOM_H diff --git a/pkg/mphysics/mbt/LinearMath/btRandom.h.i b/pkg/mphysics/mbt/LinearMath/btRandom.h.i new file mode 100644 index 00000000..e6410852 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btRandom.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btRandom.h ---------------- + +%include "LinearMath/btRandom.h" + +%{ +#include "LinearMath/btRandom.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btReducedVector.cpp b/pkg/mphysics/mbt/LinearMath/btReducedVector.cpp new file mode 100644 index 00000000..1539584e --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btReducedVector.cpp @@ -0,0 +1,170 @@ +// +// btReducedVector.cpp +// LinearMath +// +// Created by Xuchen Han on 4/4/20. +// +#include +#include "btReducedVector.h" +#include + +// returns the projection of this onto other +btReducedVector btReducedVector::proj(const btReducedVector& other) const +{ + btReducedVector ret(m_sz); + btScalar other_length2 = other.length2(); + if (other_length2 < SIMD_EPSILON) + { + return ret; + } + return other*(this->dot(other))/other_length2; +} + +void btReducedVector::normalize() +{ + if (this->length2() < SIMD_EPSILON) + { + m_indices.clear(); + m_vecs.clear(); + return; + } + *this /= std::sqrt(this->length2()); +} + +bool btReducedVector::testAdd() const +{ + int sz = 5; + btAlignedObjectArray id1; + id1.push_back(1); + id1.push_back(3); + btAlignedObjectArray v1; + v1.push_back(btVector3(1,0,1)); + v1.push_back(btVector3(3,1,5)); + btAlignedObjectArray id2; + id2.push_back(2); + id2.push_back(3); + id2.push_back(5); + btAlignedObjectArray v2; + v2.push_back(btVector3(2,3,1)); + v2.push_back(btVector3(3,4,9)); + v2.push_back(btVector3(0,4,0)); + btAlignedObjectArray id3; + id3.push_back(1); + id3.push_back(2); + id3.push_back(3); + id3.push_back(5); + btAlignedObjectArray v3; + v3.push_back(btVector3(1,0,1)); + v3.push_back(btVector3(2,3,1)); + v3.push_back(btVector3(6,5,14)); + v3.push_back(btVector3(0,4,0)); + btReducedVector rv1(sz, id1, v1); + btReducedVector rv2(sz, id2, v2); + btReducedVector ans(sz, id3, v3); + bool ret = ((ans == rv1+rv2) && (ans == rv2+rv1)); + if (!ret) + printf("btReducedVector testAdd failed\n"); + return ret; +} + +bool btReducedVector::testMinus() const +{ + int sz = 5; + btAlignedObjectArray id1; + id1.push_back(1); + id1.push_back(3); + btAlignedObjectArray v1; + v1.push_back(btVector3(1,0,1)); + v1.push_back(btVector3(3,1,5)); + btAlignedObjectArray id2; + id2.push_back(2); + id2.push_back(3); + id2.push_back(5); + btAlignedObjectArray v2; + v2.push_back(btVector3(2,3,1)); + v2.push_back(btVector3(3,4,9)); + v2.push_back(btVector3(0,4,0)); + btAlignedObjectArray id3; + id3.push_back(1); + id3.push_back(2); + id3.push_back(3); + id3.push_back(5); + btAlignedObjectArray v3; + v3.push_back(btVector3(-1,-0,-1)); + v3.push_back(btVector3(2,3,1)); + v3.push_back(btVector3(0,3,4)); + v3.push_back(btVector3(0,4,0)); + btReducedVector rv1(sz, id1, v1); + btReducedVector rv2(sz, id2, v2); + btReducedVector ans(sz, id3, v3); + bool ret = (ans == rv2-rv1); + if (!ret) + printf("btReducedVector testMinus failed\n"); + return ret; +} + +bool btReducedVector::testDot() const +{ + int sz = 5; + btAlignedObjectArray id1; + id1.push_back(1); + id1.push_back(3); + btAlignedObjectArray v1; + v1.push_back(btVector3(1,0,1)); + v1.push_back(btVector3(3,1,5)); + btAlignedObjectArray id2; + id2.push_back(2); + id2.push_back(3); + id2.push_back(5); + btAlignedObjectArray v2; + v2.push_back(btVector3(2,3,1)); + v2.push_back(btVector3(3,4,9)); + v2.push_back(btVector3(0,4,0)); + btReducedVector rv1(sz, id1, v1); + btReducedVector rv2(sz, id2, v2); + btScalar ans = 58; + bool ret = (ans == rv2.dot(rv1) && ans == rv1.dot(rv2)); + ans = 14+16+9+16+81; + ret &= (ans==rv2.dot(rv2)); + + if (!ret) + printf("btReducedVector testDot failed\n"); + return ret; +} + +bool btReducedVector::testMultiply() const +{ + int sz = 5; + btAlignedObjectArray id1; + id1.push_back(1); + id1.push_back(3); + btAlignedObjectArray v1; + v1.push_back(btVector3(1,0,1)); + v1.push_back(btVector3(3,1,5)); + btScalar s = 2; + btReducedVector rv1(sz, id1, v1); + btAlignedObjectArray id2; + id2.push_back(1); + id2.push_back(3); + btAlignedObjectArray v2; + v2.push_back(btVector3(2,0,2)); + v2.push_back(btVector3(6,2,10)); + btReducedVector ans(sz, id2, v2); + bool ret = (ans == rv1*s); + if (!ret) + printf("btReducedVector testMultiply failed\n"); + return ret; +} + +void btReducedVector::test() const +{ + bool ans = testAdd() && testMinus() && testDot() && testMultiply(); + if (ans) + { + printf("All tests passed\n"); + } + else + { + printf("Tests failed\n"); + } +} diff --git a/pkg/mphysics/mbt/LinearMath/btReducedVector.cpp.i b/pkg/mphysics/mbt/LinearMath/btReducedVector.cpp.i new file mode 100644 index 00000000..2ddd07fd --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btReducedVector.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btReducedVector.cpp ---------------- + +%include "LinearMath/btReducedVector.cpp" + +%{ +#include "LinearMath/btReducedVector.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btReducedVector.h b/pkg/mphysics/mbt/LinearMath/btReducedVector.h new file mode 100644 index 00000000..313a4271 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btReducedVector.h @@ -0,0 +1,320 @@ +// +// btReducedVectors.h +// BulletLinearMath +// +// Created by Xuchen Han on 4/4/20. +// +#ifndef btReducedVectors_h +#define btReducedVectors_h +#include "btVector3.h" +#include "btMatrix3x3.h" +#include "btAlignedObjectArray.h" +#include +#include +#include +struct TwoInts +{ + int a,b; +}; +inline bool operator<(const TwoInts& A, const TwoInts& B) +{ + return A.b < B.b; +} + + +// A helper vector type used for CG projections +class btReducedVector +{ +public: + btAlignedObjectArray m_indices; + btAlignedObjectArray m_vecs; + int m_sz; // all m_indices value < m_sz +public: + btReducedVector():m_sz(0) + { + m_indices.resize(0); + m_vecs.resize(0); + m_indices.clear(); + m_vecs.clear(); + } + + btReducedVector(int sz): m_sz(sz) + { + m_indices.resize(0); + m_vecs.resize(0); + m_indices.clear(); + m_vecs.clear(); + } + + btReducedVector(int sz, const btAlignedObjectArray& indices, const btAlignedObjectArray& vecs): m_sz(sz), m_indices(indices), m_vecs(vecs) + { + } + + void simplify() + { + btAlignedObjectArray old_indices(m_indices); + btAlignedObjectArray old_vecs(m_vecs); + m_indices.resize(0); + m_vecs.resize(0); + m_indices.clear(); + m_vecs.clear(); + for (int i = 0; i < old_indices.size(); ++i) + { + if (old_vecs[i].length2() > SIMD_EPSILON) + { + m_indices.push_back(old_indices[i]); + m_vecs.push_back(old_vecs[i]); + } + } + } + + btReducedVector operator+(const btReducedVector& other) + { + btReducedVector ret(m_sz); + int i=0, j=0; + while (i < m_indices.size() && j < other.m_indices.size()) + { + if (m_indices[i] < other.m_indices[j]) + { + ret.m_indices.push_back(m_indices[i]); + ret.m_vecs.push_back(m_vecs[i]); + ++i; + } + else if (m_indices[i] > other.m_indices[j]) + { + ret.m_indices.push_back(other.m_indices[j]); + ret.m_vecs.push_back(other.m_vecs[j]); + ++j; + } + else + { + ret.m_indices.push_back(other.m_indices[j]); + ret.m_vecs.push_back(m_vecs[i] + other.m_vecs[j]); + ++i; ++j; + } + } + while (i < m_indices.size()) + { + ret.m_indices.push_back(m_indices[i]); + ret.m_vecs.push_back(m_vecs[i]); + ++i; + } + while (j < other.m_indices.size()) + { + ret.m_indices.push_back(other.m_indices[j]); + ret.m_vecs.push_back(other.m_vecs[j]); + ++j; + } + ret.simplify(); + return ret; + } + + btReducedVector operator-() + { + btReducedVector ret(m_sz); + for (int i = 0; i < m_indices.size(); ++i) + { + ret.m_indices.push_back(m_indices[i]); + ret.m_vecs.push_back(-m_vecs[i]); + } + ret.simplify(); + return ret; + } + + btReducedVector operator-(const btReducedVector& other) + { + btReducedVector ret(m_sz); + int i=0, j=0; + while (i < m_indices.size() && j < other.m_indices.size()) + { + if (m_indices[i] < other.m_indices[j]) + { + ret.m_indices.push_back(m_indices[i]); + ret.m_vecs.push_back(m_vecs[i]); + ++i; + } + else if (m_indices[i] > other.m_indices[j]) + { + ret.m_indices.push_back(other.m_indices[j]); + ret.m_vecs.push_back(-other.m_vecs[j]); + ++j; + } + else + { + ret.m_indices.push_back(other.m_indices[j]); + ret.m_vecs.push_back(m_vecs[i] - other.m_vecs[j]); + ++i; ++j; + } + } + while (i < m_indices.size()) + { + ret.m_indices.push_back(m_indices[i]); + ret.m_vecs.push_back(m_vecs[i]); + ++i; + } + while (j < other.m_indices.size()) + { + ret.m_indices.push_back(other.m_indices[j]); + ret.m_vecs.push_back(-other.m_vecs[j]); + ++j; + } + ret.simplify(); + return ret; + } + + bool operator==(const btReducedVector& other) const + { + if (m_sz != other.m_sz) + return false; + if (m_indices.size() != other.m_indices.size()) + return false; + for (int i = 0; i < m_indices.size(); ++i) + { + if (m_indices[i] != other.m_indices[i] || m_vecs[i] != other.m_vecs[i]) + { + return false; + } + } + return true; + } + + bool operator!=(const btReducedVector& other) const + { + return !(*this == other); + } + + btReducedVector& operator=(const btReducedVector& other) + { + if (this == &other) + { + return *this; + } + m_sz = other.m_sz; + m_indices.copyFromArray(other.m_indices); + m_vecs.copyFromArray(other.m_vecs); + return *this; + } + + btScalar dot(const btReducedVector& other) const + { + btScalar ret = 0; + int j = 0; + for (int i = 0; i < m_indices.size(); ++i) + { + while (j < other.m_indices.size() && other.m_indices[j] < m_indices[i]) + { + ++j; + } + if (j < other.m_indices.size() && other.m_indices[j] == m_indices[i]) + { + ret += m_vecs[i].dot(other.m_vecs[j]); +// ++j; + } + } + return ret; + } + + btScalar dot(const btAlignedObjectArray& other) const + { + btScalar ret = 0; + for (int i = 0; i < m_indices.size(); ++i) + { + ret += m_vecs[i].dot(other[m_indices[i]]); + } + return ret; + } + + btScalar length2() const + { + return this->dot(*this); + } + + void normalize(); + + // returns the projection of this onto other + btReducedVector proj(const btReducedVector& other) const; + + bool testAdd() const; + + bool testMinus() const; + + bool testDot() const; + + bool testMultiply() const; + + void test() const; + + void print() const + { + for (int i = 0; i < m_indices.size(); ++i) + { + printf("%d: (%f, %f, %f)/", m_indices[i], m_vecs[i][0],m_vecs[i][1],m_vecs[i][2]); + } + printf("\n"); + } + + + void sort() + { + std::vector tuples; + for (int i = 0; i < m_indices.size(); ++i) + { + TwoInts ti; + ti.a = i; + ti.b = m_indices[i]; + tuples.push_back(ti); + } + std::sort(tuples.begin(), tuples.end()); + btAlignedObjectArray new_indices; + btAlignedObjectArray new_vecs; + for (size_t i = 0; i < tuples.size(); ++i) + { + new_indices.push_back(tuples[i].b); + new_vecs.push_back(m_vecs[tuples[i].a]); + } + m_indices = new_indices; + m_vecs = new_vecs; + } +}; + +SIMD_FORCE_INLINE btReducedVector operator*(const btReducedVector& v, btScalar s) +{ + btReducedVector ret(v.m_sz); + for (int i = 0; i < v.m_indices.size(); ++i) + { + ret.m_indices.push_back(v.m_indices[i]); + ret.m_vecs.push_back(s*v.m_vecs[i]); + } + ret.simplify(); + return ret; +} + +SIMD_FORCE_INLINE btReducedVector operator*(btScalar s, const btReducedVector& v) +{ + return v*s; +} + +SIMD_FORCE_INLINE btReducedVector operator/(const btReducedVector& v, btScalar s) +{ + return v * (1.0/s); +} + +SIMD_FORCE_INLINE btReducedVector& operator/=(btReducedVector& v, btScalar s) +{ + v = v/s; + return v; +} + +SIMD_FORCE_INLINE btReducedVector& operator+=(btReducedVector& v1, const btReducedVector& v2) +{ + v1 = v1+v2; + return v1; +} + +SIMD_FORCE_INLINE btReducedVector& operator-=(btReducedVector& v1, const btReducedVector& v2) +{ + v1 = v1-v2; + return v1; +} + +#endif /* btReducedVectors_h */ diff --git a/pkg/mphysics/mbt/LinearMath/btReducedVector.h.i b/pkg/mphysics/mbt/LinearMath/btReducedVector.h.i new file mode 100644 index 00000000..0cff39fd --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btReducedVector.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btReducedVector.h ---------------- + +%include "LinearMath/btReducedVector.h" + +%{ +#include "LinearMath/btReducedVector.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btScalar.h b/pkg/mphysics/mbt/LinearMath/btScalar.h new file mode 100644 index 00000000..5fbccaa8 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btScalar.h @@ -0,0 +1,832 @@ +/* +Copyright (c) 2003-2009 Erwin Coumans http://bullet.googlecode.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SCALAR_H +#define BT_SCALAR_H + +#ifdef BT_MANAGED_CODE +//Aligned data types not supported in managed code +#pragma unmanaged +#endif + +#include +#include //size_t for MSVC 6.0 +#include + +/* SVN $Revision$ on $Date$ from http://bullet.googlecode.com*/ +#define BT_BULLET_VERSION 326 + +inline int btGetVersion() +{ + return BT_BULLET_VERSION; +} + +inline int btIsDoublePrecision() +{ + #ifdef BT_USE_DOUBLE_PRECISION + return true; + #else + return false; + #endif +} + + +// The following macro "BT_NOT_EMPTY_FILE" can be put into a file +// in order suppress the MS Visual C++ Linker warning 4221 +// +// warning LNK4221: no public symbols found; archive member will be inaccessible +// +// This warning occurs on PC and XBOX when a file compiles out completely +// has no externally visible symbols which may be dependant on configuration +// #defines and options. +// +// see more https://stackoverflow.com/questions/1822887/what-is-the-best-way-to-eliminate-ms-visual-c-linker-warning-warning-lnk422 + +#if defined(_MSC_VER) +#define BT_NOT_EMPTY_FILE_CAT_II(p, res) res +#define BT_NOT_EMPTY_FILE_CAT_I(a, b) BT_NOT_EMPTY_FILE_CAT_II(~, a##b) +#define BT_NOT_EMPTY_FILE_CAT(a, b) BT_NOT_EMPTY_FILE_CAT_I(a, b) +#define BT_NOT_EMPTY_FILE \ + namespace \ + { \ + char BT_NOT_EMPTY_FILE_CAT(NoEmptyFileDummy, __COUNTER__); \ + } +#else +#define BT_NOT_EMPTY_FILE +#endif + +// clang and most formatting tools don't support indentation of preprocessor guards, so turn it off +// clang-format off +#if defined(DEBUG) || defined (_DEBUG) + #define BT_DEBUG +#endif + +#ifdef _WIN32 + #if defined(__GNUC__) // it should handle both MINGW and CYGWIN + #define SIMD_FORCE_INLINE __inline__ __attribute__((always_inline)) + #define ATTRIBUTE_ALIGNED16(a) a __attribute__((aligned(16))) + #define ATTRIBUTE_ALIGNED64(a) a __attribute__((aligned(64))) + #define ATTRIBUTE_ALIGNED128(a) a __attribute__((aligned(128))) + #elif ( defined(_MSC_VER) && _MSC_VER < 1300 ) + #define SIMD_FORCE_INLINE inline + #define ATTRIBUTE_ALIGNED16(a) a + #define ATTRIBUTE_ALIGNED64(a) a + #define ATTRIBUTE_ALIGNED128(a) a + #elif defined(_M_ARM) + #define SIMD_FORCE_INLINE __forceinline + #define ATTRIBUTE_ALIGNED16(a) __declspec() a + #define ATTRIBUTE_ALIGNED64(a) __declspec() a + #define ATTRIBUTE_ALIGNED128(a) __declspec () a + #else//__MINGW32__ + //#define BT_HAS_ALIGNED_ALLOCATOR + #pragma warning(disable : 4324) // disable padding warning +// #pragma warning(disable:4530) // Disable the exception disable but used in MSCV Stl warning. + #pragma warning(disable:4996) //Turn off warnings about deprecated C routines +// #pragma warning(disable:4786) // Disable the "debug name too long" warning + + #define SIMD_FORCE_INLINE __forceinline + #define ATTRIBUTE_ALIGNED16(a) __declspec(align(16)) a + #define ATTRIBUTE_ALIGNED64(a) __declspec(align(64)) a + #define ATTRIBUTE_ALIGNED128(a) __declspec (align(128)) a + #ifdef _XBOX + #define BT_USE_VMX128 + + #include + #define BT_HAVE_NATIVE_FSEL + #define btFsel(a,b,c) __fsel((a),(b),(c)) + #else + +#if defined (_M_ARM) || defined (_M_ARM64) + //Do not turn SSE on for ARM (may want to turn on BT_USE_NEON however) +#elif (defined (_WIN32) && (_MSC_VER) && _MSC_VER >= 1400) && (!defined (BT_USE_DOUBLE_PRECISION)) + +#ifdef __clang__ +#define __BT_DISABLE_SSE__ +#endif +#ifndef __BT_DISABLE_SSE__ + #if _MSC_VER>1400 + #define BT_USE_SIMD_VECTOR3 + #endif + #define BT_USE_SSE +#endif//__BT_DISABLE_SSE__ + #ifdef BT_USE_SSE + +#if (_MSC_FULL_VER >= 170050727)//Visual Studio 2012 can compile SSE4/FMA3 (but SSE4/FMA3 is not enabled by default) + #define BT_ALLOW_SSE4 +#endif //(_MSC_FULL_VER >= 160040219) + + //BT_USE_SSE_IN_API is disabled under Windows by default, because + //it makes it harder to integrate Bullet into your application under Windows + //(structured embedding Bullet structs/classes need to be 16-byte aligned) + //with relatively little performance gain + //If you are not embedded Bullet data in your classes, or make sure that you align those classes on 16-byte boundaries + //you can manually enable this line or set it in the build system for a bit of performance gain (a few percent, dependent on usage) + //#define BT_USE_SSE_IN_API + #endif //BT_USE_SSE + #include +#endif + + #endif//_XBOX + + #endif //__MINGW32__ + + #ifdef BT_DEBUG + #ifdef _MSC_VER + #include + #define btAssert(x) { if(!(x)){printf("Assert " __FILE__ ":%u (%s)\n", __LINE__, #x);__debugbreak(); }} + #else//_MSC_VER + #include + #define btAssert assert + #endif//_MSC_VER + #else + #define btAssert(x) + #endif + //btFullAssert is optional, slows down a lot + #define btFullAssert(x) + + #define btLikely(_c) _c + #define btUnlikely(_c) _c + +#else//_WIN32 + + #if defined (__CELLOS_LV2__) + #define SIMD_FORCE_INLINE inline __attribute__((always_inline)) + #define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16))) + #define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64))) + #define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128))) + #ifndef assert + #include + #endif + #ifdef BT_DEBUG + #ifdef __SPU__ + #include + #define printf spu_printf + #define btAssert(x) {if(!(x)){printf("Assert " __FILE__ ":%u ("#x")\n", __LINE__);spu_hcmpeq(0,0);}} + #else + #define btAssert assert + #endif + + #else//BT_DEBUG + #define btAssert(x) + #endif//BT_DEBUG + //btFullAssert is optional, slows down a lot + #define btFullAssert(x) + + #define btLikely(_c) _c + #define btUnlikely(_c) _c + + #else//defined (__CELLOS_LV2__) + + #ifdef USE_LIBSPE2 + + #define SIMD_FORCE_INLINE __inline + #define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16))) + #define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64))) + #define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128))) + #ifndef assert + #include + #endif + #ifdef BT_DEBUG + #define btAssert assert + #else + #define btAssert(x) + #endif + //btFullAssert is optional, slows down a lot + #define btFullAssert(x) + + + #define btLikely(_c) __builtin_expect((_c), 1) + #define btUnlikely(_c) __builtin_expect((_c), 0) + + + #else//USE_LIBSPE2 + //non-windows systems + + #if (defined (__APPLE__) && (!defined (BT_USE_DOUBLE_PRECISION))) + #if defined (__i386__) || defined (__x86_64__) + #define BT_USE_SIMD_VECTOR3 + #define BT_USE_SSE + //BT_USE_SSE_IN_API is enabled on Mac OSX by default, because memory is automatically aligned on 16-byte boundaries + //if apps run into issues, we will disable the next line + #define BT_USE_SSE_IN_API + #ifdef BT_USE_SSE + // include appropriate SSE level + #if defined (__SSE4_1__) + #include + #elif defined (__SSSE3__) + #include + #elif defined (__SSE3__) + #include + #else + #include + #endif + #endif //BT_USE_SSE + #elif defined( __ARM_NEON__ ) + #ifdef __clang__ + #define BT_USE_NEON 1 + #define BT_USE_SIMD_VECTOR3 + + #if defined BT_USE_NEON && defined (__clang__) + #include + #endif//BT_USE_NEON + #endif //__clang__ + #endif//__arm__ + + #define SIMD_FORCE_INLINE inline __attribute__ ((always_inline)) + ///@todo: check out alignment methods for other platforms/compilers + #define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16))) + #define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64))) + #define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128))) + #ifndef assert + #include + #endif + + #if defined(DEBUG) || defined (_DEBUG) + #if defined (__i386__) || defined (__x86_64__) + #include + #define btAssert(x)\ + {\ + if(!(x))\ + {\ + printf("Assert %s in line %d, file %s\n",#x, __LINE__, __FILE__);\ + asm volatile ("int3");\ + }\ + } + #else//defined (__i386__) || defined (__x86_64__) + #define btAssert assert + #endif//defined (__i386__) || defined (__x86_64__) + #else//defined(DEBUG) || defined (_DEBUG) + #define btAssert(x) + #endif//defined(DEBUG) || defined (_DEBUG) + + //btFullAssert is optional, slows down a lot + #define btFullAssert(x) + #define btLikely(_c) _c + #define btUnlikely(_c) _c + + #else//__APPLE__ + + #define SIMD_FORCE_INLINE inline + ///@todo: check out alignment methods for other platforms/compilers + ///#define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16))) + ///#define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64))) + ///#define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128))) + #define ATTRIBUTE_ALIGNED16(a) a + #define ATTRIBUTE_ALIGNED64(a) a + #define ATTRIBUTE_ALIGNED128(a) a + #ifndef assert + #include + #endif + + #if defined(DEBUG) || defined (_DEBUG) + #define btAssert assert + #else + #define btAssert(x) + #endif + + //btFullAssert is optional, slows down a lot + #define btFullAssert(x) + #define btLikely(_c) _c + #define btUnlikely(_c) _c + #endif //__APPLE__ + #endif // LIBSPE2 + #endif //__CELLOS_LV2__ +#endif//_WIN32 + + +///The btScalar type abstracts floating point numbers, to easily switch between double and single floating point precision. +#if defined(BT_USE_DOUBLE_PRECISION) + typedef double btScalar; + //this number could be bigger in double precision + #define BT_LARGE_FLOAT 1e30 +#else + typedef float btScalar; + //keep BT_LARGE_FLOAT*BT_LARGE_FLOAT < FLT_MAX + #define BT_LARGE_FLOAT 1e18f +#endif + +#ifdef BT_USE_SSE + typedef __m128 btSimdFloat4; +#endif //BT_USE_SSE + +#if defined(BT_USE_SSE) + //#if defined BT_USE_SSE_IN_API && defined (BT_USE_SSE) + #ifdef _WIN32 + + #ifndef BT_NAN + static int btNanMask = 0x7F800001; + #define BT_NAN (*(float *)&btNanMask) + #endif + + #ifndef BT_INFINITY + static int btInfinityMask = 0x7F800000; + #define BT_INFINITY (*(float *)&btInfinityMask) + inline int btGetInfinityMask() //suppress stupid compiler warning + { + return btInfinityMask; + } + #endif + + + + //use this, in case there are clashes (such as xnamath.h) + #ifndef BT_NO_SIMD_OPERATOR_OVERLOADS + inline __m128 operator+(const __m128 A, const __m128 B) + { + return _mm_add_ps(A, B); + } + + inline __m128 operator-(const __m128 A, const __m128 B) + { + return _mm_sub_ps(A, B); + } + + inline __m128 operator*(const __m128 A, const __m128 B) + { + return _mm_mul_ps(A, B); + } + #endif //BT_NO_SIMD_OPERATOR_OVERLOADS + + #define btCastfTo128i(a) (_mm_castps_si128(a)) + #define btCastfTo128d(a) (_mm_castps_pd(a)) + #define btCastiTo128f(a) (_mm_castsi128_ps(a)) + #define btCastdTo128f(a) (_mm_castpd_ps(a)) + #define btCastdTo128i(a) (_mm_castpd_si128(a)) + #define btAssign128(r0, r1, r2, r3) _mm_setr_ps(r0, r1, r2, r3) + + #else //_WIN32 + + #define btCastfTo128i(a) ((__m128i)(a)) + #define btCastfTo128d(a) ((__m128d)(a)) + #define btCastiTo128f(a) ((__m128)(a)) + #define btCastdTo128f(a) ((__m128)(a)) + #define btCastdTo128i(a) ((__m128i)(a)) + #define btAssign128(r0, r1, r2, r3) \ + (__m128) { r0, r1, r2, r3 } + #define BT_INFINITY INFINITY + #define BT_NAN NAN + #endif //_WIN32 +#else//BT_USE_SSE + + #ifdef BT_USE_NEON + #include + + typedef float32x4_t btSimdFloat4; + #define BT_INFINITY INFINITY + #define BT_NAN NAN + #define btAssign128(r0, r1, r2, r3) \ + (float32x4_t) { r0, r1, r2, r3 } + #else //BT_USE_NEON + + #ifndef BT_INFINITY + struct btInfMaskConverter + { + union { + float mask; + int intmask; + }; + btInfMaskConverter(int _mask = 0x7F800000) + : intmask(_mask) + { + } + }; + static btInfMaskConverter btInfinityMask = 0x7F800000; + #define BT_INFINITY (btInfinityMask.mask) + inline int btGetInfinityMask() //suppress stupid compiler warning + { + return btInfinityMask.intmask; + } + #endif + #endif //BT_USE_NEON + +#endif //BT_USE_SSE + +#ifdef BT_USE_NEON + #include + + typedef float32x4_t btSimdFloat4; + #define BT_INFINITY INFINITY + #define BT_NAN NAN + #define btAssign128(r0, r1, r2, r3) \ + (float32x4_t) { r0, r1, r2, r3 } +#endif//BT_USE_NEON + +#define BT_DECLARE_ALIGNED_ALLOCATOR() \ + SIMD_FORCE_INLINE void *operator new(size_t sizeInBytes) { return btAlignedAlloc(sizeInBytes, 16); } \ + SIMD_FORCE_INLINE void operator delete(void *ptr) { btAlignedFree(ptr); } \ + SIMD_FORCE_INLINE void *operator new(size_t, void *ptr) { return ptr; } \ + SIMD_FORCE_INLINE void operator delete(void *, void *) {} \ + SIMD_FORCE_INLINE void *operator new[](size_t sizeInBytes) { return btAlignedAlloc(sizeInBytes, 16); } \ + SIMD_FORCE_INLINE void operator delete[](void *ptr) { btAlignedFree(ptr); } \ + SIMD_FORCE_INLINE void *operator new[](size_t, void *ptr) { return ptr; } \ + SIMD_FORCE_INLINE void operator delete[](void *, void *) {} + +#if defined(BT_USE_DOUBLE_PRECISION) || defined(BT_FORCE_DOUBLE_FUNCTIONS) + + SIMD_FORCE_INLINE btScalar btSqrt(btScalar x) + { + return sqrt(x); + } + SIMD_FORCE_INLINE btScalar btFabs(btScalar x) { return fabs(x); } + SIMD_FORCE_INLINE btScalar btCos(btScalar x) { return cos(x); } + SIMD_FORCE_INLINE btScalar btSin(btScalar x) { return sin(x); } + SIMD_FORCE_INLINE btScalar btTan(btScalar x) { return tan(x); } + SIMD_FORCE_INLINE btScalar btAcos(btScalar x) + { + if (x < btScalar(-1)) x = btScalar(-1); + if (x > btScalar(1)) x = btScalar(1); + return acos(x); + } + SIMD_FORCE_INLINE btScalar btAsin(btScalar x) + { + if (x < btScalar(-1)) x = btScalar(-1); + if (x > btScalar(1)) x = btScalar(1); + return asin(x); + } + SIMD_FORCE_INLINE btScalar btAtan(btScalar x) { return atan(x); } + SIMD_FORCE_INLINE btScalar btAtan2(btScalar x, btScalar y) { return atan2(x, y); } + SIMD_FORCE_INLINE btScalar btExp(btScalar x) { return exp(x); } + SIMD_FORCE_INLINE btScalar btLog(btScalar x) { return log(x); } + SIMD_FORCE_INLINE btScalar btPow(btScalar x, btScalar y) { return pow(x, y); } + SIMD_FORCE_INLINE btScalar btFmod(btScalar x, btScalar y) { return fmod(x, y); } + +#else//BT_USE_DOUBLE_PRECISION + + SIMD_FORCE_INLINE btScalar btSqrt(btScalar y) + { + #ifdef USE_APPROXIMATION + #ifdef __LP64__ + float xhalf = 0.5f * y; + int i = *(int *)&y; + i = 0x5f375a86 - (i >> 1); + y = *(float *)&i; + y = y * (1.5f - xhalf * y * y); + y = y * (1.5f - xhalf * y * y); + y = y * (1.5f - xhalf * y * y); + y = 1 / y; + return y; + #else + double x, z, tempf; + unsigned long *tfptr = ((unsigned long *)&tempf) + 1; + tempf = y; + *tfptr = (0xbfcdd90a - *tfptr) >> 1; /* estimate of 1/sqrt(y) */ + x = tempf; + z = y * btScalar(0.5); + x = (btScalar(1.5) * x) - (x * x) * (x * z); /* iteration formula */ + x = (btScalar(1.5) * x) - (x * x) * (x * z); + x = (btScalar(1.5) * x) - (x * x) * (x * z); + x = (btScalar(1.5) * x) - (x * x) * (x * z); + x = (btScalar(1.5) * x) - (x * x) * (x * z); + return x * y; + #endif + #else + return sqrtf(y); + #endif + } + SIMD_FORCE_INLINE btScalar btFabs(btScalar x) { return fabsf(x); } + SIMD_FORCE_INLINE btScalar btCos(btScalar x) { return cosf(x); } + SIMD_FORCE_INLINE btScalar btSin(btScalar x) { return sinf(x); } + SIMD_FORCE_INLINE btScalar btTan(btScalar x) { return tanf(x); } + SIMD_FORCE_INLINE btScalar btAcos(btScalar x) + { + if (x < btScalar(-1)) + x = btScalar(-1); + if (x > btScalar(1)) + x = btScalar(1); + return acosf(x); + } + SIMD_FORCE_INLINE btScalar btAsin(btScalar x) + { + if (x < btScalar(-1)) + x = btScalar(-1); + if (x > btScalar(1)) + x = btScalar(1); + return asinf(x); + } + SIMD_FORCE_INLINE btScalar btAtan(btScalar x) { return atanf(x); } + SIMD_FORCE_INLINE btScalar btAtan2(btScalar x, btScalar y) { return atan2f(x, y); } + SIMD_FORCE_INLINE btScalar btExp(btScalar x) { return expf(x); } + SIMD_FORCE_INLINE btScalar btLog(btScalar x) { return logf(x); } + SIMD_FORCE_INLINE btScalar btPow(btScalar x, btScalar y) { return powf(x, y); } + SIMD_FORCE_INLINE btScalar btFmod(btScalar x, btScalar y) { return fmodf(x, y); } + +#endif//BT_USE_DOUBLE_PRECISION + +#define SIMD_PI btScalar(3.1415926535897932384626433832795029) +#define SIMD_2_PI (btScalar(2.0) * SIMD_PI) +#define SIMD_HALF_PI (SIMD_PI * btScalar(0.5)) +#define SIMD_RADS_PER_DEG (SIMD_2_PI / btScalar(360.0)) +#define SIMD_DEGS_PER_RAD (btScalar(360.0) / SIMD_2_PI) +#define SIMDSQRT12 btScalar(0.7071067811865475244008443621048490) +#define btRecipSqrt(x) ((btScalar)(btScalar(1.0) / btSqrt(btScalar(x)))) /* reciprocal square root */ +#define btRecip(x) (btScalar(1.0) / btScalar(x)) + +#ifdef BT_USE_DOUBLE_PRECISION + #define SIMD_EPSILON DBL_EPSILON + #define SIMD_INFINITY DBL_MAX + #define BT_ONE 1.0 + #define BT_ZERO 0.0 + #define BT_TWO 2.0 + #define BT_HALF 0.5 +#else + #define SIMD_EPSILON FLT_EPSILON + #define SIMD_INFINITY FLT_MAX + #define BT_ONE 1.0f + #define BT_ZERO 0.0f + #define BT_TWO 2.0f + #define BT_HALF 0.5f +#endif + +// clang-format on + +SIMD_FORCE_INLINE btScalar btAtan2Fast(btScalar y, btScalar x) +{ + btScalar coeff_1 = SIMD_PI / 4.0f; + btScalar coeff_2 = 3.0f * coeff_1; + btScalar abs_y = btFabs(y); + btScalar angle; + if (x >= 0.0f) + { + btScalar r = (x - abs_y) / (x + abs_y); + angle = coeff_1 - coeff_1 * r; + } + else + { + btScalar r = (x + abs_y) / (abs_y - x); + angle = coeff_2 - coeff_1 * r; + } + return (y < 0.0f) ? -angle : angle; +} + +SIMD_FORCE_INLINE bool btFuzzyZero(btScalar x) { return btFabs(x) < SIMD_EPSILON; } + +SIMD_FORCE_INLINE bool btEqual(btScalar a, btScalar eps) +{ + return (((a) <= eps) && !((a) < -eps)); +} +SIMD_FORCE_INLINE bool btGreaterEqual(btScalar a, btScalar eps) +{ + return (!((a) <= eps)); +} + +SIMD_FORCE_INLINE int btIsNegative(btScalar x) +{ + return x < btScalar(0.0) ? 1 : 0; +} + +SIMD_FORCE_INLINE btScalar btRadians(btScalar x) { return x * SIMD_RADS_PER_DEG; } +SIMD_FORCE_INLINE btScalar btDegrees(btScalar x) { return x * SIMD_DEGS_PER_RAD; } + +#define BT_DECLARE_HANDLE(name) \ + typedef struct name##__ \ + { \ + int unused; \ + } * name + +#ifndef btFsel +SIMD_FORCE_INLINE btScalar btFsel(btScalar a, btScalar b, btScalar c) +{ + return a >= 0 ? b : c; +} +#endif +#define btFsels(a, b, c) (btScalar) btFsel(a, b, c) + +SIMD_FORCE_INLINE bool btMachineIsLittleEndian() +{ + long int i = 1; + const char *p = (const char *)&i; + if (p[0] == 1) // Lowest address contains the least significant byte + return true; + else + return false; +} + +///btSelect avoids branches, which makes performance much better for consoles like Playstation 3 and XBox 360 +///Thanks Phil Knight. See also http://www.cellperformance.com/articles/2006/04/more_techniques_for_eliminatin_1.html +SIMD_FORCE_INLINE unsigned btSelect(unsigned condition, unsigned valueIfConditionNonZero, unsigned valueIfConditionZero) +{ + // Set testNz to 0xFFFFFFFF if condition is nonzero, 0x00000000 if condition is zero + // Rely on positive value or'ed with its negative having sign bit on + // and zero value or'ed with its negative (which is still zero) having sign bit off + // Use arithmetic shift right, shifting the sign bit through all 32 bits + unsigned testNz = (unsigned)(((int)condition | -(int)condition) >> 31); + unsigned testEqz = ~testNz; + return ((valueIfConditionNonZero & testNz) | (valueIfConditionZero & testEqz)); +} +SIMD_FORCE_INLINE int btSelect(unsigned condition, int valueIfConditionNonZero, int valueIfConditionZero) +{ + unsigned testNz = (unsigned)(((int)condition | -(int)condition) >> 31); + unsigned testEqz = ~testNz; + return static_cast((valueIfConditionNonZero & testNz) | (valueIfConditionZero & testEqz)); +} +SIMD_FORCE_INLINE float btSelect(unsigned condition, float valueIfConditionNonZero, float valueIfConditionZero) +{ +#ifdef BT_HAVE_NATIVE_FSEL + return (float)btFsel((btScalar)condition - btScalar(1.0f), valueIfConditionNonZero, valueIfConditionZero); +#else + return (condition != 0) ? valueIfConditionNonZero : valueIfConditionZero; +#endif +} + +template +SIMD_FORCE_INLINE void btSwap(T &a, T &b) +{ + T tmp = a; + a = b; + b = tmp; +} + +//PCK: endian swapping functions +SIMD_FORCE_INLINE unsigned btSwapEndian(unsigned val) +{ + return (((val & 0xff000000) >> 24) | ((val & 0x00ff0000) >> 8) | ((val & 0x0000ff00) << 8) | ((val & 0x000000ff) << 24)); +} + +SIMD_FORCE_INLINE unsigned short btSwapEndian(unsigned short val) +{ + return static_cast(((val & 0xff00) >> 8) | ((val & 0x00ff) << 8)); +} + +SIMD_FORCE_INLINE unsigned btSwapEndian(int val) +{ + return btSwapEndian((unsigned)val); +} + +SIMD_FORCE_INLINE unsigned short btSwapEndian(short val) +{ + return btSwapEndian((unsigned short)val); +} + +///btSwapFloat uses using char pointers to swap the endianness +////btSwapFloat/btSwapDouble will NOT return a float, because the machine might 'correct' invalid floating point values +///Not all values of sign/exponent/mantissa are valid floating point numbers according to IEEE 754. +///When a floating point unit is faced with an invalid value, it may actually change the value, or worse, throw an exception. +///In most systems, running user mode code, you wouldn't get an exception, but instead the hardware/os/runtime will 'fix' the number for you. +///so instead of returning a float/double, we return integer/long long integer +SIMD_FORCE_INLINE unsigned int btSwapEndianFloat(float d) +{ + unsigned int a = 0; + unsigned char *dst = (unsigned char *)&a; + unsigned char *src = (unsigned char *)&d; + + dst[0] = src[3]; + dst[1] = src[2]; + dst[2] = src[1]; + dst[3] = src[0]; + return a; +} + +// unswap using char pointers +SIMD_FORCE_INLINE float btUnswapEndianFloat(unsigned int a) +{ + float d = 0.0f; + unsigned char *src = (unsigned char *)&a; + unsigned char *dst = (unsigned char *)&d; + + dst[0] = src[3]; + dst[1] = src[2]; + dst[2] = src[1]; + dst[3] = src[0]; + + return d; +} + +// swap using char pointers +SIMD_FORCE_INLINE void btSwapEndianDouble(double d, unsigned char *dst) +{ + unsigned char *src = (unsigned char *)&d; + + dst[0] = src[7]; + dst[1] = src[6]; + dst[2] = src[5]; + dst[3] = src[4]; + dst[4] = src[3]; + dst[5] = src[2]; + dst[6] = src[1]; + dst[7] = src[0]; +} + +// unswap using char pointers +SIMD_FORCE_INLINE double btUnswapEndianDouble(const unsigned char *src) +{ + double d = 0.0; + unsigned char *dst = (unsigned char *)&d; + + dst[0] = src[7]; + dst[1] = src[6]; + dst[2] = src[5]; + dst[3] = src[4]; + dst[4] = src[3]; + dst[5] = src[2]; + dst[6] = src[1]; + dst[7] = src[0]; + + return d; +} + +template +SIMD_FORCE_INLINE void btSetZero(T *a, int n) +{ + T *acurr = a; + size_t ncurr = n; + while (ncurr > 0) + { + *(acurr++) = 0; + --ncurr; + } +} + +SIMD_FORCE_INLINE btScalar btLargeDot(const btScalar *a, const btScalar *b, int n) +{ + btScalar p0, q0, m0, p1, q1, m1, sum; + sum = 0; + n -= 2; + while (n >= 0) + { + p0 = a[0]; + q0 = b[0]; + m0 = p0 * q0; + p1 = a[1]; + q1 = b[1]; + m1 = p1 * q1; + sum += m0; + sum += m1; + a += 2; + b += 2; + n -= 2; + } + n += 2; + while (n > 0) + { + sum += (*a) * (*b); + a++; + b++; + n--; + } + return sum; +} + +// returns normalized value in range [-SIMD_PI, SIMD_PI] +SIMD_FORCE_INLINE btScalar btNormalizeAngle(btScalar angleInRadians) +{ + angleInRadians = btFmod(angleInRadians, SIMD_2_PI); + if (angleInRadians < -SIMD_PI) + { + return angleInRadians + SIMD_2_PI; + } + else if (angleInRadians > SIMD_PI) + { + return angleInRadians - SIMD_2_PI; + } + else + { + return angleInRadians; + } +} + +///rudimentary class to provide type info +struct btTypedObject +{ + btTypedObject(int objectType) + : m_objectType(objectType) + { + } + int m_objectType; + inline int getObjectType() const + { + return m_objectType; + } +}; + +///align a pointer to the provided alignment, upwards +template +T *btAlignPointer(T *unalignedPtr, size_t alignment) +{ + struct btConvertPointerSizeT + { + union { + T *ptr; + size_t integer; + }; + }; + btConvertPointerSizeT converter; + + const size_t bit_mask = ~(alignment - 1); + converter.ptr = unalignedPtr; + converter.integer += alignment - 1; + converter.integer &= bit_mask; + return converter.ptr; +} + +#endif //BT_SCALAR_H diff --git a/pkg/mphysics/mbt/LinearMath/btScalar.h.i b/pkg/mphysics/mbt/LinearMath/btScalar.h.i new file mode 100644 index 00000000..128542a8 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btScalar.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btScalar.h ---------------- + +%include "LinearMath/btScalar.h" + +%{ +#include "LinearMath/btScalar.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btSerializer.cpp b/pkg/mphysics/mbt/LinearMath/btSerializer.cpp new file mode 100644 index 00000000..068836f2 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btSerializer.cpp @@ -0,0 +1,692 @@ +char sBulletDNAstr[]= { +char(83),char(68),char(78),char(65),char(78),char(65),char(77),char(69),char(-74),char(1),char(0),char(0),char(109),char(95),char(115),char(105),char(122),char(101),char(0),char(109), +char(95),char(99),char(97),char(112),char(97),char(99),char(105),char(116),char(121),char(0),char(42),char(109),char(95),char(100),char(97),char(116),char(97),char(0),char(109),char(95), +char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(83),char(104),char(97),char(112),char(101),char(115),char(0),char(109),char(95),char(99),char(111), +char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(79),char(98),char(106),char(101),char(99),char(116),char(115),char(0),char(109),char(95),char(99),char(111),char(110), +char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(115),char(0),char(42),char(102),char(105),char(114),char(115),char(116),char(0),char(42),char(108),char(97),char(115), +char(116),char(0),char(109),char(95),char(102),char(108),char(111),char(97),char(116),char(115),char(91),char(52),char(93),char(0),char(109),char(95),char(101),char(108),char(91),char(51), +char(93),char(0),char(109),char(95),char(98),char(97),char(115),char(105),char(115),char(0),char(109),char(95),char(111),char(114),char(105),char(103),char(105),char(110),char(0),char(109), +char(95),char(114),char(111),char(111),char(116),char(78),char(111),char(100),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109),char(95),char(115),char(117),char(98), +char(116),char(114),char(101),char(101),char(83),char(105),char(122),char(101),char(0),char(109),char(95),char(113),char(117),char(97),char(110),char(116),char(105),char(122),char(101),char(100), +char(65),char(97),char(98),char(98),char(77),char(105),char(110),char(91),char(51),char(93),char(0),char(109),char(95),char(113),char(117),char(97),char(110),char(116),char(105),char(122), +char(101),char(100),char(65),char(97),char(98),char(98),char(77),char(97),char(120),char(91),char(51),char(93),char(0),char(109),char(95),char(97),char(97),char(98),char(98),char(77), +char(105),char(110),char(79),char(114),char(103),char(0),char(109),char(95),char(97),char(97),char(98),char(98),char(77),char(97),char(120),char(79),char(114),char(103),char(0),char(109), +char(95),char(101),char(115),char(99),char(97),char(112),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109),char(95),char(115),char(117),char(98),char(80),char(97), +char(114),char(116),char(0),char(109),char(95),char(116),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109), +char(95),char(112),char(97),char(100),char(91),char(52),char(93),char(0),char(109),char(95),char(101),char(115),char(99),char(97),char(112),char(101),char(73),char(110),char(100),char(101), +char(120),char(79),char(114),char(84),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109),char(95),char(98), +char(118),char(104),char(65),char(97),char(98),char(98),char(77),char(105),char(110),char(0),char(109),char(95),char(98),char(118),char(104),char(65),char(97),char(98),char(98),char(77), +char(97),char(120),char(0),char(109),char(95),char(98),char(118),char(104),char(81),char(117),char(97),char(110),char(116),char(105),char(122),char(97),char(116),char(105),char(111),char(110), +char(0),char(109),char(95),char(99),char(117),char(114),char(78),char(111),char(100),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109),char(95),char(117),char(115), +char(101),char(81),char(117),char(97),char(110),char(116),char(105),char(122),char(97),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(110),char(117),char(109),char(67), +char(111),char(110),char(116),char(105),char(103),char(117),char(111),char(117),char(115),char(76),char(101),char(97),char(102),char(78),char(111),char(100),char(101),char(115),char(0),char(109), +char(95),char(110),char(117),char(109),char(81),char(117),char(97),char(110),char(116),char(105),char(122),char(101),char(100),char(67),char(111),char(110),char(116),char(105),char(103),char(117), +char(111),char(117),char(115),char(78),char(111),char(100),char(101),char(115),char(0),char(42),char(109),char(95),char(99),char(111),char(110),char(116),char(105),char(103),char(117),char(111), +char(117),char(115),char(78),char(111),char(100),char(101),char(115),char(80),char(116),char(114),char(0),char(42),char(109),char(95),char(113),char(117),char(97),char(110),char(116),char(105), +char(122),char(101),char(100),char(67),char(111),char(110),char(116),char(105),char(103),char(117),char(111),char(117),char(115),char(78),char(111),char(100),char(101),char(115),char(80),char(116), +char(114),char(0),char(42),char(109),char(95),char(115),char(117),char(98),char(84),char(114),char(101),char(101),char(73),char(110),char(102),char(111),char(80),char(116),char(114),char(0), +char(109),char(95),char(116),char(114),char(97),char(118),char(101),char(114),char(115),char(97),char(108),char(77),char(111),char(100),char(101),char(0),char(109),char(95),char(110),char(117), +char(109),char(83),char(117),char(98),char(116),char(114),char(101),char(101),char(72),char(101),char(97),char(100),char(101),char(114),char(115),char(0),char(42),char(109),char(95),char(110), +char(97),char(109),char(101),char(0),char(109),char(95),char(115),char(104),char(97),char(112),char(101),char(84),char(121),char(112),char(101),char(0),char(109),char(95),char(112),char(97), +char(100),char(100),char(105),char(110),char(103),char(91),char(52),char(93),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110), +char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(109),char(95),char(108),char(111),char(99),char(97),char(108),char(83),char(99),char(97), +char(108),char(105),char(110),char(103),char(0),char(109),char(95),char(112),char(108),char(97),char(110),char(101),char(78),char(111),char(114),char(109),char(97),char(108),char(0),char(109), +char(95),char(112),char(108),char(97),char(110),char(101),char(67),char(111),char(110),char(115),char(116),char(97),char(110),char(116),char(0),char(109),char(95),char(105),char(109),char(112), +char(108),char(105),char(99),char(105),char(116),char(83),char(104),char(97),char(112),char(101),char(68),char(105),char(109),char(101),char(110),char(115),char(105),char(111),char(110),char(115), +char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(77),char(97),char(114),char(103),char(105),char(110),char(0),char(109), +char(95),char(112),char(97),char(100),char(100),char(105),char(110),char(103),char(0),char(109),char(95),char(112),char(111),char(115),char(0),char(109),char(95),char(114),char(97),char(100), +char(105),char(117),char(115),char(0),char(109),char(95),char(99),char(111),char(110),char(118),char(101),char(120),char(73),char(110),char(116),char(101),char(114),char(110),char(97),char(108), +char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(42),char(109),char(95),char(108),char(111),char(99),char(97),char(108),char(80),char(111), +char(115),char(105),char(116),char(105),char(111),char(110),char(65),char(114),char(114),char(97),char(121),char(80),char(116),char(114),char(0),char(109),char(95),char(108),char(111),char(99), +char(97),char(108),char(80),char(111),char(115),char(105),char(116),char(105),char(111),char(110),char(65),char(114),char(114),char(97),char(121),char(83),char(105),char(122),char(101),char(0), +char(109),char(95),char(118),char(97),char(108),char(117),char(101),char(0),char(109),char(95),char(112),char(97),char(100),char(91),char(50),char(93),char(0),char(109),char(95),char(118), +char(97),char(108),char(117),char(101),char(115),char(91),char(51),char(93),char(0),char(109),char(95),char(112),char(97),char(100),char(0),char(42),char(109),char(95),char(118),char(101), +char(114),char(116),char(105),char(99),char(101),char(115),char(51),char(102),char(0),char(42),char(109),char(95),char(118),char(101),char(114),char(116),char(105),char(99),char(101),char(115), +char(51),char(100),char(0),char(42),char(109),char(95),char(105),char(110),char(100),char(105),char(99),char(101),char(115),char(51),char(50),char(0),char(42),char(109),char(95),char(51), +char(105),char(110),char(100),char(105),char(99),char(101),char(115),char(49),char(54),char(0),char(42),char(109),char(95),char(51),char(105),char(110),char(100),char(105),char(99),char(101), +char(115),char(56),char(0),char(42),char(109),char(95),char(105),char(110),char(100),char(105),char(99),char(101),char(115),char(49),char(54),char(0),char(109),char(95),char(110),char(117), +char(109),char(84),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(86),char(101),char(114),char(116), +char(105),char(99),char(101),char(115),char(0),char(42),char(109),char(95),char(109),char(101),char(115),char(104),char(80),char(97),char(114),char(116),char(115),char(80),char(116),char(114), +char(0),char(109),char(95),char(115),char(99),char(97),char(108),char(105),char(110),char(103),char(0),char(109),char(95),char(110),char(117),char(109),char(77),char(101),char(115),char(104), +char(80),char(97),char(114),char(116),char(115),char(0),char(109),char(95),char(109),char(101),char(115),char(104),char(73),char(110),char(116),char(101),char(114),char(102),char(97),char(99), +char(101),char(0),char(42),char(109),char(95),char(113),char(117),char(97),char(110),char(116),char(105),char(122),char(101),char(100),char(70),char(108),char(111),char(97),char(116),char(66), +char(118),char(104),char(0),char(42),char(109),char(95),char(113),char(117),char(97),char(110),char(116),char(105),char(122),char(101),char(100),char(68),char(111),char(117),char(98),char(108), +char(101),char(66),char(118),char(104),char(0),char(42),char(109),char(95),char(116),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(73),char(110),char(102),char(111), +char(77),char(97),char(112),char(0),char(109),char(95),char(112),char(97),char(100),char(51),char(91),char(52),char(93),char(0),char(109),char(95),char(116),char(114),char(105),char(109), +char(101),char(115),char(104),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(109),char(95),char(116),char(114),char(97),char(110),char(115), +char(102),char(111),char(114),char(109),char(0),char(42),char(109),char(95),char(99),char(104),char(105),char(108),char(100),char(83),char(104),char(97),char(112),char(101),char(0),char(109), +char(95),char(99),char(104),char(105),char(108),char(100),char(83),char(104),char(97),char(112),char(101),char(84),char(121),char(112),char(101),char(0),char(109),char(95),char(99),char(104), +char(105),char(108),char(100),char(77),char(97),char(114),char(103),char(105),char(110),char(0),char(42),char(109),char(95),char(99),char(104),char(105),char(108),char(100),char(83),char(104), +char(97),char(112),char(101),char(80),char(116),char(114),char(0),char(109),char(95),char(110),char(117),char(109),char(67),char(104),char(105),char(108),char(100),char(83),char(104),char(97), +char(112),char(101),char(115),char(0),char(109),char(95),char(117),char(112),char(65),char(120),char(105),char(115),char(0),char(109),char(95),char(117),char(112),char(73),char(110),char(100), +char(101),char(120),char(0),char(109),char(95),char(102),char(108),char(97),char(103),char(115),char(0),char(109),char(95),char(101),char(100),char(103),char(101),char(86),char(48),char(86), +char(49),char(65),char(110),char(103),char(108),char(101),char(0),char(109),char(95),char(101),char(100),char(103),char(101),char(86),char(49),char(86),char(50),char(65),char(110),char(103), +char(108),char(101),char(0),char(109),char(95),char(101),char(100),char(103),char(101),char(86),char(50),char(86),char(48),char(65),char(110),char(103),char(108),char(101),char(0),char(42), +char(109),char(95),char(104),char(97),char(115),char(104),char(84),char(97),char(98),char(108),char(101),char(80),char(116),char(114),char(0),char(42),char(109),char(95),char(110),char(101), +char(120),char(116),char(80),char(116),char(114),char(0),char(42),char(109),char(95),char(118),char(97),char(108),char(117),char(101),char(65),char(114),char(114),char(97),char(121),char(80), +char(116),char(114),char(0),char(42),char(109),char(95),char(107),char(101),char(121),char(65),char(114),char(114),char(97),char(121),char(80),char(116),char(114),char(0),char(109),char(95), +char(99),char(111),char(110),char(118),char(101),char(120),char(69),char(112),char(115),char(105),char(108),char(111),char(110),char(0),char(109),char(95),char(112),char(108),char(97),char(110), +char(97),char(114),char(69),char(112),char(115),char(105),char(108),char(111),char(110),char(0),char(109),char(95),char(101),char(113),char(117),char(97),char(108),char(86),char(101),char(114), +char(116),char(101),char(120),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(101),char(100),char(103),char(101),char(68), +char(105),char(115),char(116),char(97),char(110),char(99),char(101),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(122), +char(101),char(114),char(111),char(65),char(114),char(101),char(97),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(110), +char(101),char(120),char(116),char(83),char(105),char(122),char(101),char(0),char(109),char(95),char(104),char(97),char(115),char(104),char(84),char(97),char(98),char(108),char(101),char(83), +char(105),char(122),char(101),char(0),char(109),char(95),char(110),char(117),char(109),char(86),char(97),char(108),char(117),char(101),char(115),char(0),char(109),char(95),char(110),char(117), +char(109),char(75),char(101),char(121),char(115),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(76),char(111), +char(99),char(97),char(108),char(80),char(111),char(105),char(110),char(116),char(65),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116), +char(67),char(97),char(99),char(104),char(101),char(76),char(111),char(99),char(97),char(108),char(80),char(111),char(105),char(110),char(116),char(66),char(91),char(52),char(93),char(0), +char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(80),char(111),char(115),char(105),char(116),char(105),char(111),char(110), +char(87),char(111),char(114),char(108),char(100),char(79),char(110),char(65),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67), +char(97),char(99),char(104),char(101),char(80),char(111),char(115),char(105),char(116),char(105),char(111),char(110),char(87),char(111),char(114),char(108),char(100),char(79),char(110),char(66), +char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(78),char(111),char(114),char(109), +char(97),char(108),char(87),char(111),char(114),char(108),char(100),char(79),char(110),char(66),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110), +char(116),char(67),char(97),char(99),char(104),char(101),char(76),char(97),char(116),char(101),char(114),char(97),char(108),char(70),char(114),char(105),char(99),char(116),char(105),char(111), +char(110),char(68),char(105),char(114),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104), +char(101),char(76),char(97),char(116),char(101),char(114),char(97),char(108),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(68),char(105),char(114),char(50), +char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(68),char(105),char(115),char(116), +char(97),char(110),char(99),char(101),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101), +char(65),char(112),char(112),char(108),char(105),char(101),char(100),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(91),char(52),char(93),char(0),char(109),char(95), +char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(80),char(114),char(101),char(118),char(82),char(72),char(83),char(91),char(52),char(93), +char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101), +char(100),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116), +char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101),char(100),char(82),char(111),char(108),char(108),char(105),char(110),char(103), +char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67), +char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101),char(100),char(83),char(112),char(105),char(110),char(110),char(105),char(110),char(103), +char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67), +char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101),char(100),char(82),char(101),char(115),char(116),char(105),char(116),char(117),char(116), +char(105),char(111),char(110),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(80), +char(97),char(114),char(116),char(73),char(100),char(48),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99), +char(104),char(101),char(80),char(97),char(114),char(116),char(73),char(100),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116), +char(67),char(97),char(99),char(104),char(101),char(73),char(110),char(100),char(101),char(120),char(48),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105), +char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(73),char(110),char(100),char(101),char(120),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112), +char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(80),char(111),char(105),char(110), +char(116),char(70),char(108),char(97),char(103),char(115),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99), +char(104),char(101),char(65),char(112),char(112),char(108),char(105),char(101),char(100),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(76),char(97),char(116),char(101), +char(114),char(97),char(108),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101), +char(65),char(112),char(112),char(108),char(105),char(101),char(100),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(76),char(97),char(116),char(101),char(114),char(97), +char(108),char(50),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111), +char(110),char(116),char(97),char(99),char(116),char(77),char(111),char(116),char(105),char(111),char(110),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111), +char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(77),char(111),char(116),char(105),char(111), +char(110),char(50),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111), +char(110),char(116),char(97),char(99),char(116),char(67),char(70),char(77),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67), +char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101),char(100),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(83), +char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116), +char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(69),char(82),char(80),char(91),char(52),char(93),char(0),char(109), +char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101),char(100),char(67), +char(111),char(110),char(116),char(97),char(99),char(116),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(49),char(91),char(52),char(93),char(0),char(109),char(95), +char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(67),char(70), +char(77),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(76),char(105),char(102), +char(101),char(84),char(105),char(109),char(101),char(91),char(52),char(93),char(0),char(109),char(95),char(110),char(117),char(109),char(67),char(97),char(99),char(104),char(101),char(100), +char(80),char(111),char(105),char(110),char(116),char(115),char(0),char(109),char(95),char(99),char(111),char(109),char(112),char(97),char(110),char(105),char(111),char(110),char(73),char(100), +char(65),char(0),char(109),char(95),char(99),char(111),char(109),char(112),char(97),char(110),char(105),char(111),char(110),char(73),char(100),char(66),char(0),char(109),char(95),char(105), +char(110),char(100),char(101),char(120),char(49),char(97),char(0),char(109),char(95),char(111),char(98),char(106),char(101),char(99),char(116),char(84),char(121),char(112),char(101),char(0), +char(109),char(95),char(99),char(111),char(110),char(116),char(97),char(99),char(116),char(66),char(114),char(101),char(97),char(107),char(105),char(110),char(103),char(84),char(104),char(114), +char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(99),char(111),char(110),char(116),char(97),char(99),char(116),char(80),char(114),char(111),char(99), +char(101),char(115),char(115),char(105),char(110),char(103),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(42),char(109),char(95),char(98), +char(111),char(100),char(121),char(48),char(0),char(42),char(109),char(95),char(98),char(111),char(100),char(121),char(49),char(0),char(109),char(95),char(103),char(105),char(109),char(112), +char(97),char(99),char(116),char(83),char(117),char(98),char(84),char(121),char(112),char(101),char(0),char(42),char(109),char(95),char(117),char(110),char(115),char(99),char(97),char(108), +char(101),char(100),char(80),char(111),char(105),char(110),char(116),char(115),char(70),char(108),char(111),char(97),char(116),char(80),char(116),char(114),char(0),char(42),char(109),char(95), +char(117),char(110),char(115),char(99),char(97),char(108),char(101),char(100),char(80),char(111),char(105),char(110),char(116),char(115),char(68),char(111),char(117),char(98),char(108),char(101), +char(80),char(116),char(114),char(0),char(109),char(95),char(110),char(117),char(109),char(85),char(110),char(115),char(99),char(97),char(108),char(101),char(100),char(80),char(111),char(105), +char(110),char(116),char(115),char(0),char(109),char(95),char(112),char(97),char(100),char(100),char(105),char(110),char(103),char(51),char(91),char(52),char(93),char(0),char(42),char(109), +char(95),char(98),char(114),char(111),char(97),char(100),char(112),char(104),char(97),char(115),char(101),char(72),char(97),char(110),char(100),char(108),char(101),char(0),char(42),char(109), +char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(83),char(104),char(97),char(112),char(101),char(0),char(42),char(109),char(95),char(114), +char(111),char(111),char(116),char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(83),char(104),char(97),char(112),char(101),char(0),char(109),char(95), +char(119),char(111),char(114),char(108),char(100),char(84),char(114),char(97),char(110),char(115),char(102),char(111),char(114),char(109),char(0),char(109),char(95),char(105),char(110),char(116), +char(101),char(114),char(112),char(111),char(108),char(97),char(116),char(105),char(111),char(110),char(87),char(111),char(114),char(108),char(100),char(84),char(114),char(97),char(110),char(115), +char(102),char(111),char(114),char(109),char(0),char(109),char(95),char(105),char(110),char(116),char(101),char(114),char(112),char(111),char(108),char(97),char(116),char(105),char(111),char(110), +char(76),char(105),char(110),char(101),char(97),char(114),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(105),char(110),char(116), +char(101),char(114),char(112),char(111),char(108),char(97),char(116),char(105),char(111),char(110),char(65),char(110),char(103),char(117),char(108),char(97),char(114),char(86),char(101),char(108), +char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(97),char(110),char(105),char(115),char(111),char(116),char(114),char(111),char(112),char(105),char(99),char(70), +char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(100),char(101),char(97),char(99),char(116),char(105),char(118),char(97),char(116),char(105), +char(111),char(110),char(84),char(105),char(109),char(101),char(0),char(109),char(95),char(102),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95), +char(114),char(111),char(108),char(108),char(105),char(110),char(103),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(99),char(111), +char(110),char(116),char(97),char(99),char(116),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(99),char(111),char(110),char(116),char(97), +char(99),char(116),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(114),char(101),char(115),char(116),char(105),char(116), +char(117),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(104),char(105),char(116),char(70),char(114),char(97),char(99),char(116),char(105),char(111),char(110),char(0), +char(109),char(95),char(99),char(99),char(100),char(83),char(119),char(101),char(112),char(116),char(83),char(112),char(104),char(101),char(114),char(101),char(82),char(97),char(100),char(105), +char(117),char(115),char(0),char(109),char(95),char(99),char(99),char(100),char(77),char(111),char(116),char(105),char(111),char(110),char(84),char(104),char(114),char(101),char(115),char(104), +char(111),char(108),char(100),char(0),char(109),char(95),char(104),char(97),char(115),char(65),char(110),char(105),char(115),char(111),char(116),char(114),char(111),char(112),char(105),char(99), +char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110), +char(70),char(108),char(97),char(103),char(115),char(0),char(109),char(95),char(105),char(115),char(108),char(97),char(110),char(100),char(84),char(97),char(103),char(49),char(0),char(109), +char(95),char(99),char(111),char(109),char(112),char(97),char(110),char(105),char(111),char(110),char(73),char(100),char(0),char(109),char(95),char(97),char(99),char(116),char(105),char(118), +char(97),char(116),char(105),char(111),char(110),char(83),char(116),char(97),char(116),char(101),char(49),char(0),char(109),char(95),char(105),char(110),char(116),char(101),char(114),char(110), +char(97),char(108),char(84),char(121),char(112),char(101),char(0),char(109),char(95),char(99),char(104),char(101),char(99),char(107),char(67),char(111),char(108),char(108),char(105),char(100), +char(101),char(87),char(105),char(116),char(104),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(70),char(105),char(108), +char(116),char(101),char(114),char(71),char(114),char(111),char(117),char(112),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110), +char(70),char(105),char(108),char(116),char(101),char(114),char(77),char(97),char(115),char(107),char(0),char(109),char(95),char(117),char(110),char(105),char(113),char(117),char(101),char(73), +char(100),char(0),char(109),char(95),char(116),char(97),char(117),char(0),char(109),char(95),char(100),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95), +char(116),char(105),char(109),char(101),char(83),char(116),char(101),char(112),char(0),char(109),char(95),char(109),char(97),char(120),char(69),char(114),char(114),char(111),char(114),char(82), +char(101),char(100),char(117),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(115),char(111),char(114),char(0),char(109),char(95),char(101),char(114),char(112), +char(0),char(109),char(95),char(101),char(114),char(112),char(50),char(0),char(109),char(95),char(103),char(108),char(111),char(98),char(97),char(108),char(67),char(102),char(109),char(0), +char(109),char(95),char(115),char(112),char(108),char(105),char(116),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(80),char(101),char(110),char(101),char(116),char(114), +char(97),char(116),char(105),char(111),char(110),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(115),char(112),char(108), +char(105),char(116),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(84),char(117),char(114),char(110),char(69),char(114),char(112),char(0),char(109),char(95),char(108), +char(105),char(110),char(101),char(97),char(114),char(83),char(108),char(111),char(112),char(0),char(109),char(95),char(119),char(97),char(114),char(109),char(115),char(116),char(97),char(114), +char(116),char(105),char(110),char(103),char(70),char(97),char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(97),char(114),char(116),char(105),char(99),char(117),char(108), +char(97),char(116),char(101),char(100),char(87),char(97),char(114),char(109),char(115),char(116),char(97),char(114),char(116),char(105),char(110),char(103),char(70),char(97),char(99),char(116), +char(111),char(114),char(0),char(109),char(95),char(109),char(97),char(120),char(71),char(121),char(114),char(111),char(115),char(99),char(111),char(112),char(105),char(99),char(70),char(111), +char(114),char(99),char(101),char(0),char(109),char(95),char(115),char(105),char(110),char(103),char(108),char(101),char(65),char(120),char(105),char(115),char(82),char(111),char(108),char(108), +char(105),char(110),char(103),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100), +char(0),char(109),char(95),char(110),char(117),char(109),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95),char(115), +char(111),char(108),char(118),char(101),char(114),char(77),char(111),char(100),char(101),char(0),char(109),char(95),char(114),char(101),char(115),char(116),char(105),char(110),char(103),char(67), +char(111),char(110),char(116),char(97),char(99),char(116),char(82),char(101),char(115),char(116),char(105),char(116),char(117),char(116),char(105),char(111),char(110),char(84),char(104),char(114), +char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(109),char(105),char(110),char(105),char(109),char(117),char(109),char(83),char(111),char(108),char(118), +char(101),char(114),char(66),char(97),char(116),char(99),char(104),char(83),char(105),char(122),char(101),char(0),char(109),char(95),char(115),char(112),char(108),char(105),char(116),char(73), +char(109),char(112),char(117),char(108),char(115),char(101),char(0),char(109),char(95),char(115),char(111),char(108),char(118),char(101),char(114),char(73),char(110),char(102),char(111),char(0), +char(109),char(95),char(103),char(114),char(97),char(118),char(105),char(116),char(121),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111), +char(110),char(79),char(98),char(106),char(101),char(99),char(116),char(68),char(97),char(116),char(97),char(0),char(109),char(95),char(105),char(110),char(118),char(73),char(110),char(101), +char(114),char(116),char(105),char(97),char(84),char(101),char(110),char(115),char(111),char(114),char(87),char(111),char(114),char(108),char(100),char(0),char(109),char(95),char(108),char(105), +char(110),char(101),char(97),char(114),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108), +char(97),char(114),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114), +char(70),char(97),char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(70),char(97),char(99),char(116),char(111), +char(114),char(0),char(109),char(95),char(103),char(114),char(97),char(118),char(105),char(116),char(121),char(95),char(97),char(99),char(99),char(101),char(108),char(101),char(114),char(97), +char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(105),char(110),char(118),char(73),char(110),char(101),char(114),char(116),char(105),char(97),char(76),char(111),char(99), +char(97),char(108),char(0),char(109),char(95),char(116),char(111),char(116),char(97),char(108),char(70),char(111),char(114),char(99),char(101),char(0),char(109),char(95),char(116),char(111), +char(116),char(97),char(108),char(84),char(111),char(114),char(113),char(117),char(101),char(0),char(109),char(95),char(105),char(110),char(118),char(101),char(114),char(115),char(101),char(77), +char(97),char(115),char(115),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(0), +char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(97), +char(100),char(100),char(105),char(116),char(105),char(111),char(110),char(97),char(108),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(70),char(97),char(99),char(116), +char(111),char(114),char(0),char(109),char(95),char(97),char(100),char(100),char(105),char(116),char(105),char(111),char(110),char(97),char(108),char(76),char(105),char(110),char(101),char(97), +char(114),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(83),char(113),char(114), +char(0),char(109),char(95),char(97),char(100),char(100),char(105),char(116),char(105),char(111),char(110),char(97),char(108),char(65),char(110),char(103),char(117),char(108),char(97),char(114), +char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(83),char(113),char(114),char(0), +char(109),char(95),char(97),char(100),char(100),char(105),char(116),char(105),char(111),char(110),char(97),char(108),char(65),char(110),char(103),char(117),char(108),char(97),char(114),char(68), +char(97),char(109),char(112),char(105),char(110),char(103),char(70),char(97),char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97), +char(114),char(83),char(108),char(101),char(101),char(112),char(105),char(110),char(103),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109), +char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83),char(108),char(101),char(101),char(112),char(105),char(110),char(103),char(84),char(104),char(114),char(101), +char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(97),char(100),char(100),char(105),char(116),char(105),char(111),char(110),char(97),char(108),char(68),char(97), +char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(110),char(117),char(109),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110), +char(116),char(82),char(111),char(119),char(115),char(0),char(110),char(117),char(98),char(0),char(42),char(109),char(95),char(114),char(98),char(65),char(0),char(42),char(109),char(95), +char(114),char(98),char(66),char(0),char(109),char(95),char(117),char(115),char(101),char(114),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116), +char(84),char(121),char(112),char(101),char(0),char(109),char(95),char(117),char(115),char(101),char(114),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110), +char(116),char(73),char(100),char(0),char(109),char(95),char(110),char(101),char(101),char(100),char(115),char(70),char(101),char(101),char(100),char(98),char(97),char(99),char(107),char(0), +char(109),char(95),char(97),char(112),char(112),char(108),char(105),char(101),char(100),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(0),char(109),char(95),char(100), +char(98),char(103),char(68),char(114),char(97),char(119),char(83),char(105),char(122),char(101),char(0),char(109),char(95),char(100),char(105),char(115),char(97),char(98),char(108),char(101), +char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(115),char(66),char(101),char(116),char(119),char(101),char(101),char(110),char(76),char(105),char(110), +char(107),char(101),char(100),char(66),char(111),char(100),char(105),char(101),char(115),char(0),char(109),char(95),char(111),char(118),char(101),char(114),char(114),char(105),char(100),char(101), +char(78),char(117),char(109),char(83),char(111),char(108),char(118),char(101),char(114),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0), +char(109),char(95),char(98),char(114),char(101),char(97),char(107),char(105),char(110),char(103),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(84),char(104),char(114), +char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(105),char(115),char(69),char(110),char(97),char(98),char(108),char(101),char(100),char(0),char(112), +char(97),char(100),char(100),char(105),char(110),char(103),char(91),char(52),char(93),char(0),char(109),char(95),char(116),char(121),char(112),char(101),char(67),char(111),char(110),char(115), +char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(97),char(116),char(97),char(0),char(109),char(95),char(112),char(105),char(118),char(111),char(116),char(73),char(110), +char(65),char(0),char(109),char(95),char(112),char(105),char(118),char(111),char(116),char(73),char(110),char(66),char(0),char(109),char(95),char(114),char(98),char(65),char(70),char(114), +char(97),char(109),char(101),char(0),char(109),char(95),char(114),char(98),char(66),char(70),char(114),char(97),char(109),char(101),char(0),char(109),char(95),char(117),char(115),char(101), +char(82),char(101),char(102),char(101),char(114),char(101),char(110),char(99),char(101),char(70),char(114),char(97),char(109),char(101),char(65),char(0),char(109),char(95),char(97),char(110), +char(103),char(117),char(108),char(97),char(114),char(79),char(110),char(108),char(121),char(0),char(109),char(95),char(101),char(110),char(97),char(98),char(108),char(101),char(65),char(110), +char(103),char(117),char(108),char(97),char(114),char(77),char(111),char(116),char(111),char(114),char(0),char(109),char(95),char(109),char(111),char(116),char(111),char(114),char(84),char(97), +char(114),char(103),char(101),char(116),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(109),char(97),char(120),char(77),char(111), +char(116),char(111),char(114),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(0),char(109),char(95),char(108),char(111),char(119),char(101),char(114),char(76),char(105), +char(109),char(105),char(116),char(0),char(109),char(95),char(117),char(112),char(112),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95),char(108), +char(105),char(109),char(105),char(116),char(83),char(111),char(102),char(116),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(98),char(105),char(97),char(115),char(70), +char(97),char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(114),char(101),char(108),char(97),char(120),char(97),char(116),char(105),char(111),char(110),char(70),char(97), +char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(112),char(97),char(100),char(100),char(105),char(110),char(103),char(49),char(91),char(52),char(93),char(0),char(109), +char(95),char(115),char(119),char(105),char(110),char(103),char(83),char(112),char(97),char(110),char(49),char(0),char(109),char(95),char(115),char(119),char(105),char(110),char(103),char(83), +char(112),char(97),char(110),char(50),char(0),char(109),char(95),char(116),char(119),char(105),char(115),char(116),char(83),char(112),char(97),char(110),char(0),char(109),char(95),char(108), +char(105),char(110),char(101),char(97),char(114),char(85),char(112),char(112),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95),char(108),char(105), +char(110),char(101),char(97),char(114),char(76),char(111),char(119),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95),char(97),char(110),char(103), +char(117),char(108),char(97),char(114),char(85),char(112),char(112),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95),char(97),char(110),char(103), +char(117),char(108),char(97),char(114),char(76),char(111),char(119),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95),char(117),char(115),char(101), +char(76),char(105),char(110),char(101),char(97),char(114),char(82),char(101),char(102),char(101),char(114),char(101),char(110),char(99),char(101),char(70),char(114),char(97),char(109),char(101), +char(65),char(0),char(109),char(95),char(117),char(115),char(101),char(79),char(102),char(102),char(115),char(101),char(116),char(70),char(111),char(114),char(67),char(111),char(110),char(115), +char(116),char(114),char(97),char(105),char(110),char(116),char(70),char(114),char(97),char(109),char(101),char(0),char(109),char(95),char(54),char(100),char(111),char(102),char(68),char(97), +char(116),char(97),char(0),char(109),char(95),char(115),char(112),char(114),char(105),char(110),char(103),char(69),char(110),char(97),char(98),char(108),char(101),char(100),char(91),char(54), +char(93),char(0),char(109),char(95),char(101),char(113),char(117),char(105),char(108),char(105),char(98),char(114),char(105),char(117),char(109),char(80),char(111),char(105),char(110),char(116), +char(91),char(54),char(93),char(0),char(109),char(95),char(115),char(112),char(114),char(105),char(110),char(103),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115), +char(115),char(91),char(54),char(93),char(0),char(109),char(95),char(115),char(112),char(114),char(105),char(110),char(103),char(68),char(97),char(109),char(112),char(105),char(110),char(103), +char(91),char(54),char(93),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(66),char(111),char(117),char(110),char(99),char(101),char(0),char(109), +char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(116),char(111),char(112),char(69),char(82),char(80),char(0),char(109),char(95),char(108),char(105),char(110), +char(101),char(97),char(114),char(83),char(116),char(111),char(112),char(67),char(70),char(77),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(77), +char(111),char(116),char(111),char(114),char(69),char(82),char(80),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(77),char(111),char(116),char(111), +char(114),char(67),char(70),char(77),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(84),char(97),char(114),char(103),char(101),char(116),char(86), +char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(77),char(97),char(120),char(77), +char(111),char(116),char(111),char(114),char(70),char(111),char(114),char(99),char(101),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(101), +char(114),char(118),char(111),char(84),char(97),char(114),char(103),char(101),char(116),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(112), +char(114),char(105),char(110),char(103),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(108),char(105),char(110),char(101), +char(97),char(114),char(83),char(112),char(114),char(105),char(110),char(103),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(108),char(105), +char(110),char(101),char(97),char(114),char(69),char(113),char(117),char(105),char(108),char(105),char(98),char(114),char(105),char(117),char(109),char(80),char(111),char(105),char(110),char(116), +char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(69),char(110),char(97),char(98),char(108),char(101),char(77),char(111),char(116),char(111),char(114), +char(91),char(52),char(93),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(101),char(114),char(118),char(111),char(77),char(111),char(116), +char(111),char(114),char(91),char(52),char(93),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(69),char(110),char(97),char(98),char(108),char(101), +char(83),char(112),char(114),char(105),char(110),char(103),char(91),char(52),char(93),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(112), +char(114),char(105),char(110),char(103),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115),char(76),char(105),char(109),char(105),char(116),char(101),char(100), +char(91),char(52),char(93),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(112),char(114),char(105),char(110),char(103),char(68),char(97), +char(109),char(112),char(105),char(110),char(103),char(76),char(105),char(109),char(105),char(116),char(101),char(100),char(91),char(52),char(93),char(0),char(109),char(95),char(97),char(110), +char(103),char(117),char(108),char(97),char(114),char(66),char(111),char(117),char(110),char(99),char(101),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97), +char(114),char(83),char(116),char(111),char(112),char(69),char(82),char(80),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83),char(116), +char(111),char(112),char(67),char(70),char(77),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(77),char(111),char(116),char(111),char(114), +char(69),char(82),char(80),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(77),char(111),char(116),char(111),char(114),char(67),char(70), +char(77),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(84),char(97),char(114),char(103),char(101),char(116),char(86),char(101),char(108), +char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(77),char(97),char(120),char(77),char(111), +char(116),char(111),char(114),char(70),char(111),char(114),char(99),char(101),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83),char(101), +char(114),char(118),char(111),char(84),char(97),char(114),char(103),char(101),char(116),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83), +char(112),char(114),char(105),char(110),char(103),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(97),char(110),char(103), +char(117),char(108),char(97),char(114),char(83),char(112),char(114),char(105),char(110),char(103),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95), +char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(69),char(113),char(117),char(105),char(108),char(105),char(98),char(114),char(105),char(117),char(109),char(80),char(111), +char(105),char(110),char(116),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(69),char(110),char(97),char(98),char(108),char(101),char(77), +char(111),char(116),char(111),char(114),char(91),char(52),char(93),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83),char(101),char(114), +char(118),char(111),char(77),char(111),char(116),char(111),char(114),char(91),char(52),char(93),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114), +char(69),char(110),char(97),char(98),char(108),char(101),char(83),char(112),char(114),char(105),char(110),char(103),char(91),char(52),char(93),char(0),char(109),char(95),char(97),char(110), +char(103),char(117),char(108),char(97),char(114),char(83),char(112),char(114),char(105),char(110),char(103),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115), +char(76),char(105),char(109),char(105),char(116),char(101),char(100),char(91),char(52),char(93),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114), +char(83),char(112),char(114),char(105),char(110),char(103),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(76),char(105),char(109),char(105),char(116),char(101),char(100), +char(91),char(52),char(93),char(0),char(109),char(95),char(114),char(111),char(116),char(97),char(116),char(101),char(79),char(114),char(100),char(101),char(114),char(0),char(109),char(95), +char(97),char(120),char(105),char(115),char(73),char(110),char(65),char(0),char(109),char(95),char(97),char(120),char(105),char(115),char(73),char(110),char(66),char(0),char(109),char(95), +char(114),char(97),char(116),char(105),char(111),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(116),char(105),char(102),char(102),char(110), +char(101),char(115),char(115),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83),char(116),char(105),char(102),char(102),char(110),char(101), +char(115),char(115),char(0),char(109),char(95),char(118),char(111),char(108),char(117),char(109),char(101),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115), +char(0),char(42),char(109),char(95),char(109),char(97),char(116),char(101),char(114),char(105),char(97),char(108),char(0),char(109),char(95),char(112),char(111),char(115),char(105),char(116), +char(105),char(111),char(110),char(0),char(109),char(95),char(112),char(114),char(101),char(118),char(105),char(111),char(117),char(115),char(80),char(111),char(115),char(105),char(116),char(105), +char(111),char(110),char(0),char(109),char(95),char(118),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(97),char(99),char(99),char(117), +char(109),char(117),char(108),char(97),char(116),char(101),char(100),char(70),char(111),char(114),char(99),char(101),char(0),char(109),char(95),char(110),char(111),char(114),char(109),char(97), +char(108),char(0),char(109),char(95),char(97),char(114),char(101),char(97),char(0),char(109),char(95),char(97),char(116),char(116),char(97),char(99),char(104),char(0),char(109),char(95), +char(110),char(111),char(100),char(101),char(73),char(110),char(100),char(105),char(99),char(101),char(115),char(91),char(50),char(93),char(0),char(109),char(95),char(114),char(101),char(115), +char(116),char(76),char(101),char(110),char(103),char(116),char(104),char(0),char(109),char(95),char(98),char(98),char(101),char(110),char(100),char(105),char(110),char(103),char(0),char(109), +char(95),char(110),char(111),char(100),char(101),char(73),char(110),char(100),char(105),char(99),char(101),char(115),char(91),char(51),char(93),char(0),char(109),char(95),char(114),char(101), +char(115),char(116),char(65),char(114),char(101),char(97),char(0),char(109),char(95),char(99),char(48),char(91),char(52),char(93),char(0),char(109),char(95),char(110),char(111),char(100), +char(101),char(73),char(110),char(100),char(105),char(99),char(101),char(115),char(91),char(52),char(93),char(0),char(109),char(95),char(114),char(101),char(115),char(116),char(86),char(111), +char(108),char(117),char(109),char(101),char(0),char(109),char(95),char(99),char(49),char(0),char(109),char(95),char(99),char(50),char(0),char(109),char(95),char(99),char(48),char(0), +char(109),char(95),char(108),char(111),char(99),char(97),char(108),char(70),char(114),char(97),char(109),char(101),char(0),char(42),char(109),char(95),char(114),char(105),char(103),char(105), +char(100),char(66),char(111),char(100),char(121),char(0),char(109),char(95),char(110),char(111),char(100),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109),char(95), +char(97),char(101),char(114),char(111),char(77),char(111),char(100),char(101),char(108),char(0),char(109),char(95),char(98),char(97),char(117),char(109),char(103),char(97),char(114),char(116), +char(101),char(0),char(109),char(95),char(100),char(114),char(97),char(103),char(0),char(109),char(95),char(108),char(105),char(102),char(116),char(0),char(109),char(95),char(112),char(114), +char(101),char(115),char(115),char(117),char(114),char(101),char(0),char(109),char(95),char(118),char(111),char(108),char(117),char(109),char(101),char(0),char(109),char(95),char(100),char(121), +char(110),char(97),char(109),char(105),char(99),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(112),char(111),char(115),char(101), +char(77),char(97),char(116),char(99),char(104),char(0),char(109),char(95),char(114),char(105),char(103),char(105),char(100),char(67),char(111),char(110),char(116),char(97),char(99),char(116), +char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(107),char(105),char(110),char(101),char(116),char(105),char(99),char(67),char(111), +char(110),char(116),char(97),char(99),char(116),char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(115),char(111),char(102),char(116), +char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(97),char(110), +char(99),char(104),char(111),char(114),char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(115),char(111),char(102),char(116),char(82), +char(105),char(103),char(105),char(100),char(67),char(108),char(117),char(115),char(116),char(101),char(114),char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0), +char(109),char(95),char(115),char(111),char(102),char(116),char(75),char(105),char(110),char(101),char(116),char(105),char(99),char(67),char(108),char(117),char(115),char(116),char(101),char(114), +char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(115),char(111),char(102),char(116),char(83),char(111),char(102),char(116),char(67), +char(108),char(117),char(115),char(116),char(101),char(114),char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(115),char(111),char(102), +char(116),char(82),char(105),char(103),char(105),char(100),char(67),char(108),char(117),char(115),char(116),char(101),char(114),char(73),char(109),char(112),char(117),char(108),char(115),char(101), +char(83),char(112),char(108),char(105),char(116),char(0),char(109),char(95),char(115),char(111),char(102),char(116),char(75),char(105),char(110),char(101),char(116),char(105),char(99),char(67), +char(108),char(117),char(115),char(116),char(101),char(114),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(83),char(112),char(108),char(105),char(116),char(0),char(109), +char(95),char(115),char(111),char(102),char(116),char(83),char(111),char(102),char(116),char(67),char(108),char(117),char(115),char(116),char(101),char(114),char(73),char(109),char(112),char(117), +char(108),char(115),char(101),char(83),char(112),char(108),char(105),char(116),char(0),char(109),char(95),char(109),char(97),char(120),char(86),char(111),char(108),char(117),char(109),char(101), +char(0),char(109),char(95),char(116),char(105),char(109),char(101),char(83),char(99),char(97),char(108),char(101),char(0),char(109),char(95),char(118),char(101),char(108),char(111),char(99), +char(105),char(116),char(121),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95),char(112),char(111),char(115),char(105), +char(116),char(105),char(111),char(110),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95),char(100),char(114),char(105), +char(102),char(116),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95),char(99),char(108),char(117),char(115),char(116), +char(101),char(114),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95),char(114),char(111),char(116),char(0),char(109), +char(95),char(115),char(99),char(97),char(108),char(101),char(0),char(109),char(95),char(97),char(113),char(113),char(0),char(109),char(95),char(99),char(111),char(109),char(0),char(42), +char(109),char(95),char(112),char(111),char(115),char(105),char(116),char(105),char(111),char(110),char(115),char(0),char(42),char(109),char(95),char(119),char(101),char(105),char(103),char(104), +char(116),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(80),char(111),char(115),char(105),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95), +char(110),char(117),char(109),char(87),char(101),char(105),char(103),char(116),char(115),char(0),char(109),char(95),char(98),char(118),char(111),char(108),char(117),char(109),char(101),char(0), +char(109),char(95),char(98),char(102),char(114),char(97),char(109),char(101),char(0),char(109),char(95),char(102),char(114),char(97),char(109),char(101),char(120),char(102),char(111),char(114), +char(109),char(0),char(109),char(95),char(108),char(111),char(99),char(105),char(105),char(0),char(109),char(95),char(105),char(110),char(118),char(119),char(105),char(0),char(109),char(95), +char(118),char(105),char(109),char(112),char(117),char(108),char(115),char(101),char(115),char(91),char(50),char(93),char(0),char(109),char(95),char(100),char(105),char(109),char(112),char(117), +char(108),char(115),char(101),char(115),char(91),char(50),char(93),char(0),char(109),char(95),char(108),char(118),char(0),char(109),char(95),char(97),char(118),char(0),char(42),char(109), +char(95),char(102),char(114),char(97),char(109),char(101),char(114),char(101),char(102),char(115),char(0),char(42),char(109),char(95),char(110),char(111),char(100),char(101),char(73),char(110), +char(100),char(105),char(99),char(101),char(115),char(0),char(42),char(109),char(95),char(109),char(97),char(115),char(115),char(101),char(115),char(0),char(109),char(95),char(110),char(117), +char(109),char(70),char(114),char(97),char(109),char(101),char(82),char(101),char(102),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(78),char(111),char(100),char(101), +char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(77),char(97),char(115),char(115),char(101),char(115),char(0),char(109),char(95),char(105),char(100),char(109),char(97), +char(115),char(115),char(0),char(109),char(95),char(105),char(109),char(97),char(115),char(115),char(0),char(109),char(95),char(110),char(118),char(105),char(109),char(112),char(117),char(108), +char(115),char(101),char(115),char(0),char(109),char(95),char(110),char(100),char(105),char(109),char(112),char(117),char(108),char(115),char(101),char(115),char(0),char(109),char(95),char(110), +char(100),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(108),char(100),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109), +char(95),char(97),char(100),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(109),char(97),char(116),char(99),char(104),char(105),char(110),char(103), +char(0),char(109),char(95),char(109),char(97),char(120),char(83),char(101),char(108),char(102),char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(73), +char(109),char(112),char(117),char(108),char(115),char(101),char(0),char(109),char(95),char(115),char(101),char(108),char(102),char(67),char(111),char(108),char(108),char(105),char(115),char(105), +char(111),char(110),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(70),char(97),char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(99),char(111), +char(110),char(116),char(97),char(105),char(110),char(115),char(65),char(110),char(99),char(104),char(111),char(114),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105), +char(100),char(101),char(0),char(109),char(95),char(99),char(108),char(117),char(115),char(116),char(101),char(114),char(73),char(110),char(100),char(101),char(120),char(0),char(42),char(109), +char(95),char(98),char(111),char(100),char(121),char(65),char(0),char(42),char(109),char(95),char(98),char(111),char(100),char(121),char(66),char(0),char(109),char(95),char(114),char(101), +char(102),char(115),char(91),char(50),char(93),char(0),char(109),char(95),char(99),char(102),char(109),char(0),char(109),char(95),char(115),char(112),char(108),char(105),char(116),char(0), +char(109),char(95),char(100),char(101),char(108),char(101),char(116),char(101),char(0),char(109),char(95),char(114),char(101),char(108),char(80),char(111),char(115),char(105),char(116),char(105), +char(111),char(110),char(91),char(50),char(93),char(0),char(109),char(95),char(98),char(111),char(100),char(121),char(65),char(116),char(121),char(112),char(101),char(0),char(109),char(95), +char(98),char(111),char(100),char(121),char(66),char(116),char(121),char(112),char(101),char(0),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(84),char(121),char(112), +char(101),char(0),char(42),char(109),char(95),char(112),char(111),char(115),char(101),char(0),char(42),char(42),char(109),char(95),char(109),char(97),char(116),char(101),char(114),char(105), +char(97),char(108),char(115),char(0),char(42),char(109),char(95),char(110),char(111),char(100),char(101),char(115),char(0),char(42),char(109),char(95),char(108),char(105),char(110),char(107), +char(115),char(0),char(42),char(109),char(95),char(102),char(97),char(99),char(101),char(115),char(0),char(42),char(109),char(95),char(116),char(101),char(116),char(114),char(97),char(104), +char(101),char(100),char(114),char(97),char(0),char(42),char(109),char(95),char(97),char(110),char(99),char(104),char(111),char(114),char(115),char(0),char(42),char(109),char(95),char(99), +char(108),char(117),char(115),char(116),char(101),char(114),char(115),char(0),char(42),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(115),char(0),char(109),char(95), +char(110),char(117),char(109),char(77),char(97),char(116),char(101),char(114),char(105),char(97),char(108),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(76),char(105), +char(110),char(107),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(70),char(97),char(99),char(101),char(115),char(0),char(109),char(95),char(110),char(117),char(109), +char(84),char(101),char(116),char(114),char(97),char(104),char(101),char(100),char(114),char(97),char(0),char(109),char(95),char(110),char(117),char(109),char(65),char(110),char(99),char(104), +char(111),char(114),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(67),char(108),char(117),char(115),char(116),char(101),char(114),char(115),char(0),char(109),char(95), +char(110),char(117),char(109),char(74),char(111),char(105),char(110),char(116),char(115),char(0),char(109),char(95),char(99),char(111),char(110),char(102),char(105),char(103),char(0),char(109), +char(95),char(122),char(101),char(114),char(111),char(82),char(111),char(116),char(80),char(97),char(114),char(101),char(110),char(116),char(84),char(111),char(84),char(104),char(105),char(115), +char(0),char(109),char(95),char(112),char(97),char(114),char(101),char(110),char(116),char(67),char(111),char(109),char(84),char(111),char(84),char(104),char(105),char(115),char(80),char(105), +char(118),char(111),char(116),char(79),char(102),char(102),char(115),char(101),char(116),char(0),char(109),char(95),char(116),char(104),char(105),char(115),char(80),char(105),char(118),char(111), +char(116),char(84),char(111),char(84),char(104),char(105),char(115),char(67),char(111),char(109),char(79),char(102),char(102),char(115),char(101),char(116),char(0),char(109),char(95),char(106), +char(111),char(105),char(110),char(116),char(65),char(120),char(105),char(115),char(84),char(111),char(112),char(91),char(54),char(93),char(0),char(109),char(95),char(106),char(111),char(105), +char(110),char(116),char(65),char(120),char(105),char(115),char(66),char(111),char(116),char(116),char(111),char(109),char(91),char(54),char(93),char(0),char(109),char(95),char(108),char(105), +char(110),char(107),char(73),char(110),char(101),char(114),char(116),char(105),char(97),char(0),char(109),char(95),char(97),char(98),char(115),char(70),char(114),char(97),char(109),char(101), +char(84),char(111),char(116),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(84),char(111),char(112),char(0),char(109),char(95),char(97),char(98),char(115), +char(70),char(114),char(97),char(109),char(101),char(84),char(111),char(116),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(66),char(111),char(116),char(116), +char(111),char(109),char(0),char(109),char(95),char(97),char(98),char(115),char(70),char(114),char(97),char(109),char(101),char(76),char(111),char(99),char(86),char(101),char(108),char(111), +char(99),char(105),char(116),char(121),char(84),char(111),char(112),char(0),char(109),char(95),char(97),char(98),char(115),char(70),char(114),char(97),char(109),char(101),char(76),char(111), +char(99),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(66),char(111),char(116),char(116),char(111),char(109),char(0),char(109),char(95),char(108),char(105), +char(110),char(107),char(77),char(97),char(115),char(115),char(0),char(109),char(95),char(112),char(97),char(114),char(101),char(110),char(116),char(73),char(110),char(100),char(101),char(120), +char(0),char(109),char(95),char(100),char(111),char(102),char(67),char(111),char(117),char(110),char(116),char(0),char(109),char(95),char(112),char(111),char(115),char(86),char(97),char(114), +char(67),char(111),char(117),char(110),char(116),char(0),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(80),char(111),char(115),char(91),char(55),char(93),char(0), +char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(86),char(101),char(108),char(91),char(54),char(93),char(0),char(109),char(95),char(106),char(111),char(105),char(110), +char(116),char(84),char(111),char(114),char(113),char(117),char(101),char(91),char(54),char(93),char(0),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(68),char(97), +char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(70),char(114),char(105),char(99),char(116),char(105),char(111), +char(110),char(0),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(76),char(111),char(119),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0), +char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(85),char(112),char(112),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95), +char(106),char(111),char(105),char(110),char(116),char(77),char(97),char(120),char(70),char(111),char(114),char(99),char(101),char(0),char(109),char(95),char(106),char(111),char(105),char(110), +char(116),char(77),char(97),char(120),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(42),char(109),char(95),char(108),char(105),char(110),char(107), +char(78),char(97),char(109),char(101),char(0),char(42),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(78),char(97),char(109),char(101),char(0),char(42),char(109), +char(95),char(108),char(105),char(110),char(107),char(67),char(111),char(108),char(108),char(105),char(100),char(101),char(114),char(0),char(42),char(109),char(95),char(112),char(97),char(100), +char(100),char(105),char(110),char(103),char(80),char(116),char(114),char(0),char(109),char(95),char(98),char(97),char(115),char(101),char(87),char(111),char(114),char(108),char(100),char(80), +char(111),char(115),char(105),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(98),char(97),char(115),char(101),char(87),char(111),char(114),char(108),char(100),char(79), +char(114),char(105),char(101),char(110),char(116),char(97),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(98),char(97),char(115),char(101),char(76),char(105),char(110), +char(101),char(97),char(114),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(98),char(97),char(115),char(101),char(65),char(110), +char(103),char(117),char(108),char(97),char(114),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(98),char(97),char(115),char(101), +char(73),char(110),char(101),char(114),char(116),char(105),char(97),char(0),char(109),char(95),char(98),char(97),char(115),char(101),char(77),char(97),char(115),char(115),char(0),char(42), +char(109),char(95),char(98),char(97),char(115),char(101),char(78),char(97),char(109),char(101),char(0),char(42),char(109),char(95),char(98),char(97),char(115),char(101),char(67),char(111), +char(108),char(108),char(105),char(100),char(101),char(114),char(0),char(109),char(95),char(99),char(111),char(108),char(79),char(98),char(106),char(68),char(97),char(116),char(97),char(0), +char(42),char(109),char(95),char(109),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(0),char(109),char(95),char(108),char(105),char(110),char(107),char(0), +char(84),char(89),char(80),char(69),char(99),char(0),char(0),char(0),char(99),char(104),char(97),char(114),char(0),char(117),char(99),char(104),char(97),char(114),char(0),char(115), +char(104),char(111),char(114),char(116),char(0),char(117),char(115),char(104),char(111),char(114),char(116),char(0),char(105),char(110),char(116),char(0),char(108),char(111),char(110),char(103), +char(0),char(117),char(108),char(111),char(110),char(103),char(0),char(102),char(108),char(111),char(97),char(116),char(0),char(100),char(111),char(117),char(98),char(108),char(101),char(0), +char(118),char(111),char(105),char(100),char(0),char(80),char(111),char(105),char(110),char(116),char(101),char(114),char(65),char(114),char(114),char(97),char(121),char(0),char(98),char(116), +char(80),char(104),char(121),char(115),char(105),char(99),char(115),char(83),char(121),char(115),char(116),char(101),char(109),char(0),char(76),char(105),char(115),char(116),char(66),char(97), +char(115),char(101),char(0),char(98),char(116),char(86),char(101),char(99),char(116),char(111),char(114),char(51),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116), +char(97),char(0),char(98),char(116),char(86),char(101),char(99),char(116),char(111),char(114),char(51),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116), +char(97),char(0),char(98),char(116),char(81),char(117),char(97),char(116),char(101),char(114),char(110),char(105),char(111),char(110),char(70),char(108),char(111),char(97),char(116),char(68), +char(97),char(116),char(97),char(0),char(98),char(116),char(81),char(117),char(97),char(116),char(101),char(114),char(110),char(105),char(111),char(110),char(68),char(111),char(117),char(98), +char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(97),char(116),char(114),char(105),char(120),char(51),char(120),char(51),char(70),char(108), +char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(97),char(116),char(114),char(105),char(120),char(51),char(120),char(51),char(68), +char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(84),char(114),char(97),char(110),char(115),char(102),char(111),char(114), +char(109),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(84),char(114),char(97),char(110),char(115),char(102),char(111), +char(114),char(109),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(66),char(118),char(104),char(83),char(117), +char(98),char(116),char(114),char(101),char(101),char(73),char(110),char(102),char(111),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(79),char(112),char(116),char(105), +char(109),char(105),char(122),char(101),char(100),char(66),char(118),char(104),char(78),char(111),char(100),char(101),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116), +char(97),char(0),char(98),char(116),char(79),char(112),char(116),char(105),char(109),char(105),char(122),char(101),char(100),char(66),char(118),char(104),char(78),char(111),char(100),char(101), +char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(81),char(117),char(97),char(110),char(116),char(105),char(122), +char(101),char(100),char(66),char(118),char(104),char(78),char(111),char(100),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(81),char(117),char(97),char(110), +char(116),char(105),char(122),char(101),char(100),char(66),char(118),char(104),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116), +char(81),char(117),char(97),char(110),char(116),char(105),char(122),char(101),char(100),char(66),char(118),char(104),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97), +char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(83),char(104),char(97),char(112),char(101),char(68), +char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(116),char(97),char(116),char(105),char(99),char(80),char(108),char(97),char(110),char(101),char(83),char(104),char(97), +char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(110),char(118),char(101),char(120),char(73),char(110),char(116),char(101),char(114), +char(110),char(97),char(108),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(80),char(111),char(115),char(105),char(116), +char(105),char(111),char(110),char(65),char(110),char(100),char(82),char(97),char(100),char(105),char(117),char(115),char(0),char(98),char(116),char(77),char(117),char(108),char(116),char(105), +char(83),char(112),char(104),char(101),char(114),char(101),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(73),char(110), +char(116),char(73),char(110),char(100),char(101),char(120),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(104),char(111),char(114),char(116),char(73),char(110), +char(116),char(73),char(110),char(100),char(101),char(120),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(104),char(111),char(114),char(116),char(73),char(110), +char(116),char(73),char(110),char(100),char(101),char(120),char(84),char(114),char(105),char(112),char(108),char(101),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116), +char(67),char(104),char(97),char(114),char(73),char(110),char(100),char(101),char(120),char(84),char(114),char(105),char(112),char(108),char(101),char(116),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(77),char(101),char(115),char(104),char(80),char(97),char(114),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(116), +char(114),char(105),char(100),char(105),char(110),char(103),char(77),char(101),char(115),char(104),char(73),char(110),char(116),char(101),char(114),char(102),char(97),char(99),char(101),char(68), +char(97),char(116),char(97),char(0),char(98),char(116),char(84),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(77),char(101),char(115),char(104),char(83),char(104), +char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(84),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(73),char(110), +char(102),char(111),char(77),char(97),char(112),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(99),char(97),char(108),char(101),char(100),char(84),char(114), +char(105),char(97),char(110),char(103),char(108),char(101),char(77),char(101),char(115),char(104),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0), +char(98),char(116),char(67),char(111),char(109),char(112),char(111),char(117),char(110),char(100),char(83),char(104),char(97),char(112),char(101),char(67),char(104),char(105),char(108),char(100), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(109),char(112),char(111),char(117),char(110),char(100),char(83),char(104),char(97),char(112),char(101), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(121),char(108),char(105),char(110),char(100),char(101),char(114),char(83),char(104),char(97),char(112),char(101), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(110),char(101),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(67),char(97),char(112),char(115),char(117),char(108),char(101),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0), +char(98),char(116),char(84),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(73),char(110),char(102),char(111),char(68),char(97),char(116),char(97),char(0),char(98), +char(116),char(80),char(101),char(114),char(115),char(105),char(115),char(116),char(101),char(110),char(116),char(77),char(97),char(110),char(105),char(102),char(111),char(108),char(100),char(68), +char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111), +char(110),char(79),char(98),char(106),char(101),char(99),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116), +char(80),char(101),char(114),char(115),char(105),char(115),char(116),char(101),char(110),char(116),char(77),char(97),char(110),char(105),char(102),char(111),char(108),char(100),char(70),char(108), +char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(79), +char(98),char(106),char(101),char(99),char(116),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(71),char(73),char(109), +char(112),char(97),char(99),char(116),char(77),char(101),char(115),char(104),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116), +char(67),char(111),char(110),char(118),char(101),char(120),char(72),char(117),char(108),char(108),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0), +char(98),char(116),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(83),char(111),char(108),char(118),char(101),char(114),char(73),char(110),char(102),char(111),char(68), +char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(83), +char(111),char(108),char(118),char(101),char(114),char(73),char(110),char(102),char(111),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98), +char(116),char(68),char(121),char(110),char(97),char(109),char(105),char(99),char(115),char(87),char(111),char(114),char(108),char(100),char(68),char(111),char(117),char(98),char(108),char(101), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(68),char(121),char(110),char(97),char(109),char(105),char(99),char(115),char(87),char(111),char(114),char(108),char(100), +char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(82),char(105),char(103),char(105),char(100),char(66),char(111),char(100), +char(121),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(82),char(105),char(103),char(105),char(100),char(66),char(111), +char(100),char(121),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(110),char(115),char(116), +char(114),char(97),char(105),char(110),char(116),char(73),char(110),char(102),char(111),char(49),char(0),char(98),char(116),char(84),char(121),char(112),char(101),char(100),char(67),char(111), +char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116), +char(84),char(121),char(112),char(101),char(100),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(97),char(116),char(97),char(0), +char(98),char(116),char(82),char(105),char(103),char(105),char(100),char(66),char(111),char(100),char(121),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(84),char(121), +char(112),char(101),char(100),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68), +char(97),char(116),char(97),char(0),char(98),char(116),char(80),char(111),char(105),char(110),char(116),char(50),char(80),char(111),char(105),char(110),char(116),char(67),char(111),char(110), +char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(80), +char(111),char(105),char(110),char(116),char(50),char(80),char(111),char(105),char(110),char(116),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116), +char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(50),char(0),char(98),char(116),char(80),char(111),char(105),char(110),char(116),char(50), +char(80),char(111),char(105),char(110),char(116),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108), +char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(72),char(105),char(110),char(103),char(101),char(67),char(111),char(110),char(115),char(116),char(114),char(97), +char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(72),char(105),char(110),char(103), +char(101),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(72),char(105),char(110),char(103),char(101),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111), +char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(50),char(0),char(98),char(116),char(67),char(111),char(110),char(101),char(84),char(119),char(105),char(115), +char(116),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116), +char(97),char(0),char(98),char(116),char(67),char(111),char(110),char(101),char(84),char(119),char(105),char(115),char(116),char(67),char(111),char(110),char(115),char(116),char(114),char(97), +char(105),char(110),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(71),char(101),char(110),char(101),char(114),char(105),char(99),char(54),char(68),char(111), +char(102),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(71),char(101), +char(110),char(101),char(114),char(105),char(99),char(54),char(68),char(111),char(102),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68), +char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(50),char(0),char(98),char(116),char(71),char(101),char(110),char(101),char(114),char(105),char(99), +char(54),char(68),char(111),char(102),char(83),char(112),char(114),char(105),char(110),char(103),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(71),char(101),char(110),char(101),char(114),char(105),char(99),char(54),char(68),char(111),char(102),char(83),char(112), +char(114),char(105),char(110),char(103),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101), +char(68),char(97),char(116),char(97),char(50),char(0),char(98),char(116),char(71),char(101),char(110),char(101),char(114),char(105),char(99),char(54),char(68),char(111),char(102),char(83), +char(112),char(114),char(105),char(110),char(103),char(50),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(71),char(101),char(110),char(101),char(114),char(105),char(99),char(54),char(68),char(111),char(102),char(83),char(112),char(114),char(105),char(110),char(103), +char(50),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116), +char(97),char(50),char(0),char(98),char(116),char(83),char(108),char(105),char(100),char(101),char(114),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110), +char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(108),char(105),char(100),char(101),char(114),char(67),char(111),char(110),char(115),char(116),char(114), +char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(71),char(101),char(97), +char(114),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(71),char(101),char(97),char(114),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117), +char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(83),char(111),char(102),char(116),char(66),char(111),char(100),char(121),char(77),char(97),char(116),char(101), +char(114),char(105),char(97),char(108),char(68),char(97),char(116),char(97),char(0),char(83),char(111),char(102),char(116),char(66),char(111),char(100),char(121),char(78),char(111),char(100), +char(101),char(68),char(97),char(116),char(97),char(0),char(83),char(111),char(102),char(116),char(66),char(111),char(100),char(121),char(76),char(105),char(110),char(107),char(68),char(97), +char(116),char(97),char(0),char(83),char(111),char(102),char(116),char(66),char(111),char(100),char(121),char(70),char(97),char(99),char(101),char(68),char(97),char(116),char(97),char(0), +char(83),char(111),char(102),char(116),char(66),char(111),char(100),char(121),char(84),char(101),char(116),char(114),char(97),char(68),char(97),char(116),char(97),char(0),char(83),char(111), +char(102),char(116),char(82),char(105),char(103),char(105),char(100),char(65),char(110),char(99),char(104),char(111),char(114),char(68),char(97),char(116),char(97),char(0),char(83),char(111), +char(102),char(116),char(66),char(111),char(100),char(121),char(67),char(111),char(110),char(102),char(105),char(103),char(68),char(97),char(116),char(97),char(0),char(83),char(111),char(102), +char(116),char(66),char(111),char(100),char(121),char(80),char(111),char(115),char(101),char(68),char(97),char(116),char(97),char(0),char(83),char(111),char(102),char(116),char(66),char(111), +char(100),char(121),char(67),char(108),char(117),char(115),char(116),char(101),char(114),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(111),char(102),char(116), +char(66),char(111),char(100),char(121),char(74),char(111),char(105),char(110),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(111),char(102),char(116), +char(66),char(111),char(100),char(121),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(117),char(108),char(116), +char(105),char(66),char(111),char(100),char(121),char(76),char(105),char(110),char(107),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0), +char(98),char(116),char(77),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(76),char(105),char(110),char(107),char(70),char(108),char(111),char(97),char(116), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(68),char(111),char(117),char(98), +char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(70),char(108), +char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(76), +char(105),char(110),char(107),char(67),char(111),char(108),char(108),char(105),char(100),char(101),char(114),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(77),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(76),char(105),char(110),char(107),char(67),char(111),char(108),char(108), +char(105),char(100),char(101),char(114),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(0),char(84),char(76),char(69),char(78), +char(1),char(0),char(1),char(0),char(2),char(0),char(2),char(0),char(4),char(0),char(4),char(0),char(4),char(0),char(4),char(0),char(8),char(0),char(0),char(0), +char(12),char(0),char(36),char(0),char(8),char(0),char(16),char(0),char(32),char(0),char(16),char(0),char(32),char(0),char(48),char(0),char(96),char(0),char(64),char(0), +char(-128),char(0),char(20),char(0),char(48),char(0),char(80),char(0),char(16),char(0),char(84),char(0),char(-124),char(0),char(12),char(0),char(52),char(0),char(52),char(0), +char(20),char(0),char(64),char(0),char(4),char(0),char(4),char(0),char(8),char(0),char(4),char(0),char(32),char(0),char(28),char(0),char(60),char(0),char(56),char(0), +char(76),char(0),char(76),char(0),char(24),char(0),char(60),char(0),char(60),char(0),char(60),char(0),char(16),char(0),char(16),char(6),char(-24),char(1),char(72),char(3), +char(16),char(1),char(64),char(0),char(68),char(0),char(-96),char(0),char(88),char(0),char(-64),char(0),char(104),char(0),char(-8),char(1),char(-72),char(3),char(8),char(0), +char(52),char(0),char(52),char(0),char(0),char(0),char(68),char(0),char(84),char(0),char(-124),char(0),char(116),char(0),char(92),char(1),char(-36),char(0),char(-116),char(1), +char(124),char(1),char(-44),char(0),char(-4),char(0),char(-52),char(1),char(92),char(1),char(116),char(2),char(-124),char(2),char(-76),char(4),char(-52),char(0),char(108),char(1), +char(92),char(0),char(-116),char(0),char(16),char(0),char(100),char(0),char(20),char(0),char(36),char(0),char(100),char(0),char(92),char(0),char(104),char(0),char(-64),char(0), +char(92),char(1),char(104),char(0),char(-68),char(1),char(112),char(3),char(-56),char(1),char(-68),char(0),char(100),char(0),char(28),char(1),char(-12),char(1),char(0),char(0), +char(83),char(84),char(82),char(67),char(88),char(0),char(0),char(0),char(10),char(0),char(3),char(0),char(4),char(0),char(0),char(0),char(4),char(0),char(1),char(0), +char(9),char(0),char(2),char(0),char(11),char(0),char(3),char(0),char(10),char(0),char(3),char(0),char(10),char(0),char(4),char(0),char(10),char(0),char(5),char(0), +char(12),char(0),char(2),char(0),char(9),char(0),char(6),char(0),char(9),char(0),char(7),char(0),char(13),char(0),char(1),char(0),char(7),char(0),char(8),char(0), +char(14),char(0),char(1),char(0),char(8),char(0),char(8),char(0),char(15),char(0),char(1),char(0),char(7),char(0),char(8),char(0),char(16),char(0),char(1),char(0), +char(8),char(0),char(8),char(0),char(17),char(0),char(1),char(0),char(13),char(0),char(9),char(0),char(18),char(0),char(1),char(0),char(14),char(0),char(9),char(0), +char(19),char(0),char(2),char(0),char(17),char(0),char(10),char(0),char(13),char(0),char(11),char(0),char(20),char(0),char(2),char(0),char(18),char(0),char(10),char(0), +char(14),char(0),char(11),char(0),char(21),char(0),char(4),char(0),char(4),char(0),char(12),char(0),char(4),char(0),char(13),char(0),char(2),char(0),char(14),char(0), +char(2),char(0),char(15),char(0),char(22),char(0),char(6),char(0),char(13),char(0),char(16),char(0),char(13),char(0),char(17),char(0),char(4),char(0),char(18),char(0), +char(4),char(0),char(19),char(0),char(4),char(0),char(20),char(0),char(0),char(0),char(21),char(0),char(23),char(0),char(6),char(0),char(14),char(0),char(16),char(0), +char(14),char(0),char(17),char(0),char(4),char(0),char(18),char(0),char(4),char(0),char(19),char(0),char(4),char(0),char(20),char(0),char(0),char(0),char(21),char(0), +char(24),char(0),char(3),char(0),char(2),char(0),char(14),char(0),char(2),char(0),char(15),char(0),char(4),char(0),char(22),char(0),char(25),char(0),char(12),char(0), +char(13),char(0),char(23),char(0),char(13),char(0),char(24),char(0),char(13),char(0),char(25),char(0),char(4),char(0),char(26),char(0),char(4),char(0),char(27),char(0), +char(4),char(0),char(28),char(0),char(4),char(0),char(29),char(0),char(22),char(0),char(30),char(0),char(24),char(0),char(31),char(0),char(21),char(0),char(32),char(0), +char(4),char(0),char(33),char(0),char(4),char(0),char(34),char(0),char(26),char(0),char(12),char(0),char(14),char(0),char(23),char(0),char(14),char(0),char(24),char(0), +char(14),char(0),char(25),char(0),char(4),char(0),char(26),char(0),char(4),char(0),char(27),char(0),char(4),char(0),char(28),char(0),char(4),char(0),char(29),char(0), +char(23),char(0),char(30),char(0),char(24),char(0),char(31),char(0),char(4),char(0),char(33),char(0),char(4),char(0),char(34),char(0),char(21),char(0),char(32),char(0), +char(27),char(0),char(3),char(0),char(0),char(0),char(35),char(0),char(4),char(0),char(36),char(0),char(0),char(0),char(37),char(0),char(28),char(0),char(5),char(0), +char(27),char(0),char(38),char(0),char(13),char(0),char(39),char(0),char(13),char(0),char(40),char(0),char(7),char(0),char(41),char(0),char(0),char(0),char(21),char(0), +char(29),char(0),char(5),char(0),char(27),char(0),char(38),char(0),char(13),char(0),char(39),char(0),char(13),char(0),char(42),char(0),char(7),char(0),char(43),char(0), +char(4),char(0),char(44),char(0),char(30),char(0),char(2),char(0),char(13),char(0),char(45),char(0),char(7),char(0),char(46),char(0),char(31),char(0),char(4),char(0), +char(29),char(0),char(47),char(0),char(30),char(0),char(48),char(0),char(4),char(0),char(49),char(0),char(0),char(0),char(37),char(0),char(32),char(0),char(1),char(0), +char(4),char(0),char(50),char(0),char(33),char(0),char(2),char(0),char(2),char(0),char(50),char(0),char(0),char(0),char(51),char(0),char(34),char(0),char(2),char(0), +char(2),char(0),char(52),char(0),char(0),char(0),char(51),char(0),char(35),char(0),char(2),char(0),char(0),char(0),char(52),char(0),char(0),char(0),char(53),char(0), +char(36),char(0),char(8),char(0),char(13),char(0),char(54),char(0),char(14),char(0),char(55),char(0),char(32),char(0),char(56),char(0),char(34),char(0),char(57),char(0), +char(35),char(0),char(58),char(0),char(33),char(0),char(59),char(0),char(4),char(0),char(60),char(0),char(4),char(0),char(61),char(0),char(37),char(0),char(4),char(0), +char(36),char(0),char(62),char(0),char(13),char(0),char(63),char(0),char(4),char(0),char(64),char(0),char(0),char(0),char(37),char(0),char(38),char(0),char(7),char(0), +char(27),char(0),char(38),char(0),char(37),char(0),char(65),char(0),char(25),char(0),char(66),char(0),char(26),char(0),char(67),char(0),char(39),char(0),char(68),char(0), +char(7),char(0),char(43),char(0),char(0),char(0),char(69),char(0),char(40),char(0),char(2),char(0),char(38),char(0),char(70),char(0),char(13),char(0),char(39),char(0), +char(41),char(0),char(4),char(0),char(19),char(0),char(71),char(0),char(27),char(0),char(72),char(0),char(4),char(0),char(73),char(0),char(7),char(0),char(74),char(0), +char(42),char(0),char(4),char(0),char(27),char(0),char(38),char(0),char(41),char(0),char(75),char(0),char(4),char(0),char(76),char(0),char(7),char(0),char(43),char(0), +char(43),char(0),char(3),char(0),char(29),char(0),char(47),char(0),char(4),char(0),char(77),char(0),char(0),char(0),char(37),char(0),char(44),char(0),char(3),char(0), +char(29),char(0),char(47),char(0),char(4),char(0),char(78),char(0),char(0),char(0),char(37),char(0),char(45),char(0),char(3),char(0),char(29),char(0),char(47),char(0), +char(4),char(0),char(77),char(0),char(0),char(0),char(37),char(0),char(46),char(0),char(4),char(0),char(4),char(0),char(79),char(0),char(7),char(0),char(80),char(0), +char(7),char(0),char(81),char(0),char(7),char(0),char(82),char(0),char(39),char(0),char(14),char(0),char(4),char(0),char(83),char(0),char(4),char(0),char(84),char(0), +char(46),char(0),char(85),char(0),char(4),char(0),char(86),char(0),char(7),char(0),char(87),char(0),char(7),char(0),char(88),char(0),char(7),char(0),char(89),char(0), +char(7),char(0),char(90),char(0),char(7),char(0),char(91),char(0),char(4),char(0),char(92),char(0),char(4),char(0),char(93),char(0),char(4),char(0),char(94),char(0), +char(4),char(0),char(95),char(0),char(0),char(0),char(37),char(0),char(47),char(0),char(39),char(0),char(14),char(0),char(96),char(0),char(14),char(0),char(97),char(0), +char(14),char(0),char(98),char(0),char(14),char(0),char(99),char(0),char(14),char(0),char(100),char(0),char(14),char(0),char(101),char(0),char(14),char(0),char(102),char(0), +char(8),char(0),char(103),char(0),char(8),char(0),char(104),char(0),char(8),char(0),char(105),char(0),char(8),char(0),char(106),char(0),char(8),char(0),char(107),char(0), +char(8),char(0),char(108),char(0),char(8),char(0),char(109),char(0),char(4),char(0),char(110),char(0),char(4),char(0),char(111),char(0),char(4),char(0),char(112),char(0), +char(4),char(0),char(113),char(0),char(4),char(0),char(114),char(0),char(8),char(0),char(115),char(0),char(8),char(0),char(116),char(0),char(8),char(0),char(117),char(0), +char(8),char(0),char(118),char(0),char(8),char(0),char(119),char(0),char(8),char(0),char(120),char(0),char(8),char(0),char(121),char(0),char(8),char(0),char(122),char(0), +char(8),char(0),char(123),char(0),char(4),char(0),char(124),char(0),char(4),char(0),char(125),char(0),char(4),char(0),char(126),char(0),char(4),char(0),char(127),char(0), +char(4),char(0),char(-128),char(0),char(4),char(0),char(-127),char(0),char(8),char(0),char(-126),char(0),char(8),char(0),char(-125),char(0),char(4),char(0),char(44),char(0), +char(48),char(0),char(-124),char(0),char(48),char(0),char(-123),char(0),char(49),char(0),char(39),char(0),char(13),char(0),char(96),char(0),char(13),char(0),char(97),char(0), +char(13),char(0),char(98),char(0),char(13),char(0),char(99),char(0),char(13),char(0),char(100),char(0),char(13),char(0),char(101),char(0),char(13),char(0),char(102),char(0), +char(7),char(0),char(103),char(0),char(7),char(0),char(104),char(0),char(7),char(0),char(105),char(0),char(7),char(0),char(106),char(0),char(7),char(0),char(107),char(0), +char(7),char(0),char(108),char(0),char(7),char(0),char(109),char(0),char(4),char(0),char(110),char(0),char(4),char(0),char(111),char(0),char(4),char(0),char(112),char(0), +char(4),char(0),char(113),char(0),char(4),char(0),char(114),char(0),char(7),char(0),char(115),char(0),char(7),char(0),char(116),char(0),char(7),char(0),char(117),char(0), +char(7),char(0),char(118),char(0),char(7),char(0),char(119),char(0),char(7),char(0),char(120),char(0),char(7),char(0),char(121),char(0),char(7),char(0),char(122),char(0), +char(7),char(0),char(123),char(0),char(4),char(0),char(124),char(0),char(4),char(0),char(125),char(0),char(4),char(0),char(126),char(0),char(4),char(0),char(127),char(0), +char(4),char(0),char(-128),char(0),char(4),char(0),char(-127),char(0),char(7),char(0),char(-126),char(0),char(7),char(0),char(-125),char(0),char(4),char(0),char(44),char(0), +char(50),char(0),char(-124),char(0),char(50),char(0),char(-123),char(0),char(51),char(0),char(5),char(0),char(27),char(0),char(38),char(0),char(37),char(0),char(65),char(0), +char(13),char(0),char(39),char(0),char(7),char(0),char(43),char(0),char(4),char(0),char(-122),char(0),char(52),char(0),char(5),char(0),char(29),char(0),char(47),char(0), +char(13),char(0),char(-121),char(0),char(14),char(0),char(-120),char(0),char(4),char(0),char(-119),char(0),char(0),char(0),char(-118),char(0),char(48),char(0),char(29),char(0), +char(9),char(0),char(-117),char(0),char(9),char(0),char(-116),char(0),char(27),char(0),char(-115),char(0),char(0),char(0),char(35),char(0),char(20),char(0),char(-114),char(0), +char(20),char(0),char(-113),char(0),char(14),char(0),char(-112),char(0),char(14),char(0),char(-111),char(0),char(14),char(0),char(-110),char(0),char(8),char(0),char(-125),char(0), +char(8),char(0),char(-109),char(0),char(8),char(0),char(-108),char(0),char(8),char(0),char(-107),char(0),char(8),char(0),char(-106),char(0),char(8),char(0),char(-105),char(0), +char(8),char(0),char(-104),char(0),char(8),char(0),char(-103),char(0),char(8),char(0),char(-102),char(0),char(8),char(0),char(-101),char(0),char(4),char(0),char(-100),char(0), +char(4),char(0),char(-99),char(0),char(4),char(0),char(-98),char(0),char(4),char(0),char(-97),char(0),char(4),char(0),char(-96),char(0),char(4),char(0),char(-95),char(0), +char(4),char(0),char(-94),char(0),char(4),char(0),char(-93),char(0),char(4),char(0),char(-92),char(0),char(4),char(0),char(-91),char(0),char(50),char(0),char(29),char(0), +char(9),char(0),char(-117),char(0),char(9),char(0),char(-116),char(0),char(27),char(0),char(-115),char(0),char(0),char(0),char(35),char(0),char(19),char(0),char(-114),char(0), +char(19),char(0),char(-113),char(0),char(13),char(0),char(-112),char(0),char(13),char(0),char(-111),char(0),char(13),char(0),char(-110),char(0),char(7),char(0),char(-125),char(0), +char(7),char(0),char(-109),char(0),char(7),char(0),char(-108),char(0),char(7),char(0),char(-107),char(0),char(7),char(0),char(-106),char(0),char(7),char(0),char(-105),char(0), +char(7),char(0),char(-104),char(0),char(7),char(0),char(-103),char(0),char(7),char(0),char(-102),char(0),char(7),char(0),char(-101),char(0),char(4),char(0),char(-100),char(0), +char(4),char(0),char(-99),char(0),char(4),char(0),char(-98),char(0),char(4),char(0),char(-97),char(0),char(4),char(0),char(-96),char(0),char(4),char(0),char(-95),char(0), +char(4),char(0),char(-94),char(0),char(4),char(0),char(-93),char(0),char(4),char(0),char(-92),char(0),char(4),char(0),char(-91),char(0),char(53),char(0),char(23),char(0), +char(8),char(0),char(-90),char(0),char(8),char(0),char(-89),char(0),char(8),char(0),char(-108),char(0),char(8),char(0),char(-88),char(0),char(8),char(0),char(-104),char(0), +char(8),char(0),char(-87),char(0),char(8),char(0),char(-86),char(0),char(8),char(0),char(-85),char(0),char(8),char(0),char(-84),char(0),char(8),char(0),char(-83),char(0), +char(8),char(0),char(-82),char(0),char(8),char(0),char(-81),char(0),char(8),char(0),char(-80),char(0),char(8),char(0),char(-79),char(0),char(8),char(0),char(-78),char(0), +char(8),char(0),char(-77),char(0),char(8),char(0),char(-76),char(0),char(4),char(0),char(-75),char(0),char(4),char(0),char(-74),char(0),char(4),char(0),char(-73),char(0), +char(4),char(0),char(-72),char(0),char(4),char(0),char(-71),char(0),char(0),char(0),char(37),char(0),char(54),char(0),char(22),char(0),char(7),char(0),char(-90),char(0), +char(7),char(0),char(-89),char(0),char(7),char(0),char(-108),char(0),char(7),char(0),char(-88),char(0),char(7),char(0),char(-104),char(0),char(7),char(0),char(-87),char(0), +char(7),char(0),char(-86),char(0),char(7),char(0),char(-85),char(0),char(7),char(0),char(-84),char(0),char(7),char(0),char(-83),char(0),char(7),char(0),char(-82),char(0), +char(7),char(0),char(-81),char(0),char(7),char(0),char(-80),char(0),char(7),char(0),char(-79),char(0),char(7),char(0),char(-78),char(0),char(7),char(0),char(-77),char(0), +char(7),char(0),char(-76),char(0),char(4),char(0),char(-75),char(0),char(4),char(0),char(-74),char(0),char(4),char(0),char(-73),char(0),char(4),char(0),char(-72),char(0), +char(4),char(0),char(-71),char(0),char(55),char(0),char(2),char(0),char(53),char(0),char(-70),char(0),char(14),char(0),char(-69),char(0),char(56),char(0),char(2),char(0), +char(54),char(0),char(-70),char(0),char(13),char(0),char(-69),char(0),char(57),char(0),char(21),char(0),char(50),char(0),char(-68),char(0),char(17),char(0),char(-67),char(0), +char(13),char(0),char(-66),char(0),char(13),char(0),char(-65),char(0),char(13),char(0),char(-64),char(0),char(13),char(0),char(-63),char(0),char(13),char(0),char(-69),char(0), +char(13),char(0),char(-62),char(0),char(13),char(0),char(-61),char(0),char(13),char(0),char(-60),char(0),char(13),char(0),char(-59),char(0),char(7),char(0),char(-58),char(0), +char(7),char(0),char(-57),char(0),char(7),char(0),char(-56),char(0),char(7),char(0),char(-55),char(0),char(7),char(0),char(-54),char(0),char(7),char(0),char(-53),char(0), +char(7),char(0),char(-52),char(0),char(7),char(0),char(-51),char(0),char(7),char(0),char(-50),char(0),char(4),char(0),char(-49),char(0),char(58),char(0),char(22),char(0), +char(48),char(0),char(-68),char(0),char(18),char(0),char(-67),char(0),char(14),char(0),char(-66),char(0),char(14),char(0),char(-65),char(0),char(14),char(0),char(-64),char(0), +char(14),char(0),char(-63),char(0),char(14),char(0),char(-69),char(0),char(14),char(0),char(-62),char(0),char(14),char(0),char(-61),char(0),char(14),char(0),char(-60),char(0), +char(14),char(0),char(-59),char(0),char(8),char(0),char(-58),char(0),char(8),char(0),char(-57),char(0),char(8),char(0),char(-56),char(0),char(8),char(0),char(-55),char(0), +char(8),char(0),char(-54),char(0),char(8),char(0),char(-53),char(0),char(8),char(0),char(-52),char(0),char(8),char(0),char(-51),char(0),char(8),char(0),char(-50),char(0), +char(4),char(0),char(-49),char(0),char(0),char(0),char(37),char(0),char(59),char(0),char(2),char(0),char(4),char(0),char(-48),char(0),char(4),char(0),char(-47),char(0), +char(60),char(0),char(13),char(0),char(57),char(0),char(-46),char(0),char(57),char(0),char(-45),char(0),char(0),char(0),char(35),char(0),char(4),char(0),char(-127),char(0), +char(4),char(0),char(-44),char(0),char(4),char(0),char(-43),char(0),char(4),char(0),char(-42),char(0),char(7),char(0),char(-41),char(0),char(7),char(0),char(-40),char(0), +char(4),char(0),char(-39),char(0),char(4),char(0),char(-38),char(0),char(7),char(0),char(-37),char(0),char(4),char(0),char(-36),char(0),char(61),char(0),char(13),char(0), +char(62),char(0),char(-46),char(0),char(62),char(0),char(-45),char(0),char(0),char(0),char(35),char(0),char(4),char(0),char(-127),char(0),char(4),char(0),char(-44),char(0), +char(4),char(0),char(-43),char(0),char(4),char(0),char(-42),char(0),char(7),char(0),char(-41),char(0),char(7),char(0),char(-40),char(0),char(4),char(0),char(-39),char(0), +char(4),char(0),char(-38),char(0),char(7),char(0),char(-37),char(0),char(4),char(0),char(-36),char(0),char(63),char(0),char(14),char(0),char(58),char(0),char(-46),char(0), +char(58),char(0),char(-45),char(0),char(0),char(0),char(35),char(0),char(4),char(0),char(-127),char(0),char(4),char(0),char(-44),char(0),char(4),char(0),char(-43),char(0), +char(4),char(0),char(-42),char(0),char(8),char(0),char(-41),char(0),char(8),char(0),char(-40),char(0),char(4),char(0),char(-39),char(0),char(4),char(0),char(-38),char(0), +char(8),char(0),char(-37),char(0),char(4),char(0),char(-36),char(0),char(0),char(0),char(-35),char(0),char(64),char(0),char(3),char(0),char(61),char(0),char(-34),char(0), +char(13),char(0),char(-33),char(0),char(13),char(0),char(-32),char(0),char(65),char(0),char(3),char(0),char(63),char(0),char(-34),char(0),char(14),char(0),char(-33),char(0), +char(14),char(0),char(-32),char(0),char(66),char(0),char(3),char(0),char(61),char(0),char(-34),char(0),char(14),char(0),char(-33),char(0),char(14),char(0),char(-32),char(0), +char(67),char(0),char(13),char(0),char(61),char(0),char(-34),char(0),char(20),char(0),char(-31),char(0),char(20),char(0),char(-30),char(0),char(4),char(0),char(-29),char(0), +char(4),char(0),char(-28),char(0),char(4),char(0),char(-27),char(0),char(7),char(0),char(-26),char(0),char(7),char(0),char(-25),char(0),char(7),char(0),char(-24),char(0), +char(7),char(0),char(-23),char(0),char(7),char(0),char(-22),char(0),char(7),char(0),char(-21),char(0),char(7),char(0),char(-20),char(0),char(68),char(0),char(13),char(0), +char(61),char(0),char(-34),char(0),char(19),char(0),char(-31),char(0),char(19),char(0),char(-30),char(0),char(4),char(0),char(-29),char(0),char(4),char(0),char(-28),char(0), +char(4),char(0),char(-27),char(0),char(7),char(0),char(-26),char(0),char(7),char(0),char(-25),char(0),char(7),char(0),char(-24),char(0),char(7),char(0),char(-23),char(0), +char(7),char(0),char(-22),char(0),char(7),char(0),char(-21),char(0),char(7),char(0),char(-20),char(0),char(69),char(0),char(14),char(0),char(63),char(0),char(-34),char(0), +char(20),char(0),char(-31),char(0),char(20),char(0),char(-30),char(0),char(4),char(0),char(-29),char(0),char(4),char(0),char(-28),char(0),char(4),char(0),char(-27),char(0), +char(8),char(0),char(-26),char(0),char(8),char(0),char(-25),char(0),char(8),char(0),char(-24),char(0),char(8),char(0),char(-23),char(0),char(8),char(0),char(-22),char(0), +char(8),char(0),char(-21),char(0),char(8),char(0),char(-20),char(0),char(0),char(0),char(-19),char(0),char(70),char(0),char(10),char(0),char(63),char(0),char(-34),char(0), +char(20),char(0),char(-31),char(0),char(20),char(0),char(-30),char(0),char(8),char(0),char(-18),char(0),char(8),char(0),char(-17),char(0),char(8),char(0),char(-16),char(0), +char(8),char(0),char(-22),char(0),char(8),char(0),char(-21),char(0),char(8),char(0),char(-20),char(0),char(8),char(0),char(-89),char(0),char(71),char(0),char(11),char(0), +char(61),char(0),char(-34),char(0),char(19),char(0),char(-31),char(0),char(19),char(0),char(-30),char(0),char(7),char(0),char(-18),char(0),char(7),char(0),char(-17),char(0), +char(7),char(0),char(-16),char(0),char(7),char(0),char(-22),char(0),char(7),char(0),char(-21),char(0),char(7),char(0),char(-20),char(0),char(7),char(0),char(-89),char(0), +char(0),char(0),char(21),char(0),char(72),char(0),char(9),char(0),char(61),char(0),char(-34),char(0),char(19),char(0),char(-31),char(0),char(19),char(0),char(-30),char(0), +char(13),char(0),char(-15),char(0),char(13),char(0),char(-14),char(0),char(13),char(0),char(-13),char(0),char(13),char(0),char(-12),char(0),char(4),char(0),char(-11),char(0), +char(4),char(0),char(-10),char(0),char(73),char(0),char(9),char(0),char(63),char(0),char(-34),char(0),char(20),char(0),char(-31),char(0),char(20),char(0),char(-30),char(0), +char(14),char(0),char(-15),char(0),char(14),char(0),char(-14),char(0),char(14),char(0),char(-13),char(0),char(14),char(0),char(-12),char(0),char(4),char(0),char(-11),char(0), +char(4),char(0),char(-10),char(0),char(74),char(0),char(5),char(0),char(72),char(0),char(-9),char(0),char(4),char(0),char(-8),char(0),char(7),char(0),char(-7),char(0), +char(7),char(0),char(-6),char(0),char(7),char(0),char(-5),char(0),char(75),char(0),char(5),char(0),char(73),char(0),char(-9),char(0),char(4),char(0),char(-8),char(0), +char(8),char(0),char(-7),char(0),char(8),char(0),char(-6),char(0),char(8),char(0),char(-5),char(0),char(76),char(0),char(41),char(0),char(61),char(0),char(-34),char(0), +char(19),char(0),char(-31),char(0),char(19),char(0),char(-30),char(0),char(13),char(0),char(-15),char(0),char(13),char(0),char(-14),char(0),char(13),char(0),char(-4),char(0), +char(13),char(0),char(-3),char(0),char(13),char(0),char(-2),char(0),char(13),char(0),char(-1),char(0),char(13),char(0),char(0),char(1),char(13),char(0),char(1),char(1), +char(13),char(0),char(2),char(1),char(13),char(0),char(3),char(1),char(13),char(0),char(4),char(1),char(13),char(0),char(5),char(1),char(13),char(0),char(6),char(1), +char(0),char(0),char(7),char(1),char(0),char(0),char(8),char(1),char(0),char(0),char(9),char(1),char(0),char(0),char(10),char(1),char(0),char(0),char(11),char(1), +char(0),char(0),char(-19),char(0),char(13),char(0),char(-13),char(0),char(13),char(0),char(-12),char(0),char(13),char(0),char(12),char(1),char(13),char(0),char(13),char(1), +char(13),char(0),char(14),char(1),char(13),char(0),char(15),char(1),char(13),char(0),char(16),char(1),char(13),char(0),char(17),char(1),char(13),char(0),char(18),char(1), +char(13),char(0),char(19),char(1),char(13),char(0),char(20),char(1),char(13),char(0),char(21),char(1),char(13),char(0),char(22),char(1),char(0),char(0),char(23),char(1), +char(0),char(0),char(24),char(1),char(0),char(0),char(25),char(1),char(0),char(0),char(26),char(1),char(0),char(0),char(27),char(1),char(4),char(0),char(28),char(1), +char(77),char(0),char(41),char(0),char(63),char(0),char(-34),char(0),char(20),char(0),char(-31),char(0),char(20),char(0),char(-30),char(0),char(14),char(0),char(-15),char(0), +char(14),char(0),char(-14),char(0),char(14),char(0),char(-4),char(0),char(14),char(0),char(-3),char(0),char(14),char(0),char(-2),char(0),char(14),char(0),char(-1),char(0), +char(14),char(0),char(0),char(1),char(14),char(0),char(1),char(1),char(14),char(0),char(2),char(1),char(14),char(0),char(3),char(1),char(14),char(0),char(4),char(1), +char(14),char(0),char(5),char(1),char(14),char(0),char(6),char(1),char(0),char(0),char(7),char(1),char(0),char(0),char(8),char(1),char(0),char(0),char(9),char(1), +char(0),char(0),char(10),char(1),char(0),char(0),char(11),char(1),char(0),char(0),char(-19),char(0),char(14),char(0),char(-13),char(0),char(14),char(0),char(-12),char(0), +char(14),char(0),char(12),char(1),char(14),char(0),char(13),char(1),char(14),char(0),char(14),char(1),char(14),char(0),char(15),char(1),char(14),char(0),char(16),char(1), +char(14),char(0),char(17),char(1),char(14),char(0),char(18),char(1),char(14),char(0),char(19),char(1),char(14),char(0),char(20),char(1),char(14),char(0),char(21),char(1), +char(14),char(0),char(22),char(1),char(0),char(0),char(23),char(1),char(0),char(0),char(24),char(1),char(0),char(0),char(25),char(1),char(0),char(0),char(26),char(1), +char(0),char(0),char(27),char(1),char(4),char(0),char(28),char(1),char(78),char(0),char(9),char(0),char(61),char(0),char(-34),char(0),char(19),char(0),char(-31),char(0), +char(19),char(0),char(-30),char(0),char(7),char(0),char(-15),char(0),char(7),char(0),char(-14),char(0),char(7),char(0),char(-13),char(0),char(7),char(0),char(-12),char(0), +char(4),char(0),char(-11),char(0),char(4),char(0),char(-10),char(0),char(79),char(0),char(9),char(0),char(63),char(0),char(-34),char(0),char(20),char(0),char(-31),char(0), +char(20),char(0),char(-30),char(0),char(8),char(0),char(-15),char(0),char(8),char(0),char(-14),char(0),char(8),char(0),char(-13),char(0),char(8),char(0),char(-12),char(0), +char(4),char(0),char(-11),char(0),char(4),char(0),char(-10),char(0),char(80),char(0),char(5),char(0),char(60),char(0),char(-34),char(0),char(13),char(0),char(29),char(1), +char(13),char(0),char(30),char(1),char(7),char(0),char(31),char(1),char(0),char(0),char(37),char(0),char(81),char(0),char(4),char(0),char(63),char(0),char(-34),char(0), +char(14),char(0),char(29),char(1),char(14),char(0),char(30),char(1),char(8),char(0),char(31),char(1),char(82),char(0),char(4),char(0),char(7),char(0),char(32),char(1), +char(7),char(0),char(33),char(1),char(7),char(0),char(34),char(1),char(4),char(0),char(79),char(0),char(83),char(0),char(10),char(0),char(82),char(0),char(35),char(1), +char(13),char(0),char(36),char(1),char(13),char(0),char(37),char(1),char(13),char(0),char(38),char(1),char(13),char(0),char(39),char(1),char(13),char(0),char(40),char(1), +char(7),char(0),char(-58),char(0),char(7),char(0),char(41),char(1),char(4),char(0),char(42),char(1),char(4),char(0),char(53),char(0),char(84),char(0),char(4),char(0), +char(82),char(0),char(35),char(1),char(4),char(0),char(43),char(1),char(7),char(0),char(44),char(1),char(4),char(0),char(45),char(1),char(85),char(0),char(4),char(0), +char(13),char(0),char(40),char(1),char(82),char(0),char(35),char(1),char(4),char(0),char(46),char(1),char(7),char(0),char(47),char(1),char(86),char(0),char(7),char(0), +char(13),char(0),char(48),char(1),char(82),char(0),char(35),char(1),char(4),char(0),char(49),char(1),char(7),char(0),char(50),char(1),char(7),char(0),char(51),char(1), +char(7),char(0),char(52),char(1),char(4),char(0),char(53),char(0),char(87),char(0),char(6),char(0),char(17),char(0),char(53),char(1),char(13),char(0),char(51),char(1), +char(13),char(0),char(54),char(1),char(62),char(0),char(55),char(1),char(4),char(0),char(56),char(1),char(7),char(0),char(52),char(1),char(88),char(0),char(26),char(0), +char(4),char(0),char(57),char(1),char(7),char(0),char(58),char(1),char(7),char(0),char(-89),char(0),char(7),char(0),char(59),char(1),char(7),char(0),char(60),char(1), +char(7),char(0),char(61),char(1),char(7),char(0),char(62),char(1),char(7),char(0),char(63),char(1),char(7),char(0),char(64),char(1),char(7),char(0),char(65),char(1), +char(7),char(0),char(66),char(1),char(7),char(0),char(67),char(1),char(7),char(0),char(68),char(1),char(7),char(0),char(69),char(1),char(7),char(0),char(70),char(1), +char(7),char(0),char(71),char(1),char(7),char(0),char(72),char(1),char(7),char(0),char(73),char(1),char(7),char(0),char(74),char(1),char(7),char(0),char(75),char(1), +char(7),char(0),char(76),char(1),char(4),char(0),char(77),char(1),char(4),char(0),char(78),char(1),char(4),char(0),char(79),char(1),char(4),char(0),char(80),char(1), +char(4),char(0),char(-99),char(0),char(89),char(0),char(12),char(0),char(17),char(0),char(81),char(1),char(17),char(0),char(82),char(1),char(17),char(0),char(83),char(1), +char(13),char(0),char(84),char(1),char(13),char(0),char(85),char(1),char(7),char(0),char(86),char(1),char(4),char(0),char(87),char(1),char(4),char(0),char(88),char(1), +char(4),char(0),char(89),char(1),char(4),char(0),char(90),char(1),char(7),char(0),char(50),char(1),char(4),char(0),char(53),char(0),char(90),char(0),char(27),char(0), +char(19),char(0),char(91),char(1),char(17),char(0),char(92),char(1),char(17),char(0),char(93),char(1),char(13),char(0),char(84),char(1),char(13),char(0),char(94),char(1), +char(13),char(0),char(95),char(1),char(13),char(0),char(96),char(1),char(13),char(0),char(97),char(1),char(13),char(0),char(98),char(1),char(4),char(0),char(99),char(1), +char(7),char(0),char(100),char(1),char(4),char(0),char(101),char(1),char(4),char(0),char(102),char(1),char(4),char(0),char(103),char(1),char(7),char(0),char(104),char(1), +char(7),char(0),char(105),char(1),char(4),char(0),char(106),char(1),char(4),char(0),char(107),char(1),char(7),char(0),char(108),char(1),char(7),char(0),char(109),char(1), +char(7),char(0),char(110),char(1),char(7),char(0),char(111),char(1),char(7),char(0),char(112),char(1),char(7),char(0),char(113),char(1),char(4),char(0),char(114),char(1), +char(4),char(0),char(115),char(1),char(4),char(0),char(116),char(1),char(91),char(0),char(12),char(0),char(9),char(0),char(117),char(1),char(9),char(0),char(118),char(1), +char(13),char(0),char(119),char(1),char(7),char(0),char(120),char(1),char(7),char(0),char(-85),char(0),char(7),char(0),char(121),char(1),char(4),char(0),char(122),char(1), +char(13),char(0),char(123),char(1),char(4),char(0),char(124),char(1),char(4),char(0),char(125),char(1),char(4),char(0),char(126),char(1),char(4),char(0),char(53),char(0), +char(92),char(0),char(19),char(0),char(50),char(0),char(-68),char(0),char(89),char(0),char(127),char(1),char(82),char(0),char(-128),char(1),char(83),char(0),char(-127),char(1), +char(84),char(0),char(-126),char(1),char(85),char(0),char(-125),char(1),char(86),char(0),char(-124),char(1),char(87),char(0),char(-123),char(1),char(90),char(0),char(-122),char(1), +char(91),char(0),char(-121),char(1),char(4),char(0),char(-120),char(1),char(4),char(0),char(102),char(1),char(4),char(0),char(-119),char(1),char(4),char(0),char(-118),char(1), +char(4),char(0),char(-117),char(1),char(4),char(0),char(-116),char(1),char(4),char(0),char(-115),char(1),char(4),char(0),char(-114),char(1),char(88),char(0),char(-113),char(1), +char(93),char(0),char(28),char(0),char(16),char(0),char(-112),char(1),char(14),char(0),char(-111),char(1),char(14),char(0),char(-110),char(1),char(14),char(0),char(-109),char(1), +char(14),char(0),char(-108),char(1),char(14),char(0),char(-107),char(1),char(14),char(0),char(-106),char(1),char(14),char(0),char(-105),char(1),char(14),char(0),char(-104),char(1), +char(14),char(0),char(-103),char(1),char(8),char(0),char(-102),char(1),char(4),char(0),char(-101),char(1),char(4),char(0),char(126),char(1),char(4),char(0),char(-100),char(1), +char(4),char(0),char(-99),char(1),char(8),char(0),char(-98),char(1),char(8),char(0),char(-97),char(1),char(8),char(0),char(-96),char(1),char(8),char(0),char(-95),char(1), +char(8),char(0),char(-94),char(1),char(8),char(0),char(-93),char(1),char(8),char(0),char(-92),char(1),char(8),char(0),char(-91),char(1),char(8),char(0),char(-90),char(1), +char(0),char(0),char(-89),char(1),char(0),char(0),char(-88),char(1),char(48),char(0),char(-87),char(1),char(0),char(0),char(-86),char(1),char(94),char(0),char(28),char(0), +char(15),char(0),char(-112),char(1),char(13),char(0),char(-111),char(1),char(13),char(0),char(-110),char(1),char(13),char(0),char(-109),char(1),char(13),char(0),char(-108),char(1), +char(13),char(0),char(-107),char(1),char(13),char(0),char(-106),char(1),char(13),char(0),char(-105),char(1),char(13),char(0),char(-104),char(1),char(13),char(0),char(-103),char(1), +char(4),char(0),char(-100),char(1),char(7),char(0),char(-102),char(1),char(4),char(0),char(-101),char(1),char(4),char(0),char(126),char(1),char(7),char(0),char(-98),char(1), +char(7),char(0),char(-97),char(1),char(7),char(0),char(-96),char(1),char(4),char(0),char(-99),char(1),char(7),char(0),char(-95),char(1),char(7),char(0),char(-94),char(1), +char(7),char(0),char(-93),char(1),char(7),char(0),char(-92),char(1),char(7),char(0),char(-91),char(1),char(7),char(0),char(-90),char(1),char(0),char(0),char(-89),char(1), +char(0),char(0),char(-88),char(1),char(50),char(0),char(-87),char(1),char(0),char(0),char(-86),char(1),char(95),char(0),char(11),char(0),char(14),char(0),char(-85),char(1), +char(16),char(0),char(-84),char(1),char(14),char(0),char(-83),char(1),char(14),char(0),char(-82),char(1),char(14),char(0),char(-81),char(1),char(8),char(0),char(-80),char(1), +char(4),char(0),char(-119),char(1),char(0),char(0),char(37),char(0),char(0),char(0),char(-79),char(1),char(93),char(0),char(-126),char(1),char(48),char(0),char(-78),char(1), +char(96),char(0),char(10),char(0),char(13),char(0),char(-85),char(1),char(15),char(0),char(-84),char(1),char(13),char(0),char(-83),char(1),char(13),char(0),char(-82),char(1), +char(13),char(0),char(-81),char(1),char(7),char(0),char(-80),char(1),char(4),char(0),char(-119),char(1),char(0),char(0),char(-79),char(1),char(94),char(0),char(-126),char(1), +char(50),char(0),char(-78),char(1),char(97),char(0),char(4),char(0),char(50),char(0),char(-77),char(1),char(96),char(0),char(-76),char(1),char(4),char(0),char(-75),char(1), +char(0),char(0),char(37),char(0),char(98),char(0),char(4),char(0),char(48),char(0),char(-77),char(1),char(95),char(0),char(-76),char(1),char(4),char(0),char(-75),char(1), +char(0),char(0),char(37),char(0),}; +int sBulletDNAlen= sizeof(sBulletDNAstr); diff --git a/pkg/mphysics/mbt/LinearMath/btSerializer.cpp.i b/pkg/mphysics/mbt/LinearMath/btSerializer.cpp.i new file mode 100644 index 00000000..36998325 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btSerializer.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btSerializer.cpp ---------------- + +%include "LinearMath/btSerializer.cpp" + +%{ +#include "LinearMath/btSerializer.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btSerializer.h b/pkg/mphysics/mbt/LinearMath/btSerializer.h new file mode 100644 index 00000000..e0cdbd7d --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btSerializer.h @@ -0,0 +1,866 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_SERIALIZER_H +#define BT_SERIALIZER_H + +#include "btScalar.h" // has definitions like SIMD_FORCE_INLINE +#include "btHashMap.h" + +#if !defined(__CELLOS_LV2__) && !defined(__MWERKS__) +#include +#endif +#include + +extern char sBulletDNAstr[]; +extern int sBulletDNAlen; +extern char sBulletDNAstr64[]; +extern int sBulletDNAlen64; + +SIMD_FORCE_INLINE int btStrLen(const char* str) +{ + if (!str) + return (0); + int len = 0; + + while (*str != 0) + { + str++; + len++; + } + + return len; +} + +class btChunk +{ +public: + int m_chunkCode; + int m_length; + void* m_oldPtr; + int m_dna_nr; + int m_number; +}; + +enum btSerializationFlags +{ + BT_SERIALIZE_NO_BVH = 1, + BT_SERIALIZE_NO_TRIANGLEINFOMAP = 2, + BT_SERIALIZE_NO_DUPLICATE_ASSERT = 4, + BT_SERIALIZE_CONTACT_MANIFOLDS = 8, +}; + +class btSerializer +{ +public: + virtual ~btSerializer() {} + + virtual const unsigned char* getBufferPointer() const = 0; + + virtual int getCurrentBufferSize() const = 0; + + virtual btChunk* allocate(size_t size, int numElements) = 0; + + virtual void finalizeChunk(btChunk* chunk, const char* structType, int chunkCode, void* oldPtr) = 0; + + virtual void* findPointer(void* oldPtr) = 0; + + virtual void* getUniquePointer(void* oldPtr) = 0; + + virtual void startSerialization() = 0; + + virtual void finishSerialization() = 0; + + virtual const char* findNameForPointer(const void* ptr) const = 0; + + virtual void registerNameForPointer(const void* ptr, const char* name) = 0; + + virtual void serializeName(const char* ptr) = 0; + + virtual int getSerializationFlags() const = 0; + + virtual void setSerializationFlags(int flags) = 0; + + virtual int getNumChunks() const = 0; + + virtual const btChunk* getChunk(int chunkIndex) const = 0; +}; + +#define BT_HEADER_LENGTH 12 +#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__) +#define BT_MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d)) +#else +#define BT_MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a)) +#endif + +#define BT_MULTIBODY_CODE BT_MAKE_ID('M', 'B', 'D', 'Y') +#define BT_MB_LINKCOLLIDER_CODE BT_MAKE_ID('M', 'B', 'L', 'C') +#define BT_SOFTBODY_CODE BT_MAKE_ID('S', 'B', 'D', 'Y') +#define BT_COLLISIONOBJECT_CODE BT_MAKE_ID('C', 'O', 'B', 'J') +#define BT_RIGIDBODY_CODE BT_MAKE_ID('R', 'B', 'D', 'Y') +#define BT_CONSTRAINT_CODE BT_MAKE_ID('C', 'O', 'N', 'S') +#define BT_BOXSHAPE_CODE BT_MAKE_ID('B', 'O', 'X', 'S') +#define BT_QUANTIZED_BVH_CODE BT_MAKE_ID('Q', 'B', 'V', 'H') +#define BT_TRIANLGE_INFO_MAP BT_MAKE_ID('T', 'M', 'A', 'P') +#define BT_SHAPE_CODE BT_MAKE_ID('S', 'H', 'A', 'P') +#define BT_ARRAY_CODE BT_MAKE_ID('A', 'R', 'A', 'Y') +#define BT_SBMATERIAL_CODE BT_MAKE_ID('S', 'B', 'M', 'T') +#define BT_SBNODE_CODE BT_MAKE_ID('S', 'B', 'N', 'D') +#define BT_DYNAMICSWORLD_CODE BT_MAKE_ID('D', 'W', 'L', 'D') +#define BT_CONTACTMANIFOLD_CODE BT_MAKE_ID('C', 'O', 'N', 'T') +#define BT_DNA_CODE BT_MAKE_ID('D', 'N', 'A', '1') + +struct btPointerUid +{ + union { + void* m_ptr; + int m_uniqueIds[2]; + }; +}; + +struct btBulletSerializedArrays +{ + btBulletSerializedArrays() + { + } + btAlignedObjectArray m_bvhsDouble; + btAlignedObjectArray m_bvhsFloat; + btAlignedObjectArray m_colShapeData; + btAlignedObjectArray m_dynamicWorldInfoDataDouble; + btAlignedObjectArray m_dynamicWorldInfoDataFloat; + btAlignedObjectArray m_rigidBodyDataDouble; + btAlignedObjectArray m_rigidBodyDataFloat; + btAlignedObjectArray m_collisionObjectDataDouble; + btAlignedObjectArray m_collisionObjectDataFloat; + btAlignedObjectArray m_constraintDataFloat; + btAlignedObjectArray m_constraintDataDouble; + btAlignedObjectArray m_constraintData; //for backwards compatibility + btAlignedObjectArray m_softBodyFloatData; + btAlignedObjectArray m_softBodyDoubleData; +}; + +///The btDefaultSerializer is the main Bullet serialization class. +///The constructor takes an optional argument for backwards compatibility, it is recommended to leave this empty/zero. +class btDefaultSerializer : public btSerializer +{ +protected: + btAlignedObjectArray mTypes; + btAlignedObjectArray mStructs; + btAlignedObjectArray mTlens; + btHashMap mStructReverse; + btHashMap mTypeLookup; + + btHashMap m_chunkP; + + btHashMap m_nameMap; + + btHashMap m_uniquePointers; + int m_uniqueIdGenerator; + + int m_totalSize; + unsigned char* m_buffer; + bool m_ownsBuffer; + int m_currentSize; + void* m_dna; + int m_dnaLength; + + int m_serializationFlags; + + btAlignedObjectArray m_chunkPtrs; + +protected: + virtual void* findPointer(void* oldPtr) + { + void** ptr = m_chunkP.find(oldPtr); + if (ptr && *ptr) + return *ptr; + return 0; + } + + virtual void writeDNA() + { + btChunk* dnaChunk = allocate(m_dnaLength, 1); + memcpy(dnaChunk->m_oldPtr, m_dna, m_dnaLength); + finalizeChunk(dnaChunk, "DNA1", BT_DNA_CODE, m_dna); + } + + int getReverseType(const char* type) const + { + btHashString key(type); + const int* valuePtr = mTypeLookup.find(key); + if (valuePtr) + return *valuePtr; + + return -1; + } + + void initDNA(const char* bdnaOrg, int dnalen) + { + ///was already initialized + if (m_dna) + return; + + int littleEndian = 1; + littleEndian = ((char*)&littleEndian)[0]; + + m_dna = btAlignedAlloc(dnalen, 16); + memcpy(m_dna, bdnaOrg, dnalen); + m_dnaLength = dnalen; + + int* intPtr = 0; + short* shtPtr = 0; + char* cp = 0; + int dataLen = 0; + intPtr = (int*)m_dna; + + /* + SDNA (4 bytes) (magic number) + NAME (4 bytes) + (4 bytes) amount of names (int) + + + */ + + if (strncmp((const char*)m_dna, "SDNA", 4) == 0) + { + // skip ++ NAME + intPtr++; + intPtr++; + } + + // Parse names + if (!littleEndian) + *intPtr = btSwapEndian(*intPtr); + + dataLen = *intPtr; + + intPtr++; + + cp = (char*)intPtr; + int i; + for (i = 0; i < dataLen; i++) + { + while (*cp) cp++; + cp++; + } + cp = btAlignPointer(cp, 4); + + /* + TYPE (4 bytes) + amount of types (int) + + + */ + + intPtr = (int*)cp; + btAssert(strncmp(cp, "TYPE", 4) == 0); + intPtr++; + + if (!littleEndian) + *intPtr = btSwapEndian(*intPtr); + + dataLen = *intPtr; + intPtr++; + + cp = (char*)intPtr; + for (i = 0; i < dataLen; i++) + { + mTypes.push_back(cp); + while (*cp) cp++; + cp++; + } + + cp = btAlignPointer(cp, 4); + + /* + TLEN (4 bytes) + (short) the lengths of types + + */ + + // Parse type lens + intPtr = (int*)cp; + btAssert(strncmp(cp, "TLEN", 4) == 0); + intPtr++; + + dataLen = (int)mTypes.size(); + + shtPtr = (short*)intPtr; + for (i = 0; i < dataLen; i++, shtPtr++) + { + if (!littleEndian) + shtPtr[0] = btSwapEndian(shtPtr[0]); + mTlens.push_back(shtPtr[0]); + } + + if (dataLen & 1) shtPtr++; + + /* + STRC (4 bytes) + amount of structs (int) + + + + + + + */ + + intPtr = (int*)shtPtr; + cp = (char*)intPtr; + btAssert(strncmp(cp, "STRC", 4) == 0); + intPtr++; + + if (!littleEndian) + *intPtr = btSwapEndian(*intPtr); + dataLen = *intPtr; + intPtr++; + + shtPtr = (short*)intPtr; + for (i = 0; i < dataLen; i++) + { + mStructs.push_back(shtPtr); + + if (!littleEndian) + { + shtPtr[0] = btSwapEndian(shtPtr[0]); + shtPtr[1] = btSwapEndian(shtPtr[1]); + + int len = shtPtr[1]; + shtPtr += 2; + + for (int a = 0; a < len; a++, shtPtr += 2) + { + shtPtr[0] = btSwapEndian(shtPtr[0]); + shtPtr[1] = btSwapEndian(shtPtr[1]); + } + } + else + { + shtPtr += (2 * shtPtr[1]) + 2; + } + } + + // build reverse lookups + for (i = 0; i < (int)mStructs.size(); i++) + { + short* strc = mStructs.at(i); + mStructReverse.insert(strc[0], i); + mTypeLookup.insert(btHashString(mTypes[strc[0]]), i); + } + } + +public: + btHashMap m_skipPointers; + + btDefaultSerializer(int totalSize = 0, unsigned char* buffer = 0) + : m_uniqueIdGenerator(0), + m_totalSize(totalSize), + m_currentSize(0), + m_dna(0), + m_dnaLength(0), + m_serializationFlags(0) + { + if (buffer == 0) + { + m_buffer = m_totalSize ? (unsigned char*)btAlignedAlloc(totalSize, 16) : 0; + m_ownsBuffer = true; + } + else + { + m_buffer = buffer; + m_ownsBuffer = false; + } + + const bool VOID_IS_8 = ((sizeof(void*) == 8)); + +#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES + if (VOID_IS_8) + { +#if _WIN64 + initDNA((const char*)sBulletDNAstr64, sBulletDNAlen64); +#else + btAssert(0); +#endif + } + else + { +#ifndef _WIN64 + initDNA((const char*)sBulletDNAstr, sBulletDNAlen); +#else + btAssert(0); +#endif + } + +#else //BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES + if (VOID_IS_8) + { + initDNA((const char*)sBulletDNAstr64, sBulletDNAlen64); + } + else + { + initDNA((const char*)sBulletDNAstr, sBulletDNAlen); + } +#endif //BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES + } + + virtual ~btDefaultSerializer() + { + if (m_buffer && m_ownsBuffer) + btAlignedFree(m_buffer); + if (m_dna) + btAlignedFree(m_dna); + } + + static int getMemoryDnaSizeInBytes() + { + const bool VOID_IS_8 = ((sizeof(void*) == 8)); + + if (VOID_IS_8) + { + return sBulletDNAlen64; + } + return sBulletDNAlen; + } + static const char* getMemoryDna() + { + const bool VOID_IS_8 = ((sizeof(void*) == 8)); + if (VOID_IS_8) + { + return (const char*)sBulletDNAstr64; + } + return (const char*)sBulletDNAstr; + } + + void insertHeader() + { + writeHeader(m_buffer); + m_currentSize += BT_HEADER_LENGTH; + } + + void writeHeader(unsigned char* buffer) const + { +#ifdef BT_USE_DOUBLE_PRECISION + memcpy(buffer, "BULLETd", 7); +#else + memcpy(buffer, "BULLETf", 7); +#endif //BT_USE_DOUBLE_PRECISION + + int littleEndian = 1; + littleEndian = ((char*)&littleEndian)[0]; + + if (sizeof(void*) == 8) + { + buffer[7] = '-'; + } + else + { + buffer[7] = '_'; + } + + if (littleEndian) + { + buffer[8] = 'v'; + } + else + { + buffer[8] = 'V'; + } + + buffer[9] = '3'; + buffer[10] = '2'; + buffer[11] = '6'; + } + + virtual void startSerialization() + { + m_uniqueIdGenerator = 1; + if (m_totalSize) + { + unsigned char* buffer = internalAlloc(BT_HEADER_LENGTH); + writeHeader(buffer); + } + } + + virtual void finishSerialization() + { + writeDNA(); + + //if we didn't pre-allocate a buffer, we need to create a contiguous buffer now + if (!m_totalSize) + { + if (m_buffer) + btAlignedFree(m_buffer); + + m_currentSize += BT_HEADER_LENGTH; + m_buffer = (unsigned char*)btAlignedAlloc(m_currentSize, 16); + + unsigned char* currentPtr = m_buffer; + writeHeader(m_buffer); + currentPtr += BT_HEADER_LENGTH; + for (int i = 0; i < m_chunkPtrs.size(); i++) + { + int curLength = (int)sizeof(btChunk) + m_chunkPtrs[i]->m_length; + memcpy(currentPtr, m_chunkPtrs[i], curLength); + btAlignedFree(m_chunkPtrs[i]); + currentPtr += curLength; + } + } + + mTypes.clear(); + mStructs.clear(); + mTlens.clear(); + mStructReverse.clear(); + mTypeLookup.clear(); + m_skipPointers.clear(); + m_chunkP.clear(); + m_nameMap.clear(); + m_uniquePointers.clear(); + m_chunkPtrs.clear(); + } + + virtual void* getUniquePointer(void* oldPtr) + { + btAssert(m_uniqueIdGenerator >= 0); + if (!oldPtr) + return 0; + + btPointerUid* uptr = (btPointerUid*)m_uniquePointers.find(oldPtr); + if (uptr) + { + return uptr->m_ptr; + } + + void** ptr2 = m_skipPointers[oldPtr]; + if (ptr2) + { + return 0; + } + + m_uniqueIdGenerator++; + + btPointerUid uid; + uid.m_uniqueIds[0] = m_uniqueIdGenerator; + uid.m_uniqueIds[1] = m_uniqueIdGenerator; + m_uniquePointers.insert(oldPtr, uid); + return uid.m_ptr; + } + + virtual const unsigned char* getBufferPointer() const + { + return m_buffer; + } + + virtual int getCurrentBufferSize() const + { + return m_currentSize; + } + + virtual void finalizeChunk(btChunk* chunk, const char* structType, int chunkCode, void* oldPtr) + { + if (!(m_serializationFlags & BT_SERIALIZE_NO_DUPLICATE_ASSERT)) + { + btAssert(!findPointer(oldPtr)); + } + + chunk->m_dna_nr = getReverseType(structType); + + chunk->m_chunkCode = chunkCode; + + void* uniquePtr = getUniquePointer(oldPtr); + + m_chunkP.insert(oldPtr, uniquePtr); //chunk->m_oldPtr); + chunk->m_oldPtr = uniquePtr; //oldPtr; + } + + virtual unsigned char* internalAlloc(size_t size) + { + unsigned char* ptr = 0; + + if (m_totalSize) + { + ptr = m_buffer + m_currentSize; + m_currentSize += int(size); + btAssert(m_currentSize < m_totalSize); + } + else + { + ptr = (unsigned char*)btAlignedAlloc(size, 16); + m_currentSize += int(size); + } + return ptr; + } + + virtual btChunk* allocate(size_t size, int numElements) + { + unsigned char* ptr = internalAlloc(int(size) * numElements + sizeof(btChunk)); + + unsigned char* data = ptr + sizeof(btChunk); + + btChunk* chunk = (btChunk*)ptr; + chunk->m_chunkCode = 0; + chunk->m_oldPtr = data; + chunk->m_length = int(size) * numElements; + chunk->m_number = numElements; + + m_chunkPtrs.push_back(chunk); + + return chunk; + } + + virtual const char* findNameForPointer(const void* ptr) const + { + const char* const* namePtr = m_nameMap.find(ptr); + if (namePtr && *namePtr) + return *namePtr; + return 0; + } + + virtual void registerNameForPointer(const void* ptr, const char* name) + { + m_nameMap.insert(ptr, name); + } + + virtual void serializeName(const char* name) + { + if (name) + { + //don't serialize name twice + if (findPointer((void*)name)) + return; + + int len = btStrLen(name); + if (len) + { + int newLen = len + 1; + int padding = ((newLen + 3) & ~3) - newLen; + newLen += padding; + + //serialize name string now + btChunk* chunk = allocate(sizeof(char), newLen); + char* destinationName = (char*)chunk->m_oldPtr; + for (int i = 0; i < len; i++) + { + destinationName[i] = name[i]; + } + destinationName[len] = 0; + finalizeChunk(chunk, "char", BT_ARRAY_CODE, (void*)name); + } + } + } + + virtual int getSerializationFlags() const + { + return m_serializationFlags; + } + + virtual void setSerializationFlags(int flags) + { + m_serializationFlags = flags; + } + int getNumChunks() const + { + return m_chunkPtrs.size(); + } + + const btChunk* getChunk(int chunkIndex) const + { + return m_chunkPtrs[chunkIndex]; + } +}; + +///In general it is best to use btDefaultSerializer, +///in particular when writing the data to disk or sending it over the network. +///The btInMemorySerializer is experimental and only suitable in a few cases. +///The btInMemorySerializer takes a shortcut and can be useful to create a deep-copy +///of objects. There will be a demo on how to use the btInMemorySerializer. +#ifdef ENABLE_INMEMORY_SERIALIZER + +struct btInMemorySerializer : public btDefaultSerializer +{ + btHashMap m_uid2ChunkPtr; + btHashMap m_orgPtr2UniqueDataPtr; + btHashMap m_names2Ptr; + + btBulletSerializedArrays m_arrays; + + btInMemorySerializer(int totalSize = 0, unsigned char* buffer = 0) + : btDefaultSerializer(totalSize, buffer) + { + } + + virtual void startSerialization() + { + m_uid2ChunkPtr.clear(); + //todo: m_arrays.clear(); + btDefaultSerializer::startSerialization(); + } + + btChunk* findChunkFromUniquePointer(void* uniquePointer) + { + btChunk** chkPtr = m_uid2ChunkPtr[uniquePointer]; + if (chkPtr) + { + return *chkPtr; + } + return 0; + } + + virtual void registerNameForPointer(const void* ptr, const char* name) + { + btDefaultSerializer::registerNameForPointer(ptr, name); + m_names2Ptr.insert(name, ptr); + } + + virtual void finishSerialization() + { + } + + virtual void* getUniquePointer(void* oldPtr) + { + if (oldPtr == 0) + return 0; + + // void* uniquePtr = getUniquePointer(oldPtr); + btChunk* chunk = findChunkFromUniquePointer(oldPtr); + if (chunk) + { + return chunk->m_oldPtr; + } + else + { + const char* n = (const char*)oldPtr; + const void** ptr = m_names2Ptr[n]; + if (ptr) + { + return oldPtr; + } + else + { + void** ptr2 = m_skipPointers[oldPtr]; + if (ptr2) + { + return 0; + } + else + { + //If this assert hit, serialization happened in the wrong order + // 'getUniquePointer' + btAssert(0); + } + } + return 0; + } + return oldPtr; + } + + virtual void finalizeChunk(btChunk* chunk, const char* structType, int chunkCode, void* oldPtr) + { + if (!(m_serializationFlags & BT_SERIALIZE_NO_DUPLICATE_ASSERT)) + { + btAssert(!findPointer(oldPtr)); + } + + chunk->m_dna_nr = getReverseType(structType); + chunk->m_chunkCode = chunkCode; + //void* uniquePtr = getUniquePointer(oldPtr); + m_chunkP.insert(oldPtr, oldPtr); //chunk->m_oldPtr); + // chunk->m_oldPtr = uniquePtr;//oldPtr; + + void* uid = findPointer(oldPtr); + m_uid2ChunkPtr.insert(uid, chunk); + + switch (chunk->m_chunkCode) + { + case BT_SOFTBODY_CODE: + { +#ifdef BT_USE_DOUBLE_PRECISION + m_arrays.m_softBodyDoubleData.push_back((btSoftBodyDoubleData*)chunk->m_oldPtr); +#else + m_arrays.m_softBodyFloatData.push_back((btSoftBodyFloatData*)chunk->m_oldPtr); +#endif + break; + } + case BT_COLLISIONOBJECT_CODE: + { +#ifdef BT_USE_DOUBLE_PRECISION + m_arrays.m_collisionObjectDataDouble.push_back((btCollisionObjectDoubleData*)chunk->m_oldPtr); +#else //BT_USE_DOUBLE_PRECISION + m_arrays.m_collisionObjectDataFloat.push_back((btCollisionObjectFloatData*)chunk->m_oldPtr); +#endif //BT_USE_DOUBLE_PRECISION + break; + } + case BT_RIGIDBODY_CODE: + { +#ifdef BT_USE_DOUBLE_PRECISION + m_arrays.m_rigidBodyDataDouble.push_back((btRigidBodyDoubleData*)chunk->m_oldPtr); +#else + m_arrays.m_rigidBodyDataFloat.push_back((btRigidBodyFloatData*)chunk->m_oldPtr); +#endif //BT_USE_DOUBLE_PRECISION + break; + }; + case BT_CONSTRAINT_CODE: + { +#ifdef BT_USE_DOUBLE_PRECISION + m_arrays.m_constraintDataDouble.push_back((btTypedConstraintDoubleData*)chunk->m_oldPtr); +#else + m_arrays.m_constraintDataFloat.push_back((btTypedConstraintFloatData*)chunk->m_oldPtr); +#endif + break; + } + case BT_QUANTIZED_BVH_CODE: + { +#ifdef BT_USE_DOUBLE_PRECISION + m_arrays.m_bvhsDouble.push_back((btQuantizedBvhDoubleData*)chunk->m_oldPtr); +#else + m_arrays.m_bvhsFloat.push_back((btQuantizedBvhFloatData*)chunk->m_oldPtr); +#endif + break; + } + + case BT_SHAPE_CODE: + { + btCollisionShapeData* shapeData = (btCollisionShapeData*)chunk->m_oldPtr; + m_arrays.m_colShapeData.push_back(shapeData); + break; + } + case BT_TRIANLGE_INFO_MAP: + case BT_ARRAY_CODE: + case BT_SBMATERIAL_CODE: + case BT_SBNODE_CODE: + case BT_DYNAMICSWORLD_CODE: + case BT_DNA_CODE: + { + break; + } + default: + { + } + }; + } + + int getNumChunks() const + { + return m_uid2ChunkPtr.size(); + } + + const btChunk* getChunk(int chunkIndex) const + { + return *m_uid2ChunkPtr.getAtIndex(chunkIndex); + } +}; +#endif //ENABLE_INMEMORY_SERIALIZER + +#endif //BT_SERIALIZER_H diff --git a/pkg/mphysics/mbt/LinearMath/btSerializer.h.i b/pkg/mphysics/mbt/LinearMath/btSerializer.h.i new file mode 100644 index 00000000..165b8d78 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btSerializer.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btSerializer.h ---------------- + +%include "LinearMath/btSerializer.h" + +%{ +#include "LinearMath/btSerializer.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btSerializer64.cpp b/pkg/mphysics/mbt/LinearMath/btSerializer64.cpp new file mode 100644 index 00000000..6c4bc703 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btSerializer64.cpp @@ -0,0 +1,692 @@ +char sBulletDNAstr64[]= { +char(83),char(68),char(78),char(65),char(78),char(65),char(77),char(69),char(-74),char(1),char(0),char(0),char(109),char(95),char(115),char(105),char(122),char(101),char(0),char(109), +char(95),char(99),char(97),char(112),char(97),char(99),char(105),char(116),char(121),char(0),char(42),char(109),char(95),char(100),char(97),char(116),char(97),char(0),char(109),char(95), +char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(83),char(104),char(97),char(112),char(101),char(115),char(0),char(109),char(95),char(99),char(111), +char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(79),char(98),char(106),char(101),char(99),char(116),char(115),char(0),char(109),char(95),char(99),char(111),char(110), +char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(115),char(0),char(42),char(102),char(105),char(114),char(115),char(116),char(0),char(42),char(108),char(97),char(115), +char(116),char(0),char(109),char(95),char(102),char(108),char(111),char(97),char(116),char(115),char(91),char(52),char(93),char(0),char(109),char(95),char(101),char(108),char(91),char(51), +char(93),char(0),char(109),char(95),char(98),char(97),char(115),char(105),char(115),char(0),char(109),char(95),char(111),char(114),char(105),char(103),char(105),char(110),char(0),char(109), +char(95),char(114),char(111),char(111),char(116),char(78),char(111),char(100),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109),char(95),char(115),char(117),char(98), +char(116),char(114),char(101),char(101),char(83),char(105),char(122),char(101),char(0),char(109),char(95),char(113),char(117),char(97),char(110),char(116),char(105),char(122),char(101),char(100), +char(65),char(97),char(98),char(98),char(77),char(105),char(110),char(91),char(51),char(93),char(0),char(109),char(95),char(113),char(117),char(97),char(110),char(116),char(105),char(122), +char(101),char(100),char(65),char(97),char(98),char(98),char(77),char(97),char(120),char(91),char(51),char(93),char(0),char(109),char(95),char(97),char(97),char(98),char(98),char(77), +char(105),char(110),char(79),char(114),char(103),char(0),char(109),char(95),char(97),char(97),char(98),char(98),char(77),char(97),char(120),char(79),char(114),char(103),char(0),char(109), +char(95),char(101),char(115),char(99),char(97),char(112),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109),char(95),char(115),char(117),char(98),char(80),char(97), +char(114),char(116),char(0),char(109),char(95),char(116),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109), +char(95),char(112),char(97),char(100),char(91),char(52),char(93),char(0),char(109),char(95),char(101),char(115),char(99),char(97),char(112),char(101),char(73),char(110),char(100),char(101), +char(120),char(79),char(114),char(84),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109),char(95),char(98), +char(118),char(104),char(65),char(97),char(98),char(98),char(77),char(105),char(110),char(0),char(109),char(95),char(98),char(118),char(104),char(65),char(97),char(98),char(98),char(77), +char(97),char(120),char(0),char(109),char(95),char(98),char(118),char(104),char(81),char(117),char(97),char(110),char(116),char(105),char(122),char(97),char(116),char(105),char(111),char(110), +char(0),char(109),char(95),char(99),char(117),char(114),char(78),char(111),char(100),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109),char(95),char(117),char(115), +char(101),char(81),char(117),char(97),char(110),char(116),char(105),char(122),char(97),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(110),char(117),char(109),char(67), +char(111),char(110),char(116),char(105),char(103),char(117),char(111),char(117),char(115),char(76),char(101),char(97),char(102),char(78),char(111),char(100),char(101),char(115),char(0),char(109), +char(95),char(110),char(117),char(109),char(81),char(117),char(97),char(110),char(116),char(105),char(122),char(101),char(100),char(67),char(111),char(110),char(116),char(105),char(103),char(117), +char(111),char(117),char(115),char(78),char(111),char(100),char(101),char(115),char(0),char(42),char(109),char(95),char(99),char(111),char(110),char(116),char(105),char(103),char(117),char(111), +char(117),char(115),char(78),char(111),char(100),char(101),char(115),char(80),char(116),char(114),char(0),char(42),char(109),char(95),char(113),char(117),char(97),char(110),char(116),char(105), +char(122),char(101),char(100),char(67),char(111),char(110),char(116),char(105),char(103),char(117),char(111),char(117),char(115),char(78),char(111),char(100),char(101),char(115),char(80),char(116), +char(114),char(0),char(42),char(109),char(95),char(115),char(117),char(98),char(84),char(114),char(101),char(101),char(73),char(110),char(102),char(111),char(80),char(116),char(114),char(0), +char(109),char(95),char(116),char(114),char(97),char(118),char(101),char(114),char(115),char(97),char(108),char(77),char(111),char(100),char(101),char(0),char(109),char(95),char(110),char(117), +char(109),char(83),char(117),char(98),char(116),char(114),char(101),char(101),char(72),char(101),char(97),char(100),char(101),char(114),char(115),char(0),char(42),char(109),char(95),char(110), +char(97),char(109),char(101),char(0),char(109),char(95),char(115),char(104),char(97),char(112),char(101),char(84),char(121),char(112),char(101),char(0),char(109),char(95),char(112),char(97), +char(100),char(100),char(105),char(110),char(103),char(91),char(52),char(93),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110), +char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(109),char(95),char(108),char(111),char(99),char(97),char(108),char(83),char(99),char(97), +char(108),char(105),char(110),char(103),char(0),char(109),char(95),char(112),char(108),char(97),char(110),char(101),char(78),char(111),char(114),char(109),char(97),char(108),char(0),char(109), +char(95),char(112),char(108),char(97),char(110),char(101),char(67),char(111),char(110),char(115),char(116),char(97),char(110),char(116),char(0),char(109),char(95),char(105),char(109),char(112), +char(108),char(105),char(99),char(105),char(116),char(83),char(104),char(97),char(112),char(101),char(68),char(105),char(109),char(101),char(110),char(115),char(105),char(111),char(110),char(115), +char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(77),char(97),char(114),char(103),char(105),char(110),char(0),char(109), +char(95),char(112),char(97),char(100),char(100),char(105),char(110),char(103),char(0),char(109),char(95),char(112),char(111),char(115),char(0),char(109),char(95),char(114),char(97),char(100), +char(105),char(117),char(115),char(0),char(109),char(95),char(99),char(111),char(110),char(118),char(101),char(120),char(73),char(110),char(116),char(101),char(114),char(110),char(97),char(108), +char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(42),char(109),char(95),char(108),char(111),char(99),char(97),char(108),char(80),char(111), +char(115),char(105),char(116),char(105),char(111),char(110),char(65),char(114),char(114),char(97),char(121),char(80),char(116),char(114),char(0),char(109),char(95),char(108),char(111),char(99), +char(97),char(108),char(80),char(111),char(115),char(105),char(116),char(105),char(111),char(110),char(65),char(114),char(114),char(97),char(121),char(83),char(105),char(122),char(101),char(0), +char(109),char(95),char(118),char(97),char(108),char(117),char(101),char(0),char(109),char(95),char(112),char(97),char(100),char(91),char(50),char(93),char(0),char(109),char(95),char(118), +char(97),char(108),char(117),char(101),char(115),char(91),char(51),char(93),char(0),char(109),char(95),char(112),char(97),char(100),char(0),char(42),char(109),char(95),char(118),char(101), +char(114),char(116),char(105),char(99),char(101),char(115),char(51),char(102),char(0),char(42),char(109),char(95),char(118),char(101),char(114),char(116),char(105),char(99),char(101),char(115), +char(51),char(100),char(0),char(42),char(109),char(95),char(105),char(110),char(100),char(105),char(99),char(101),char(115),char(51),char(50),char(0),char(42),char(109),char(95),char(51), +char(105),char(110),char(100),char(105),char(99),char(101),char(115),char(49),char(54),char(0),char(42),char(109),char(95),char(51),char(105),char(110),char(100),char(105),char(99),char(101), +char(115),char(56),char(0),char(42),char(109),char(95),char(105),char(110),char(100),char(105),char(99),char(101),char(115),char(49),char(54),char(0),char(109),char(95),char(110),char(117), +char(109),char(84),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(86),char(101),char(114),char(116), +char(105),char(99),char(101),char(115),char(0),char(42),char(109),char(95),char(109),char(101),char(115),char(104),char(80),char(97),char(114),char(116),char(115),char(80),char(116),char(114), +char(0),char(109),char(95),char(115),char(99),char(97),char(108),char(105),char(110),char(103),char(0),char(109),char(95),char(110),char(117),char(109),char(77),char(101),char(115),char(104), +char(80),char(97),char(114),char(116),char(115),char(0),char(109),char(95),char(109),char(101),char(115),char(104),char(73),char(110),char(116),char(101),char(114),char(102),char(97),char(99), +char(101),char(0),char(42),char(109),char(95),char(113),char(117),char(97),char(110),char(116),char(105),char(122),char(101),char(100),char(70),char(108),char(111),char(97),char(116),char(66), +char(118),char(104),char(0),char(42),char(109),char(95),char(113),char(117),char(97),char(110),char(116),char(105),char(122),char(101),char(100),char(68),char(111),char(117),char(98),char(108), +char(101),char(66),char(118),char(104),char(0),char(42),char(109),char(95),char(116),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(73),char(110),char(102),char(111), +char(77),char(97),char(112),char(0),char(109),char(95),char(112),char(97),char(100),char(51),char(91),char(52),char(93),char(0),char(109),char(95),char(116),char(114),char(105),char(109), +char(101),char(115),char(104),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(109),char(95),char(116),char(114),char(97),char(110),char(115), +char(102),char(111),char(114),char(109),char(0),char(42),char(109),char(95),char(99),char(104),char(105),char(108),char(100),char(83),char(104),char(97),char(112),char(101),char(0),char(109), +char(95),char(99),char(104),char(105),char(108),char(100),char(83),char(104),char(97),char(112),char(101),char(84),char(121),char(112),char(101),char(0),char(109),char(95),char(99),char(104), +char(105),char(108),char(100),char(77),char(97),char(114),char(103),char(105),char(110),char(0),char(42),char(109),char(95),char(99),char(104),char(105),char(108),char(100),char(83),char(104), +char(97),char(112),char(101),char(80),char(116),char(114),char(0),char(109),char(95),char(110),char(117),char(109),char(67),char(104),char(105),char(108),char(100),char(83),char(104),char(97), +char(112),char(101),char(115),char(0),char(109),char(95),char(117),char(112),char(65),char(120),char(105),char(115),char(0),char(109),char(95),char(117),char(112),char(73),char(110),char(100), +char(101),char(120),char(0),char(109),char(95),char(102),char(108),char(97),char(103),char(115),char(0),char(109),char(95),char(101),char(100),char(103),char(101),char(86),char(48),char(86), +char(49),char(65),char(110),char(103),char(108),char(101),char(0),char(109),char(95),char(101),char(100),char(103),char(101),char(86),char(49),char(86),char(50),char(65),char(110),char(103), +char(108),char(101),char(0),char(109),char(95),char(101),char(100),char(103),char(101),char(86),char(50),char(86),char(48),char(65),char(110),char(103),char(108),char(101),char(0),char(42), +char(109),char(95),char(104),char(97),char(115),char(104),char(84),char(97),char(98),char(108),char(101),char(80),char(116),char(114),char(0),char(42),char(109),char(95),char(110),char(101), +char(120),char(116),char(80),char(116),char(114),char(0),char(42),char(109),char(95),char(118),char(97),char(108),char(117),char(101),char(65),char(114),char(114),char(97),char(121),char(80), +char(116),char(114),char(0),char(42),char(109),char(95),char(107),char(101),char(121),char(65),char(114),char(114),char(97),char(121),char(80),char(116),char(114),char(0),char(109),char(95), +char(99),char(111),char(110),char(118),char(101),char(120),char(69),char(112),char(115),char(105),char(108),char(111),char(110),char(0),char(109),char(95),char(112),char(108),char(97),char(110), +char(97),char(114),char(69),char(112),char(115),char(105),char(108),char(111),char(110),char(0),char(109),char(95),char(101),char(113),char(117),char(97),char(108),char(86),char(101),char(114), +char(116),char(101),char(120),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(101),char(100),char(103),char(101),char(68), +char(105),char(115),char(116),char(97),char(110),char(99),char(101),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(122), +char(101),char(114),char(111),char(65),char(114),char(101),char(97),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(110), +char(101),char(120),char(116),char(83),char(105),char(122),char(101),char(0),char(109),char(95),char(104),char(97),char(115),char(104),char(84),char(97),char(98),char(108),char(101),char(83), +char(105),char(122),char(101),char(0),char(109),char(95),char(110),char(117),char(109),char(86),char(97),char(108),char(117),char(101),char(115),char(0),char(109),char(95),char(110),char(117), +char(109),char(75),char(101),char(121),char(115),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(76),char(111), +char(99),char(97),char(108),char(80),char(111),char(105),char(110),char(116),char(65),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116), +char(67),char(97),char(99),char(104),char(101),char(76),char(111),char(99),char(97),char(108),char(80),char(111),char(105),char(110),char(116),char(66),char(91),char(52),char(93),char(0), +char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(80),char(111),char(115),char(105),char(116),char(105),char(111),char(110), +char(87),char(111),char(114),char(108),char(100),char(79),char(110),char(65),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67), +char(97),char(99),char(104),char(101),char(80),char(111),char(115),char(105),char(116),char(105),char(111),char(110),char(87),char(111),char(114),char(108),char(100),char(79),char(110),char(66), +char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(78),char(111),char(114),char(109), +char(97),char(108),char(87),char(111),char(114),char(108),char(100),char(79),char(110),char(66),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110), +char(116),char(67),char(97),char(99),char(104),char(101),char(76),char(97),char(116),char(101),char(114),char(97),char(108),char(70),char(114),char(105),char(99),char(116),char(105),char(111), +char(110),char(68),char(105),char(114),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104), +char(101),char(76),char(97),char(116),char(101),char(114),char(97),char(108),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(68),char(105),char(114),char(50), +char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(68),char(105),char(115),char(116), +char(97),char(110),char(99),char(101),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101), +char(65),char(112),char(112),char(108),char(105),char(101),char(100),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(91),char(52),char(93),char(0),char(109),char(95), +char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(80),char(114),char(101),char(118),char(82),char(72),char(83),char(91),char(52),char(93), +char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101), +char(100),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116), +char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101),char(100),char(82),char(111),char(108),char(108),char(105),char(110),char(103), +char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67), +char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101),char(100),char(83),char(112),char(105),char(110),char(110),char(105),char(110),char(103), +char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67), +char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101),char(100),char(82),char(101),char(115),char(116),char(105),char(116),char(117),char(116), +char(105),char(111),char(110),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(80), +char(97),char(114),char(116),char(73),char(100),char(48),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99), +char(104),char(101),char(80),char(97),char(114),char(116),char(73),char(100),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116), +char(67),char(97),char(99),char(104),char(101),char(73),char(110),char(100),char(101),char(120),char(48),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105), +char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(73),char(110),char(100),char(101),char(120),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112), +char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(80),char(111),char(105),char(110), +char(116),char(70),char(108),char(97),char(103),char(115),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99), +char(104),char(101),char(65),char(112),char(112),char(108),char(105),char(101),char(100),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(76),char(97),char(116),char(101), +char(114),char(97),char(108),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101), +char(65),char(112),char(112),char(108),char(105),char(101),char(100),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(76),char(97),char(116),char(101),char(114),char(97), +char(108),char(50),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111), +char(110),char(116),char(97),char(99),char(116),char(77),char(111),char(116),char(105),char(111),char(110),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111), +char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(77),char(111),char(116),char(105),char(111), +char(110),char(50),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111), +char(110),char(116),char(97),char(99),char(116),char(67),char(70),char(77),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67), +char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101),char(100),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(83), +char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115),char(49),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116), +char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(69),char(82),char(80),char(91),char(52),char(93),char(0),char(109), +char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(67),char(111),char(109),char(98),char(105),char(110),char(101),char(100),char(67), +char(111),char(110),char(116),char(97),char(99),char(116),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(49),char(91),char(52),char(93),char(0),char(109),char(95), +char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(67),char(70), +char(77),char(91),char(52),char(93),char(0),char(109),char(95),char(112),char(111),char(105),char(110),char(116),char(67),char(97),char(99),char(104),char(101),char(76),char(105),char(102), +char(101),char(84),char(105),char(109),char(101),char(91),char(52),char(93),char(0),char(109),char(95),char(110),char(117),char(109),char(67),char(97),char(99),char(104),char(101),char(100), +char(80),char(111),char(105),char(110),char(116),char(115),char(0),char(109),char(95),char(99),char(111),char(109),char(112),char(97),char(110),char(105),char(111),char(110),char(73),char(100), +char(65),char(0),char(109),char(95),char(99),char(111),char(109),char(112),char(97),char(110),char(105),char(111),char(110),char(73),char(100),char(66),char(0),char(109),char(95),char(105), +char(110),char(100),char(101),char(120),char(49),char(97),char(0),char(109),char(95),char(111),char(98),char(106),char(101),char(99),char(116),char(84),char(121),char(112),char(101),char(0), +char(109),char(95),char(99),char(111),char(110),char(116),char(97),char(99),char(116),char(66),char(114),char(101),char(97),char(107),char(105),char(110),char(103),char(84),char(104),char(114), +char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(99),char(111),char(110),char(116),char(97),char(99),char(116),char(80),char(114),char(111),char(99), +char(101),char(115),char(115),char(105),char(110),char(103),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(42),char(109),char(95),char(98), +char(111),char(100),char(121),char(48),char(0),char(42),char(109),char(95),char(98),char(111),char(100),char(121),char(49),char(0),char(109),char(95),char(103),char(105),char(109),char(112), +char(97),char(99),char(116),char(83),char(117),char(98),char(84),char(121),char(112),char(101),char(0),char(42),char(109),char(95),char(117),char(110),char(115),char(99),char(97),char(108), +char(101),char(100),char(80),char(111),char(105),char(110),char(116),char(115),char(70),char(108),char(111),char(97),char(116),char(80),char(116),char(114),char(0),char(42),char(109),char(95), +char(117),char(110),char(115),char(99),char(97),char(108),char(101),char(100),char(80),char(111),char(105),char(110),char(116),char(115),char(68),char(111),char(117),char(98),char(108),char(101), +char(80),char(116),char(114),char(0),char(109),char(95),char(110),char(117),char(109),char(85),char(110),char(115),char(99),char(97),char(108),char(101),char(100),char(80),char(111),char(105), +char(110),char(116),char(115),char(0),char(109),char(95),char(112),char(97),char(100),char(100),char(105),char(110),char(103),char(51),char(91),char(52),char(93),char(0),char(42),char(109), +char(95),char(98),char(114),char(111),char(97),char(100),char(112),char(104),char(97),char(115),char(101),char(72),char(97),char(110),char(100),char(108),char(101),char(0),char(42),char(109), +char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(83),char(104),char(97),char(112),char(101),char(0),char(42),char(109),char(95),char(114), +char(111),char(111),char(116),char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(83),char(104),char(97),char(112),char(101),char(0),char(109),char(95), +char(119),char(111),char(114),char(108),char(100),char(84),char(114),char(97),char(110),char(115),char(102),char(111),char(114),char(109),char(0),char(109),char(95),char(105),char(110),char(116), +char(101),char(114),char(112),char(111),char(108),char(97),char(116),char(105),char(111),char(110),char(87),char(111),char(114),char(108),char(100),char(84),char(114),char(97),char(110),char(115), +char(102),char(111),char(114),char(109),char(0),char(109),char(95),char(105),char(110),char(116),char(101),char(114),char(112),char(111),char(108),char(97),char(116),char(105),char(111),char(110), +char(76),char(105),char(110),char(101),char(97),char(114),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(105),char(110),char(116), +char(101),char(114),char(112),char(111),char(108),char(97),char(116),char(105),char(111),char(110),char(65),char(110),char(103),char(117),char(108),char(97),char(114),char(86),char(101),char(108), +char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(97),char(110),char(105),char(115),char(111),char(116),char(114),char(111),char(112),char(105),char(99),char(70), +char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(100),char(101),char(97),char(99),char(116),char(105),char(118),char(97),char(116),char(105), +char(111),char(110),char(84),char(105),char(109),char(101),char(0),char(109),char(95),char(102),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95), +char(114),char(111),char(108),char(108),char(105),char(110),char(103),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(99),char(111), +char(110),char(116),char(97),char(99),char(116),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(99),char(111),char(110),char(116),char(97), +char(99),char(116),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(114),char(101),char(115),char(116),char(105),char(116), +char(117),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(104),char(105),char(116),char(70),char(114),char(97),char(99),char(116),char(105),char(111),char(110),char(0), +char(109),char(95),char(99),char(99),char(100),char(83),char(119),char(101),char(112),char(116),char(83),char(112),char(104),char(101),char(114),char(101),char(82),char(97),char(100),char(105), +char(117),char(115),char(0),char(109),char(95),char(99),char(99),char(100),char(77),char(111),char(116),char(105),char(111),char(110),char(84),char(104),char(114),char(101),char(115),char(104), +char(111),char(108),char(100),char(0),char(109),char(95),char(104),char(97),char(115),char(65),char(110),char(105),char(115),char(111),char(116),char(114),char(111),char(112),char(105),char(99), +char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110), +char(70),char(108),char(97),char(103),char(115),char(0),char(109),char(95),char(105),char(115),char(108),char(97),char(110),char(100),char(84),char(97),char(103),char(49),char(0),char(109), +char(95),char(99),char(111),char(109),char(112),char(97),char(110),char(105),char(111),char(110),char(73),char(100),char(0),char(109),char(95),char(97),char(99),char(116),char(105),char(118), +char(97),char(116),char(105),char(111),char(110),char(83),char(116),char(97),char(116),char(101),char(49),char(0),char(109),char(95),char(105),char(110),char(116),char(101),char(114),char(110), +char(97),char(108),char(84),char(121),char(112),char(101),char(0),char(109),char(95),char(99),char(104),char(101),char(99),char(107),char(67),char(111),char(108),char(108),char(105),char(100), +char(101),char(87),char(105),char(116),char(104),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(70),char(105),char(108), +char(116),char(101),char(114),char(71),char(114),char(111),char(117),char(112),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110), +char(70),char(105),char(108),char(116),char(101),char(114),char(77),char(97),char(115),char(107),char(0),char(109),char(95),char(117),char(110),char(105),char(113),char(117),char(101),char(73), +char(100),char(0),char(109),char(95),char(116),char(97),char(117),char(0),char(109),char(95),char(100),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95), +char(116),char(105),char(109),char(101),char(83),char(116),char(101),char(112),char(0),char(109),char(95),char(109),char(97),char(120),char(69),char(114),char(114),char(111),char(114),char(82), +char(101),char(100),char(117),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(115),char(111),char(114),char(0),char(109),char(95),char(101),char(114),char(112), +char(0),char(109),char(95),char(101),char(114),char(112),char(50),char(0),char(109),char(95),char(103),char(108),char(111),char(98),char(97),char(108),char(67),char(102),char(109),char(0), +char(109),char(95),char(115),char(112),char(108),char(105),char(116),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(80),char(101),char(110),char(101),char(116),char(114), +char(97),char(116),char(105),char(111),char(110),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(115),char(112),char(108), +char(105),char(116),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(84),char(117),char(114),char(110),char(69),char(114),char(112),char(0),char(109),char(95),char(108), +char(105),char(110),char(101),char(97),char(114),char(83),char(108),char(111),char(112),char(0),char(109),char(95),char(119),char(97),char(114),char(109),char(115),char(116),char(97),char(114), +char(116),char(105),char(110),char(103),char(70),char(97),char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(97),char(114),char(116),char(105),char(99),char(117),char(108), +char(97),char(116),char(101),char(100),char(87),char(97),char(114),char(109),char(115),char(116),char(97),char(114),char(116),char(105),char(110),char(103),char(70),char(97),char(99),char(116), +char(111),char(114),char(0),char(109),char(95),char(109),char(97),char(120),char(71),char(121),char(114),char(111),char(115),char(99),char(111),char(112),char(105),char(99),char(70),char(111), +char(114),char(99),char(101),char(0),char(109),char(95),char(115),char(105),char(110),char(103),char(108),char(101),char(65),char(120),char(105),char(115),char(82),char(111),char(108),char(108), +char(105),char(110),char(103),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100), +char(0),char(109),char(95),char(110),char(117),char(109),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95),char(115), +char(111),char(108),char(118),char(101),char(114),char(77),char(111),char(100),char(101),char(0),char(109),char(95),char(114),char(101),char(115),char(116),char(105),char(110),char(103),char(67), +char(111),char(110),char(116),char(97),char(99),char(116),char(82),char(101),char(115),char(116),char(105),char(116),char(117),char(116),char(105),char(111),char(110),char(84),char(104),char(114), +char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(109),char(105),char(110),char(105),char(109),char(117),char(109),char(83),char(111),char(108),char(118), +char(101),char(114),char(66),char(97),char(116),char(99),char(104),char(83),char(105),char(122),char(101),char(0),char(109),char(95),char(115),char(112),char(108),char(105),char(116),char(73), +char(109),char(112),char(117),char(108),char(115),char(101),char(0),char(109),char(95),char(115),char(111),char(108),char(118),char(101),char(114),char(73),char(110),char(102),char(111),char(0), +char(109),char(95),char(103),char(114),char(97),char(118),char(105),char(116),char(121),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105),char(115),char(105),char(111), +char(110),char(79),char(98),char(106),char(101),char(99),char(116),char(68),char(97),char(116),char(97),char(0),char(109),char(95),char(105),char(110),char(118),char(73),char(110),char(101), +char(114),char(116),char(105),char(97),char(84),char(101),char(110),char(115),char(111),char(114),char(87),char(111),char(114),char(108),char(100),char(0),char(109),char(95),char(108),char(105), +char(110),char(101),char(97),char(114),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108), +char(97),char(114),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114), +char(70),char(97),char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(70),char(97),char(99),char(116),char(111), +char(114),char(0),char(109),char(95),char(103),char(114),char(97),char(118),char(105),char(116),char(121),char(95),char(97),char(99),char(99),char(101),char(108),char(101),char(114),char(97), +char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(105),char(110),char(118),char(73),char(110),char(101),char(114),char(116),char(105),char(97),char(76),char(111),char(99), +char(97),char(108),char(0),char(109),char(95),char(116),char(111),char(116),char(97),char(108),char(70),char(111),char(114),char(99),char(101),char(0),char(109),char(95),char(116),char(111), +char(116),char(97),char(108),char(84),char(111),char(114),char(113),char(117),char(101),char(0),char(109),char(95),char(105),char(110),char(118),char(101),char(114),char(115),char(101),char(77), +char(97),char(115),char(115),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(0), +char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(97), +char(100),char(100),char(105),char(116),char(105),char(111),char(110),char(97),char(108),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(70),char(97),char(99),char(116), +char(111),char(114),char(0),char(109),char(95),char(97),char(100),char(100),char(105),char(116),char(105),char(111),char(110),char(97),char(108),char(76),char(105),char(110),char(101),char(97), +char(114),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(83),char(113),char(114), +char(0),char(109),char(95),char(97),char(100),char(100),char(105),char(116),char(105),char(111),char(110),char(97),char(108),char(65),char(110),char(103),char(117),char(108),char(97),char(114), +char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(83),char(113),char(114),char(0), +char(109),char(95),char(97),char(100),char(100),char(105),char(116),char(105),char(111),char(110),char(97),char(108),char(65),char(110),char(103),char(117),char(108),char(97),char(114),char(68), +char(97),char(109),char(112),char(105),char(110),char(103),char(70),char(97),char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97), +char(114),char(83),char(108),char(101),char(101),char(112),char(105),char(110),char(103),char(84),char(104),char(114),char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109), +char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83),char(108),char(101),char(101),char(112),char(105),char(110),char(103),char(84),char(104),char(114),char(101), +char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(97),char(100),char(100),char(105),char(116),char(105),char(111),char(110),char(97),char(108),char(68),char(97), +char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(110),char(117),char(109),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110), +char(116),char(82),char(111),char(119),char(115),char(0),char(110),char(117),char(98),char(0),char(42),char(109),char(95),char(114),char(98),char(65),char(0),char(42),char(109),char(95), +char(114),char(98),char(66),char(0),char(109),char(95),char(117),char(115),char(101),char(114),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116), +char(84),char(121),char(112),char(101),char(0),char(109),char(95),char(117),char(115),char(101),char(114),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110), +char(116),char(73),char(100),char(0),char(109),char(95),char(110),char(101),char(101),char(100),char(115),char(70),char(101),char(101),char(100),char(98),char(97),char(99),char(107),char(0), +char(109),char(95),char(97),char(112),char(112),char(108),char(105),char(101),char(100),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(0),char(109),char(95),char(100), +char(98),char(103),char(68),char(114),char(97),char(119),char(83),char(105),char(122),char(101),char(0),char(109),char(95),char(100),char(105),char(115),char(97),char(98),char(108),char(101), +char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(115),char(66),char(101),char(116),char(119),char(101),char(101),char(110),char(76),char(105),char(110), +char(107),char(101),char(100),char(66),char(111),char(100),char(105),char(101),char(115),char(0),char(109),char(95),char(111),char(118),char(101),char(114),char(114),char(105),char(100),char(101), +char(78),char(117),char(109),char(83),char(111),char(108),char(118),char(101),char(114),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0), +char(109),char(95),char(98),char(114),char(101),char(97),char(107),char(105),char(110),char(103),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(84),char(104),char(114), +char(101),char(115),char(104),char(111),char(108),char(100),char(0),char(109),char(95),char(105),char(115),char(69),char(110),char(97),char(98),char(108),char(101),char(100),char(0),char(112), +char(97),char(100),char(100),char(105),char(110),char(103),char(91),char(52),char(93),char(0),char(109),char(95),char(116),char(121),char(112),char(101),char(67),char(111),char(110),char(115), +char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(97),char(116),char(97),char(0),char(109),char(95),char(112),char(105),char(118),char(111),char(116),char(73),char(110), +char(65),char(0),char(109),char(95),char(112),char(105),char(118),char(111),char(116),char(73),char(110),char(66),char(0),char(109),char(95),char(114),char(98),char(65),char(70),char(114), +char(97),char(109),char(101),char(0),char(109),char(95),char(114),char(98),char(66),char(70),char(114),char(97),char(109),char(101),char(0),char(109),char(95),char(117),char(115),char(101), +char(82),char(101),char(102),char(101),char(114),char(101),char(110),char(99),char(101),char(70),char(114),char(97),char(109),char(101),char(65),char(0),char(109),char(95),char(97),char(110), +char(103),char(117),char(108),char(97),char(114),char(79),char(110),char(108),char(121),char(0),char(109),char(95),char(101),char(110),char(97),char(98),char(108),char(101),char(65),char(110), +char(103),char(117),char(108),char(97),char(114),char(77),char(111),char(116),char(111),char(114),char(0),char(109),char(95),char(109),char(111),char(116),char(111),char(114),char(84),char(97), +char(114),char(103),char(101),char(116),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(109),char(97),char(120),char(77),char(111), +char(116),char(111),char(114),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(0),char(109),char(95),char(108),char(111),char(119),char(101),char(114),char(76),char(105), +char(109),char(105),char(116),char(0),char(109),char(95),char(117),char(112),char(112),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95),char(108), +char(105),char(109),char(105),char(116),char(83),char(111),char(102),char(116),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(98),char(105),char(97),char(115),char(70), +char(97),char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(114),char(101),char(108),char(97),char(120),char(97),char(116),char(105),char(111),char(110),char(70),char(97), +char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(112),char(97),char(100),char(100),char(105),char(110),char(103),char(49),char(91),char(52),char(93),char(0),char(109), +char(95),char(115),char(119),char(105),char(110),char(103),char(83),char(112),char(97),char(110),char(49),char(0),char(109),char(95),char(115),char(119),char(105),char(110),char(103),char(83), +char(112),char(97),char(110),char(50),char(0),char(109),char(95),char(116),char(119),char(105),char(115),char(116),char(83),char(112),char(97),char(110),char(0),char(109),char(95),char(108), +char(105),char(110),char(101),char(97),char(114),char(85),char(112),char(112),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95),char(108),char(105), +char(110),char(101),char(97),char(114),char(76),char(111),char(119),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95),char(97),char(110),char(103), +char(117),char(108),char(97),char(114),char(85),char(112),char(112),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95),char(97),char(110),char(103), +char(117),char(108),char(97),char(114),char(76),char(111),char(119),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95),char(117),char(115),char(101), +char(76),char(105),char(110),char(101),char(97),char(114),char(82),char(101),char(102),char(101),char(114),char(101),char(110),char(99),char(101),char(70),char(114),char(97),char(109),char(101), +char(65),char(0),char(109),char(95),char(117),char(115),char(101),char(79),char(102),char(102),char(115),char(101),char(116),char(70),char(111),char(114),char(67),char(111),char(110),char(115), +char(116),char(114),char(97),char(105),char(110),char(116),char(70),char(114),char(97),char(109),char(101),char(0),char(109),char(95),char(54),char(100),char(111),char(102),char(68),char(97), +char(116),char(97),char(0),char(109),char(95),char(115),char(112),char(114),char(105),char(110),char(103),char(69),char(110),char(97),char(98),char(108),char(101),char(100),char(91),char(54), +char(93),char(0),char(109),char(95),char(101),char(113),char(117),char(105),char(108),char(105),char(98),char(114),char(105),char(117),char(109),char(80),char(111),char(105),char(110),char(116), +char(91),char(54),char(93),char(0),char(109),char(95),char(115),char(112),char(114),char(105),char(110),char(103),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115), +char(115),char(91),char(54),char(93),char(0),char(109),char(95),char(115),char(112),char(114),char(105),char(110),char(103),char(68),char(97),char(109),char(112),char(105),char(110),char(103), +char(91),char(54),char(93),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(66),char(111),char(117),char(110),char(99),char(101),char(0),char(109), +char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(116),char(111),char(112),char(69),char(82),char(80),char(0),char(109),char(95),char(108),char(105),char(110), +char(101),char(97),char(114),char(83),char(116),char(111),char(112),char(67),char(70),char(77),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(77), +char(111),char(116),char(111),char(114),char(69),char(82),char(80),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(77),char(111),char(116),char(111), +char(114),char(67),char(70),char(77),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(84),char(97),char(114),char(103),char(101),char(116),char(86), +char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(77),char(97),char(120),char(77), +char(111),char(116),char(111),char(114),char(70),char(111),char(114),char(99),char(101),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(101), +char(114),char(118),char(111),char(84),char(97),char(114),char(103),char(101),char(116),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(112), +char(114),char(105),char(110),char(103),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(108),char(105),char(110),char(101), +char(97),char(114),char(83),char(112),char(114),char(105),char(110),char(103),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(108),char(105), +char(110),char(101),char(97),char(114),char(69),char(113),char(117),char(105),char(108),char(105),char(98),char(114),char(105),char(117),char(109),char(80),char(111),char(105),char(110),char(116), +char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(69),char(110),char(97),char(98),char(108),char(101),char(77),char(111),char(116),char(111),char(114), +char(91),char(52),char(93),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(101),char(114),char(118),char(111),char(77),char(111),char(116), +char(111),char(114),char(91),char(52),char(93),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(69),char(110),char(97),char(98),char(108),char(101), +char(83),char(112),char(114),char(105),char(110),char(103),char(91),char(52),char(93),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(112), +char(114),char(105),char(110),char(103),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115),char(76),char(105),char(109),char(105),char(116),char(101),char(100), +char(91),char(52),char(93),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(112),char(114),char(105),char(110),char(103),char(68),char(97), +char(109),char(112),char(105),char(110),char(103),char(76),char(105),char(109),char(105),char(116),char(101),char(100),char(91),char(52),char(93),char(0),char(109),char(95),char(97),char(110), +char(103),char(117),char(108),char(97),char(114),char(66),char(111),char(117),char(110),char(99),char(101),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97), +char(114),char(83),char(116),char(111),char(112),char(69),char(82),char(80),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83),char(116), +char(111),char(112),char(67),char(70),char(77),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(77),char(111),char(116),char(111),char(114), +char(69),char(82),char(80),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(77),char(111),char(116),char(111),char(114),char(67),char(70), +char(77),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(84),char(97),char(114),char(103),char(101),char(116),char(86),char(101),char(108), +char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(77),char(97),char(120),char(77),char(111), +char(116),char(111),char(114),char(70),char(111),char(114),char(99),char(101),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83),char(101), +char(114),char(118),char(111),char(84),char(97),char(114),char(103),char(101),char(116),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83), +char(112),char(114),char(105),char(110),char(103),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(97),char(110),char(103), +char(117),char(108),char(97),char(114),char(83),char(112),char(114),char(105),char(110),char(103),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95), +char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(69),char(113),char(117),char(105),char(108),char(105),char(98),char(114),char(105),char(117),char(109),char(80),char(111), +char(105),char(110),char(116),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(69),char(110),char(97),char(98),char(108),char(101),char(77), +char(111),char(116),char(111),char(114),char(91),char(52),char(93),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83),char(101),char(114), +char(118),char(111),char(77),char(111),char(116),char(111),char(114),char(91),char(52),char(93),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114), +char(69),char(110),char(97),char(98),char(108),char(101),char(83),char(112),char(114),char(105),char(110),char(103),char(91),char(52),char(93),char(0),char(109),char(95),char(97),char(110), +char(103),char(117),char(108),char(97),char(114),char(83),char(112),char(114),char(105),char(110),char(103),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115), +char(76),char(105),char(109),char(105),char(116),char(101),char(100),char(91),char(52),char(93),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114), +char(83),char(112),char(114),char(105),char(110),char(103),char(68),char(97),char(109),char(112),char(105),char(110),char(103),char(76),char(105),char(109),char(105),char(116),char(101),char(100), +char(91),char(52),char(93),char(0),char(109),char(95),char(114),char(111),char(116),char(97),char(116),char(101),char(79),char(114),char(100),char(101),char(114),char(0),char(109),char(95), +char(97),char(120),char(105),char(115),char(73),char(110),char(65),char(0),char(109),char(95),char(97),char(120),char(105),char(115),char(73),char(110),char(66),char(0),char(109),char(95), +char(114),char(97),char(116),char(105),char(111),char(0),char(109),char(95),char(108),char(105),char(110),char(101),char(97),char(114),char(83),char(116),char(105),char(102),char(102),char(110), +char(101),char(115),char(115),char(0),char(109),char(95),char(97),char(110),char(103),char(117),char(108),char(97),char(114),char(83),char(116),char(105),char(102),char(102),char(110),char(101), +char(115),char(115),char(0),char(109),char(95),char(118),char(111),char(108),char(117),char(109),char(101),char(83),char(116),char(105),char(102),char(102),char(110),char(101),char(115),char(115), +char(0),char(42),char(109),char(95),char(109),char(97),char(116),char(101),char(114),char(105),char(97),char(108),char(0),char(109),char(95),char(112),char(111),char(115),char(105),char(116), +char(105),char(111),char(110),char(0),char(109),char(95),char(112),char(114),char(101),char(118),char(105),char(111),char(117),char(115),char(80),char(111),char(115),char(105),char(116),char(105), +char(111),char(110),char(0),char(109),char(95),char(118),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(97),char(99),char(99),char(117), +char(109),char(117),char(108),char(97),char(116),char(101),char(100),char(70),char(111),char(114),char(99),char(101),char(0),char(109),char(95),char(110),char(111),char(114),char(109),char(97), +char(108),char(0),char(109),char(95),char(97),char(114),char(101),char(97),char(0),char(109),char(95),char(97),char(116),char(116),char(97),char(99),char(104),char(0),char(109),char(95), +char(110),char(111),char(100),char(101),char(73),char(110),char(100),char(105),char(99),char(101),char(115),char(91),char(50),char(93),char(0),char(109),char(95),char(114),char(101),char(115), +char(116),char(76),char(101),char(110),char(103),char(116),char(104),char(0),char(109),char(95),char(98),char(98),char(101),char(110),char(100),char(105),char(110),char(103),char(0),char(109), +char(95),char(110),char(111),char(100),char(101),char(73),char(110),char(100),char(105),char(99),char(101),char(115),char(91),char(51),char(93),char(0),char(109),char(95),char(114),char(101), +char(115),char(116),char(65),char(114),char(101),char(97),char(0),char(109),char(95),char(99),char(48),char(91),char(52),char(93),char(0),char(109),char(95),char(110),char(111),char(100), +char(101),char(73),char(110),char(100),char(105),char(99),char(101),char(115),char(91),char(52),char(93),char(0),char(109),char(95),char(114),char(101),char(115),char(116),char(86),char(111), +char(108),char(117),char(109),char(101),char(0),char(109),char(95),char(99),char(49),char(0),char(109),char(95),char(99),char(50),char(0),char(109),char(95),char(99),char(48),char(0), +char(109),char(95),char(108),char(111),char(99),char(97),char(108),char(70),char(114),char(97),char(109),char(101),char(0),char(42),char(109),char(95),char(114),char(105),char(103),char(105), +char(100),char(66),char(111),char(100),char(121),char(0),char(109),char(95),char(110),char(111),char(100),char(101),char(73),char(110),char(100),char(101),char(120),char(0),char(109),char(95), +char(97),char(101),char(114),char(111),char(77),char(111),char(100),char(101),char(108),char(0),char(109),char(95),char(98),char(97),char(117),char(109),char(103),char(97),char(114),char(116), +char(101),char(0),char(109),char(95),char(100),char(114),char(97),char(103),char(0),char(109),char(95),char(108),char(105),char(102),char(116),char(0),char(109),char(95),char(112),char(114), +char(101),char(115),char(115),char(117),char(114),char(101),char(0),char(109),char(95),char(118),char(111),char(108),char(117),char(109),char(101),char(0),char(109),char(95),char(100),char(121), +char(110),char(97),char(109),char(105),char(99),char(70),char(114),char(105),char(99),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(112),char(111),char(115),char(101), +char(77),char(97),char(116),char(99),char(104),char(0),char(109),char(95),char(114),char(105),char(103),char(105),char(100),char(67),char(111),char(110),char(116),char(97),char(99),char(116), +char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(107),char(105),char(110),char(101),char(116),char(105),char(99),char(67),char(111), +char(110),char(116),char(97),char(99),char(116),char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(115),char(111),char(102),char(116), +char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(97),char(110), +char(99),char(104),char(111),char(114),char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(115),char(111),char(102),char(116),char(82), +char(105),char(103),char(105),char(100),char(67),char(108),char(117),char(115),char(116),char(101),char(114),char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0), +char(109),char(95),char(115),char(111),char(102),char(116),char(75),char(105),char(110),char(101),char(116),char(105),char(99),char(67),char(108),char(117),char(115),char(116),char(101),char(114), +char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(115),char(111),char(102),char(116),char(83),char(111),char(102),char(116),char(67), +char(108),char(117),char(115),char(116),char(101),char(114),char(72),char(97),char(114),char(100),char(110),char(101),char(115),char(115),char(0),char(109),char(95),char(115),char(111),char(102), +char(116),char(82),char(105),char(103),char(105),char(100),char(67),char(108),char(117),char(115),char(116),char(101),char(114),char(73),char(109),char(112),char(117),char(108),char(115),char(101), +char(83),char(112),char(108),char(105),char(116),char(0),char(109),char(95),char(115),char(111),char(102),char(116),char(75),char(105),char(110),char(101),char(116),char(105),char(99),char(67), +char(108),char(117),char(115),char(116),char(101),char(114),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(83),char(112),char(108),char(105),char(116),char(0),char(109), +char(95),char(115),char(111),char(102),char(116),char(83),char(111),char(102),char(116),char(67),char(108),char(117),char(115),char(116),char(101),char(114),char(73),char(109),char(112),char(117), +char(108),char(115),char(101),char(83),char(112),char(108),char(105),char(116),char(0),char(109),char(95),char(109),char(97),char(120),char(86),char(111),char(108),char(117),char(109),char(101), +char(0),char(109),char(95),char(116),char(105),char(109),char(101),char(83),char(99),char(97),char(108),char(101),char(0),char(109),char(95),char(118),char(101),char(108),char(111),char(99), +char(105),char(116),char(121),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95),char(112),char(111),char(115),char(105), +char(116),char(105),char(111),char(110),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95),char(100),char(114),char(105), +char(102),char(116),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95),char(99),char(108),char(117),char(115),char(116), +char(101),char(114),char(73),char(116),char(101),char(114),char(97),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95),char(114),char(111),char(116),char(0),char(109), +char(95),char(115),char(99),char(97),char(108),char(101),char(0),char(109),char(95),char(97),char(113),char(113),char(0),char(109),char(95),char(99),char(111),char(109),char(0),char(42), +char(109),char(95),char(112),char(111),char(115),char(105),char(116),char(105),char(111),char(110),char(115),char(0),char(42),char(109),char(95),char(119),char(101),char(105),char(103),char(104), +char(116),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(80),char(111),char(115),char(105),char(116),char(105),char(111),char(110),char(115),char(0),char(109),char(95), +char(110),char(117),char(109),char(87),char(101),char(105),char(103),char(116),char(115),char(0),char(109),char(95),char(98),char(118),char(111),char(108),char(117),char(109),char(101),char(0), +char(109),char(95),char(98),char(102),char(114),char(97),char(109),char(101),char(0),char(109),char(95),char(102),char(114),char(97),char(109),char(101),char(120),char(102),char(111),char(114), +char(109),char(0),char(109),char(95),char(108),char(111),char(99),char(105),char(105),char(0),char(109),char(95),char(105),char(110),char(118),char(119),char(105),char(0),char(109),char(95), +char(118),char(105),char(109),char(112),char(117),char(108),char(115),char(101),char(115),char(91),char(50),char(93),char(0),char(109),char(95),char(100),char(105),char(109),char(112),char(117), +char(108),char(115),char(101),char(115),char(91),char(50),char(93),char(0),char(109),char(95),char(108),char(118),char(0),char(109),char(95),char(97),char(118),char(0),char(42),char(109), +char(95),char(102),char(114),char(97),char(109),char(101),char(114),char(101),char(102),char(115),char(0),char(42),char(109),char(95),char(110),char(111),char(100),char(101),char(73),char(110), +char(100),char(105),char(99),char(101),char(115),char(0),char(42),char(109),char(95),char(109),char(97),char(115),char(115),char(101),char(115),char(0),char(109),char(95),char(110),char(117), +char(109),char(70),char(114),char(97),char(109),char(101),char(82),char(101),char(102),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(78),char(111),char(100),char(101), +char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(77),char(97),char(115),char(115),char(101),char(115),char(0),char(109),char(95),char(105),char(100),char(109),char(97), +char(115),char(115),char(0),char(109),char(95),char(105),char(109),char(97),char(115),char(115),char(0),char(109),char(95),char(110),char(118),char(105),char(109),char(112),char(117),char(108), +char(115),char(101),char(115),char(0),char(109),char(95),char(110),char(100),char(105),char(109),char(112),char(117),char(108),char(115),char(101),char(115),char(0),char(109),char(95),char(110), +char(100),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(108),char(100),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109), +char(95),char(97),char(100),char(97),char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(109),char(97),char(116),char(99),char(104),char(105),char(110),char(103), +char(0),char(109),char(95),char(109),char(97),char(120),char(83),char(101),char(108),char(102),char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(73), +char(109),char(112),char(117),char(108),char(115),char(101),char(0),char(109),char(95),char(115),char(101),char(108),char(102),char(67),char(111),char(108),char(108),char(105),char(115),char(105), +char(111),char(110),char(73),char(109),char(112),char(117),char(108),char(115),char(101),char(70),char(97),char(99),char(116),char(111),char(114),char(0),char(109),char(95),char(99),char(111), +char(110),char(116),char(97),char(105),char(110),char(115),char(65),char(110),char(99),char(104),char(111),char(114),char(0),char(109),char(95),char(99),char(111),char(108),char(108),char(105), +char(100),char(101),char(0),char(109),char(95),char(99),char(108),char(117),char(115),char(116),char(101),char(114),char(73),char(110),char(100),char(101),char(120),char(0),char(42),char(109), +char(95),char(98),char(111),char(100),char(121),char(65),char(0),char(42),char(109),char(95),char(98),char(111),char(100),char(121),char(66),char(0),char(109),char(95),char(114),char(101), +char(102),char(115),char(91),char(50),char(93),char(0),char(109),char(95),char(99),char(102),char(109),char(0),char(109),char(95),char(115),char(112),char(108),char(105),char(116),char(0), +char(109),char(95),char(100),char(101),char(108),char(101),char(116),char(101),char(0),char(109),char(95),char(114),char(101),char(108),char(80),char(111),char(115),char(105),char(116),char(105), +char(111),char(110),char(91),char(50),char(93),char(0),char(109),char(95),char(98),char(111),char(100),char(121),char(65),char(116),char(121),char(112),char(101),char(0),char(109),char(95), +char(98),char(111),char(100),char(121),char(66),char(116),char(121),char(112),char(101),char(0),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(84),char(121),char(112), +char(101),char(0),char(42),char(109),char(95),char(112),char(111),char(115),char(101),char(0),char(42),char(42),char(109),char(95),char(109),char(97),char(116),char(101),char(114),char(105), +char(97),char(108),char(115),char(0),char(42),char(109),char(95),char(110),char(111),char(100),char(101),char(115),char(0),char(42),char(109),char(95),char(108),char(105),char(110),char(107), +char(115),char(0),char(42),char(109),char(95),char(102),char(97),char(99),char(101),char(115),char(0),char(42),char(109),char(95),char(116),char(101),char(116),char(114),char(97),char(104), +char(101),char(100),char(114),char(97),char(0),char(42),char(109),char(95),char(97),char(110),char(99),char(104),char(111),char(114),char(115),char(0),char(42),char(109),char(95),char(99), +char(108),char(117),char(115),char(116),char(101),char(114),char(115),char(0),char(42),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(115),char(0),char(109),char(95), +char(110),char(117),char(109),char(77),char(97),char(116),char(101),char(114),char(105),char(97),char(108),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(76),char(105), +char(110),char(107),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(70),char(97),char(99),char(101),char(115),char(0),char(109),char(95),char(110),char(117),char(109), +char(84),char(101),char(116),char(114),char(97),char(104),char(101),char(100),char(114),char(97),char(0),char(109),char(95),char(110),char(117),char(109),char(65),char(110),char(99),char(104), +char(111),char(114),char(115),char(0),char(109),char(95),char(110),char(117),char(109),char(67),char(108),char(117),char(115),char(116),char(101),char(114),char(115),char(0),char(109),char(95), +char(110),char(117),char(109),char(74),char(111),char(105),char(110),char(116),char(115),char(0),char(109),char(95),char(99),char(111),char(110),char(102),char(105),char(103),char(0),char(109), +char(95),char(122),char(101),char(114),char(111),char(82),char(111),char(116),char(80),char(97),char(114),char(101),char(110),char(116),char(84),char(111),char(84),char(104),char(105),char(115), +char(0),char(109),char(95),char(112),char(97),char(114),char(101),char(110),char(116),char(67),char(111),char(109),char(84),char(111),char(84),char(104),char(105),char(115),char(80),char(105), +char(118),char(111),char(116),char(79),char(102),char(102),char(115),char(101),char(116),char(0),char(109),char(95),char(116),char(104),char(105),char(115),char(80),char(105),char(118),char(111), +char(116),char(84),char(111),char(84),char(104),char(105),char(115),char(67),char(111),char(109),char(79),char(102),char(102),char(115),char(101),char(116),char(0),char(109),char(95),char(106), +char(111),char(105),char(110),char(116),char(65),char(120),char(105),char(115),char(84),char(111),char(112),char(91),char(54),char(93),char(0),char(109),char(95),char(106),char(111),char(105), +char(110),char(116),char(65),char(120),char(105),char(115),char(66),char(111),char(116),char(116),char(111),char(109),char(91),char(54),char(93),char(0),char(109),char(95),char(108),char(105), +char(110),char(107),char(73),char(110),char(101),char(114),char(116),char(105),char(97),char(0),char(109),char(95),char(97),char(98),char(115),char(70),char(114),char(97),char(109),char(101), +char(84),char(111),char(116),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(84),char(111),char(112),char(0),char(109),char(95),char(97),char(98),char(115), +char(70),char(114),char(97),char(109),char(101),char(84),char(111),char(116),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(66),char(111),char(116),char(116), +char(111),char(109),char(0),char(109),char(95),char(97),char(98),char(115),char(70),char(114),char(97),char(109),char(101),char(76),char(111),char(99),char(86),char(101),char(108),char(111), +char(99),char(105),char(116),char(121),char(84),char(111),char(112),char(0),char(109),char(95),char(97),char(98),char(115),char(70),char(114),char(97),char(109),char(101),char(76),char(111), +char(99),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(66),char(111),char(116),char(116),char(111),char(109),char(0),char(109),char(95),char(108),char(105), +char(110),char(107),char(77),char(97),char(115),char(115),char(0),char(109),char(95),char(112),char(97),char(114),char(101),char(110),char(116),char(73),char(110),char(100),char(101),char(120), +char(0),char(109),char(95),char(100),char(111),char(102),char(67),char(111),char(117),char(110),char(116),char(0),char(109),char(95),char(112),char(111),char(115),char(86),char(97),char(114), +char(67),char(111),char(117),char(110),char(116),char(0),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(80),char(111),char(115),char(91),char(55),char(93),char(0), +char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(86),char(101),char(108),char(91),char(54),char(93),char(0),char(109),char(95),char(106),char(111),char(105),char(110), +char(116),char(84),char(111),char(114),char(113),char(117),char(101),char(91),char(54),char(93),char(0),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(68),char(97), +char(109),char(112),char(105),char(110),char(103),char(0),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(70),char(114),char(105),char(99),char(116),char(105),char(111), +char(110),char(0),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(76),char(111),char(119),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0), +char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(85),char(112),char(112),char(101),char(114),char(76),char(105),char(109),char(105),char(116),char(0),char(109),char(95), +char(106),char(111),char(105),char(110),char(116),char(77),char(97),char(120),char(70),char(111),char(114),char(99),char(101),char(0),char(109),char(95),char(106),char(111),char(105),char(110), +char(116),char(77),char(97),char(120),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(42),char(109),char(95),char(108),char(105),char(110),char(107), +char(78),char(97),char(109),char(101),char(0),char(42),char(109),char(95),char(106),char(111),char(105),char(110),char(116),char(78),char(97),char(109),char(101),char(0),char(42),char(109), +char(95),char(108),char(105),char(110),char(107),char(67),char(111),char(108),char(108),char(105),char(100),char(101),char(114),char(0),char(42),char(109),char(95),char(112),char(97),char(100), +char(100),char(105),char(110),char(103),char(80),char(116),char(114),char(0),char(109),char(95),char(98),char(97),char(115),char(101),char(87),char(111),char(114),char(108),char(100),char(80), +char(111),char(115),char(105),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(98),char(97),char(115),char(101),char(87),char(111),char(114),char(108),char(100),char(79), +char(114),char(105),char(101),char(110),char(116),char(97),char(116),char(105),char(111),char(110),char(0),char(109),char(95),char(98),char(97),char(115),char(101),char(76),char(105),char(110), +char(101),char(97),char(114),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(98),char(97),char(115),char(101),char(65),char(110), +char(103),char(117),char(108),char(97),char(114),char(86),char(101),char(108),char(111),char(99),char(105),char(116),char(121),char(0),char(109),char(95),char(98),char(97),char(115),char(101), +char(73),char(110),char(101),char(114),char(116),char(105),char(97),char(0),char(109),char(95),char(98),char(97),char(115),char(101),char(77),char(97),char(115),char(115),char(0),char(42), +char(109),char(95),char(98),char(97),char(115),char(101),char(78),char(97),char(109),char(101),char(0),char(42),char(109),char(95),char(98),char(97),char(115),char(101),char(67),char(111), +char(108),char(108),char(105),char(100),char(101),char(114),char(0),char(109),char(95),char(99),char(111),char(108),char(79),char(98),char(106),char(68),char(97),char(116),char(97),char(0), +char(42),char(109),char(95),char(109),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(0),char(109),char(95),char(108),char(105),char(110),char(107),char(0), +char(84),char(89),char(80),char(69),char(99),char(0),char(0),char(0),char(99),char(104),char(97),char(114),char(0),char(117),char(99),char(104),char(97),char(114),char(0),char(115), +char(104),char(111),char(114),char(116),char(0),char(117),char(115),char(104),char(111),char(114),char(116),char(0),char(105),char(110),char(116),char(0),char(108),char(111),char(110),char(103), +char(0),char(117),char(108),char(111),char(110),char(103),char(0),char(102),char(108),char(111),char(97),char(116),char(0),char(100),char(111),char(117),char(98),char(108),char(101),char(0), +char(118),char(111),char(105),char(100),char(0),char(80),char(111),char(105),char(110),char(116),char(101),char(114),char(65),char(114),char(114),char(97),char(121),char(0),char(98),char(116), +char(80),char(104),char(121),char(115),char(105),char(99),char(115),char(83),char(121),char(115),char(116),char(101),char(109),char(0),char(76),char(105),char(115),char(116),char(66),char(97), +char(115),char(101),char(0),char(98),char(116),char(86),char(101),char(99),char(116),char(111),char(114),char(51),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116), +char(97),char(0),char(98),char(116),char(86),char(101),char(99),char(116),char(111),char(114),char(51),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116), +char(97),char(0),char(98),char(116),char(81),char(117),char(97),char(116),char(101),char(114),char(110),char(105),char(111),char(110),char(70),char(108),char(111),char(97),char(116),char(68), +char(97),char(116),char(97),char(0),char(98),char(116),char(81),char(117),char(97),char(116),char(101),char(114),char(110),char(105),char(111),char(110),char(68),char(111),char(117),char(98), +char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(97),char(116),char(114),char(105),char(120),char(51),char(120),char(51),char(70),char(108), +char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(97),char(116),char(114),char(105),char(120),char(51),char(120),char(51),char(68), +char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(84),char(114),char(97),char(110),char(115),char(102),char(111),char(114), +char(109),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(84),char(114),char(97),char(110),char(115),char(102),char(111), +char(114),char(109),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(66),char(118),char(104),char(83),char(117), +char(98),char(116),char(114),char(101),char(101),char(73),char(110),char(102),char(111),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(79),char(112),char(116),char(105), +char(109),char(105),char(122),char(101),char(100),char(66),char(118),char(104),char(78),char(111),char(100),char(101),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116), +char(97),char(0),char(98),char(116),char(79),char(112),char(116),char(105),char(109),char(105),char(122),char(101),char(100),char(66),char(118),char(104),char(78),char(111),char(100),char(101), +char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(81),char(117),char(97),char(110),char(116),char(105),char(122), +char(101),char(100),char(66),char(118),char(104),char(78),char(111),char(100),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(81),char(117),char(97),char(110), +char(116),char(105),char(122),char(101),char(100),char(66),char(118),char(104),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116), +char(81),char(117),char(97),char(110),char(116),char(105),char(122),char(101),char(100),char(66),char(118),char(104),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97), +char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(83),char(104),char(97),char(112),char(101),char(68), +char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(116),char(97),char(116),char(105),char(99),char(80),char(108),char(97),char(110),char(101),char(83),char(104),char(97), +char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(110),char(118),char(101),char(120),char(73),char(110),char(116),char(101),char(114), +char(110),char(97),char(108),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(80),char(111),char(115),char(105),char(116), +char(105),char(111),char(110),char(65),char(110),char(100),char(82),char(97),char(100),char(105),char(117),char(115),char(0),char(98),char(116),char(77),char(117),char(108),char(116),char(105), +char(83),char(112),char(104),char(101),char(114),char(101),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(73),char(110), +char(116),char(73),char(110),char(100),char(101),char(120),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(104),char(111),char(114),char(116),char(73),char(110), +char(116),char(73),char(110),char(100),char(101),char(120),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(104),char(111),char(114),char(116),char(73),char(110), +char(116),char(73),char(110),char(100),char(101),char(120),char(84),char(114),char(105),char(112),char(108),char(101),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116), +char(67),char(104),char(97),char(114),char(73),char(110),char(100),char(101),char(120),char(84),char(114),char(105),char(112),char(108),char(101),char(116),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(77),char(101),char(115),char(104),char(80),char(97),char(114),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(116), +char(114),char(105),char(100),char(105),char(110),char(103),char(77),char(101),char(115),char(104),char(73),char(110),char(116),char(101),char(114),char(102),char(97),char(99),char(101),char(68), +char(97),char(116),char(97),char(0),char(98),char(116),char(84),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(77),char(101),char(115),char(104),char(83),char(104), +char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(84),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(73),char(110), +char(102),char(111),char(77),char(97),char(112),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(99),char(97),char(108),char(101),char(100),char(84),char(114), +char(105),char(97),char(110),char(103),char(108),char(101),char(77),char(101),char(115),char(104),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0), +char(98),char(116),char(67),char(111),char(109),char(112),char(111),char(117),char(110),char(100),char(83),char(104),char(97),char(112),char(101),char(67),char(104),char(105),char(108),char(100), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(109),char(112),char(111),char(117),char(110),char(100),char(83),char(104),char(97),char(112),char(101), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(121),char(108),char(105),char(110),char(100),char(101),char(114),char(83),char(104),char(97),char(112),char(101), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(110),char(101),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(67),char(97),char(112),char(115),char(117),char(108),char(101),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0), +char(98),char(116),char(84),char(114),char(105),char(97),char(110),char(103),char(108),char(101),char(73),char(110),char(102),char(111),char(68),char(97),char(116),char(97),char(0),char(98), +char(116),char(80),char(101),char(114),char(115),char(105),char(115),char(116),char(101),char(110),char(116),char(77),char(97),char(110),char(105),char(102),char(111),char(108),char(100),char(68), +char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111), +char(110),char(79),char(98),char(106),char(101),char(99),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116), +char(80),char(101),char(114),char(115),char(105),char(115),char(116),char(101),char(110),char(116),char(77),char(97),char(110),char(105),char(102),char(111),char(108),char(100),char(70),char(108), +char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(108),char(108),char(105),char(115),char(105),char(111),char(110),char(79), +char(98),char(106),char(101),char(99),char(116),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(71),char(73),char(109), +char(112),char(97),char(99),char(116),char(77),char(101),char(115),char(104),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116), +char(67),char(111),char(110),char(118),char(101),char(120),char(72),char(117),char(108),char(108),char(83),char(104),char(97),char(112),char(101),char(68),char(97),char(116),char(97),char(0), +char(98),char(116),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(83),char(111),char(108),char(118),char(101),char(114),char(73),char(110),char(102),char(111),char(68), +char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(110),char(116),char(97),char(99),char(116),char(83), +char(111),char(108),char(118),char(101),char(114),char(73),char(110),char(102),char(111),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98), +char(116),char(68),char(121),char(110),char(97),char(109),char(105),char(99),char(115),char(87),char(111),char(114),char(108),char(100),char(68),char(111),char(117),char(98),char(108),char(101), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(68),char(121),char(110),char(97),char(109),char(105),char(99),char(115),char(87),char(111),char(114),char(108),char(100), +char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(82),char(105),char(103),char(105),char(100),char(66),char(111),char(100), +char(121),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(82),char(105),char(103),char(105),char(100),char(66),char(111), +char(100),char(121),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(67),char(111),char(110),char(115),char(116), +char(114),char(97),char(105),char(110),char(116),char(73),char(110),char(102),char(111),char(49),char(0),char(98),char(116),char(84),char(121),char(112),char(101),char(100),char(67),char(111), +char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116), +char(84),char(121),char(112),char(101),char(100),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(97),char(116),char(97),char(0), +char(98),char(116),char(82),char(105),char(103),char(105),char(100),char(66),char(111),char(100),char(121),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(84),char(121), +char(112),char(101),char(100),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68), +char(97),char(116),char(97),char(0),char(98),char(116),char(80),char(111),char(105),char(110),char(116),char(50),char(80),char(111),char(105),char(110),char(116),char(67),char(111),char(110), +char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(80), +char(111),char(105),char(110),char(116),char(50),char(80),char(111),char(105),char(110),char(116),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116), +char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(50),char(0),char(98),char(116),char(80),char(111),char(105),char(110),char(116),char(50), +char(80),char(111),char(105),char(110),char(116),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108), +char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(72),char(105),char(110),char(103),char(101),char(67),char(111),char(110),char(115),char(116),char(114),char(97), +char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(72),char(105),char(110),char(103), +char(101),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(72),char(105),char(110),char(103),char(101),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111), +char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(50),char(0),char(98),char(116),char(67),char(111),char(110),char(101),char(84),char(119),char(105),char(115), +char(116),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116), +char(97),char(0),char(98),char(116),char(67),char(111),char(110),char(101),char(84),char(119),char(105),char(115),char(116),char(67),char(111),char(110),char(115),char(116),char(114),char(97), +char(105),char(110),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(71),char(101),char(110),char(101),char(114),char(105),char(99),char(54),char(68),char(111), +char(102),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(71),char(101), +char(110),char(101),char(114),char(105),char(99),char(54),char(68),char(111),char(102),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68), +char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(50),char(0),char(98),char(116),char(71),char(101),char(110),char(101),char(114),char(105),char(99), +char(54),char(68),char(111),char(102),char(83),char(112),char(114),char(105),char(110),char(103),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(71),char(101),char(110),char(101),char(114),char(105),char(99),char(54),char(68),char(111),char(102),char(83),char(112), +char(114),char(105),char(110),char(103),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101), +char(68),char(97),char(116),char(97),char(50),char(0),char(98),char(116),char(71),char(101),char(110),char(101),char(114),char(105),char(99),char(54),char(68),char(111),char(102),char(83), +char(112),char(114),char(105),char(110),char(103),char(50),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(71),char(101),char(110),char(101),char(114),char(105),char(99),char(54),char(68),char(111),char(102),char(83),char(112),char(114),char(105),char(110),char(103), +char(50),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116), +char(97),char(50),char(0),char(98),char(116),char(83),char(108),char(105),char(100),char(101),char(114),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110), +char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(108),char(105),char(100),char(101),char(114),char(67),char(111),char(110),char(115),char(116),char(114), +char(97),char(105),char(110),char(116),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(71),char(101),char(97), +char(114),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(71),char(101),char(97),char(114),char(67),char(111),char(110),char(115),char(116),char(114),char(97),char(105),char(110),char(116),char(68),char(111),char(117), +char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(83),char(111),char(102),char(116),char(66),char(111),char(100),char(121),char(77),char(97),char(116),char(101), +char(114),char(105),char(97),char(108),char(68),char(97),char(116),char(97),char(0),char(83),char(111),char(102),char(116),char(66),char(111),char(100),char(121),char(78),char(111),char(100), +char(101),char(68),char(97),char(116),char(97),char(0),char(83),char(111),char(102),char(116),char(66),char(111),char(100),char(121),char(76),char(105),char(110),char(107),char(68),char(97), +char(116),char(97),char(0),char(83),char(111),char(102),char(116),char(66),char(111),char(100),char(121),char(70),char(97),char(99),char(101),char(68),char(97),char(116),char(97),char(0), +char(83),char(111),char(102),char(116),char(66),char(111),char(100),char(121),char(84),char(101),char(116),char(114),char(97),char(68),char(97),char(116),char(97),char(0),char(83),char(111), +char(102),char(116),char(82),char(105),char(103),char(105),char(100),char(65),char(110),char(99),char(104),char(111),char(114),char(68),char(97),char(116),char(97),char(0),char(83),char(111), +char(102),char(116),char(66),char(111),char(100),char(121),char(67),char(111),char(110),char(102),char(105),char(103),char(68),char(97),char(116),char(97),char(0),char(83),char(111),char(102), +char(116),char(66),char(111),char(100),char(121),char(80),char(111),char(115),char(101),char(68),char(97),char(116),char(97),char(0),char(83),char(111),char(102),char(116),char(66),char(111), +char(100),char(121),char(67),char(108),char(117),char(115),char(116),char(101),char(114),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(111),char(102),char(116), +char(66),char(111),char(100),char(121),char(74),char(111),char(105),char(110),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(83),char(111),char(102),char(116), +char(66),char(111),char(100),char(121),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(117),char(108),char(116), +char(105),char(66),char(111),char(100),char(121),char(76),char(105),char(110),char(107),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0), +char(98),char(116),char(77),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(76),char(105),char(110),char(107),char(70),char(108),char(111),char(97),char(116), +char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(68),char(111),char(117),char(98), +char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(70),char(108), +char(111),char(97),char(116),char(68),char(97),char(116),char(97),char(0),char(98),char(116),char(77),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(76), +char(105),char(110),char(107),char(67),char(111),char(108),char(108),char(105),char(100),char(101),char(114),char(70),char(108),char(111),char(97),char(116),char(68),char(97),char(116),char(97), +char(0),char(98),char(116),char(77),char(117),char(108),char(116),char(105),char(66),char(111),char(100),char(121),char(76),char(105),char(110),char(107),char(67),char(111),char(108),char(108), +char(105),char(100),char(101),char(114),char(68),char(111),char(117),char(98),char(108),char(101),char(68),char(97),char(116),char(97),char(0),char(0),char(84),char(76),char(69),char(78), +char(1),char(0),char(1),char(0),char(2),char(0),char(2),char(0),char(4),char(0),char(4),char(0),char(4),char(0),char(4),char(0),char(8),char(0),char(0),char(0), +char(16),char(0),char(48),char(0),char(16),char(0),char(16),char(0),char(32),char(0),char(16),char(0),char(32),char(0),char(48),char(0),char(96),char(0),char(64),char(0), +char(-128),char(0),char(20),char(0),char(48),char(0),char(80),char(0),char(16),char(0),char(96),char(0),char(-112),char(0),char(16),char(0),char(56),char(0),char(56),char(0), +char(20),char(0),char(72),char(0),char(4),char(0),char(4),char(0),char(8),char(0),char(4),char(0),char(56),char(0),char(32),char(0),char(80),char(0),char(72),char(0), +char(96),char(0),char(80),char(0),char(32),char(0),char(64),char(0),char(64),char(0),char(64),char(0),char(16),char(0),char(24),char(6),char(-8),char(1),char(80),char(3), +char(32),char(1),char(72),char(0),char(80),char(0),char(-96),char(0),char(88),char(0),char(-64),char(0),char(104),char(0),char(8),char(2),char(-56),char(3),char(8),char(0), +char(64),char(0),char(64),char(0),char(0),char(0),char(80),char(0),char(96),char(0),char(-112),char(0),char(-128),char(0),char(104),char(1),char(-24),char(0),char(-104),char(1), +char(-120),char(1),char(-32),char(0),char(8),char(1),char(-40),char(1),char(104),char(1),char(-128),char(2),char(-112),char(2),char(-64),char(4),char(-40),char(0),char(120),char(1), +char(104),char(0),char(-104),char(0),char(16),char(0),char(104),char(0),char(24),char(0),char(40),char(0),char(104),char(0),char(96),char(0),char(104),char(0),char(-56),char(0), +char(104),char(1),char(112),char(0),char(-16),char(1),char(-128),char(3),char(-40),char(1),char(-56),char(0),char(112),char(0),char(48),char(1),char(8),char(2),char(0),char(0), +char(83),char(84),char(82),char(67),char(88),char(0),char(0),char(0),char(10),char(0),char(3),char(0),char(4),char(0),char(0),char(0),char(4),char(0),char(1),char(0), +char(9),char(0),char(2),char(0),char(11),char(0),char(3),char(0),char(10),char(0),char(3),char(0),char(10),char(0),char(4),char(0),char(10),char(0),char(5),char(0), +char(12),char(0),char(2),char(0),char(9),char(0),char(6),char(0),char(9),char(0),char(7),char(0),char(13),char(0),char(1),char(0),char(7),char(0),char(8),char(0), +char(14),char(0),char(1),char(0),char(8),char(0),char(8),char(0),char(15),char(0),char(1),char(0),char(7),char(0),char(8),char(0),char(16),char(0),char(1),char(0), +char(8),char(0),char(8),char(0),char(17),char(0),char(1),char(0),char(13),char(0),char(9),char(0),char(18),char(0),char(1),char(0),char(14),char(0),char(9),char(0), +char(19),char(0),char(2),char(0),char(17),char(0),char(10),char(0),char(13),char(0),char(11),char(0),char(20),char(0),char(2),char(0),char(18),char(0),char(10),char(0), +char(14),char(0),char(11),char(0),char(21),char(0),char(4),char(0),char(4),char(0),char(12),char(0),char(4),char(0),char(13),char(0),char(2),char(0),char(14),char(0), +char(2),char(0),char(15),char(0),char(22),char(0),char(6),char(0),char(13),char(0),char(16),char(0),char(13),char(0),char(17),char(0),char(4),char(0),char(18),char(0), +char(4),char(0),char(19),char(0),char(4),char(0),char(20),char(0),char(0),char(0),char(21),char(0),char(23),char(0),char(6),char(0),char(14),char(0),char(16),char(0), +char(14),char(0),char(17),char(0),char(4),char(0),char(18),char(0),char(4),char(0),char(19),char(0),char(4),char(0),char(20),char(0),char(0),char(0),char(21),char(0), +char(24),char(0),char(3),char(0),char(2),char(0),char(14),char(0),char(2),char(0),char(15),char(0),char(4),char(0),char(22),char(0),char(25),char(0),char(12),char(0), +char(13),char(0),char(23),char(0),char(13),char(0),char(24),char(0),char(13),char(0),char(25),char(0),char(4),char(0),char(26),char(0),char(4),char(0),char(27),char(0), +char(4),char(0),char(28),char(0),char(4),char(0),char(29),char(0),char(22),char(0),char(30),char(0),char(24),char(0),char(31),char(0),char(21),char(0),char(32),char(0), +char(4),char(0),char(33),char(0),char(4),char(0),char(34),char(0),char(26),char(0),char(12),char(0),char(14),char(0),char(23),char(0),char(14),char(0),char(24),char(0), +char(14),char(0),char(25),char(0),char(4),char(0),char(26),char(0),char(4),char(0),char(27),char(0),char(4),char(0),char(28),char(0),char(4),char(0),char(29),char(0), +char(23),char(0),char(30),char(0),char(24),char(0),char(31),char(0),char(4),char(0),char(33),char(0),char(4),char(0),char(34),char(0),char(21),char(0),char(32),char(0), +char(27),char(0),char(3),char(0),char(0),char(0),char(35),char(0),char(4),char(0),char(36),char(0),char(0),char(0),char(37),char(0),char(28),char(0),char(5),char(0), +char(27),char(0),char(38),char(0),char(13),char(0),char(39),char(0),char(13),char(0),char(40),char(0),char(7),char(0),char(41),char(0),char(0),char(0),char(21),char(0), +char(29),char(0),char(5),char(0),char(27),char(0),char(38),char(0),char(13),char(0),char(39),char(0),char(13),char(0),char(42),char(0),char(7),char(0),char(43),char(0), +char(4),char(0),char(44),char(0),char(30),char(0),char(2),char(0),char(13),char(0),char(45),char(0),char(7),char(0),char(46),char(0),char(31),char(0),char(4),char(0), +char(29),char(0),char(47),char(0),char(30),char(0),char(48),char(0),char(4),char(0),char(49),char(0),char(0),char(0),char(37),char(0),char(32),char(0),char(1),char(0), +char(4),char(0),char(50),char(0),char(33),char(0),char(2),char(0),char(2),char(0),char(50),char(0),char(0),char(0),char(51),char(0),char(34),char(0),char(2),char(0), +char(2),char(0),char(52),char(0),char(0),char(0),char(51),char(0),char(35),char(0),char(2),char(0),char(0),char(0),char(52),char(0),char(0),char(0),char(53),char(0), +char(36),char(0),char(8),char(0),char(13),char(0),char(54),char(0),char(14),char(0),char(55),char(0),char(32),char(0),char(56),char(0),char(34),char(0),char(57),char(0), +char(35),char(0),char(58),char(0),char(33),char(0),char(59),char(0),char(4),char(0),char(60),char(0),char(4),char(0),char(61),char(0),char(37),char(0),char(4),char(0), +char(36),char(0),char(62),char(0),char(13),char(0),char(63),char(0),char(4),char(0),char(64),char(0),char(0),char(0),char(37),char(0),char(38),char(0),char(7),char(0), +char(27),char(0),char(38),char(0),char(37),char(0),char(65),char(0),char(25),char(0),char(66),char(0),char(26),char(0),char(67),char(0),char(39),char(0),char(68),char(0), +char(7),char(0),char(43),char(0),char(0),char(0),char(69),char(0),char(40),char(0),char(2),char(0),char(38),char(0),char(70),char(0),char(13),char(0),char(39),char(0), +char(41),char(0),char(4),char(0),char(19),char(0),char(71),char(0),char(27),char(0),char(72),char(0),char(4),char(0),char(73),char(0),char(7),char(0),char(74),char(0), +char(42),char(0),char(4),char(0),char(27),char(0),char(38),char(0),char(41),char(0),char(75),char(0),char(4),char(0),char(76),char(0),char(7),char(0),char(43),char(0), +char(43),char(0),char(3),char(0),char(29),char(0),char(47),char(0),char(4),char(0),char(77),char(0),char(0),char(0),char(37),char(0),char(44),char(0),char(3),char(0), +char(29),char(0),char(47),char(0),char(4),char(0),char(78),char(0),char(0),char(0),char(37),char(0),char(45),char(0),char(3),char(0),char(29),char(0),char(47),char(0), +char(4),char(0),char(77),char(0),char(0),char(0),char(37),char(0),char(46),char(0),char(4),char(0),char(4),char(0),char(79),char(0),char(7),char(0),char(80),char(0), +char(7),char(0),char(81),char(0),char(7),char(0),char(82),char(0),char(39),char(0),char(14),char(0),char(4),char(0),char(83),char(0),char(4),char(0),char(84),char(0), +char(46),char(0),char(85),char(0),char(4),char(0),char(86),char(0),char(7),char(0),char(87),char(0),char(7),char(0),char(88),char(0),char(7),char(0),char(89),char(0), +char(7),char(0),char(90),char(0),char(7),char(0),char(91),char(0),char(4),char(0),char(92),char(0),char(4),char(0),char(93),char(0),char(4),char(0),char(94),char(0), +char(4),char(0),char(95),char(0),char(0),char(0),char(37),char(0),char(47),char(0),char(39),char(0),char(14),char(0),char(96),char(0),char(14),char(0),char(97),char(0), +char(14),char(0),char(98),char(0),char(14),char(0),char(99),char(0),char(14),char(0),char(100),char(0),char(14),char(0),char(101),char(0),char(14),char(0),char(102),char(0), +char(8),char(0),char(103),char(0),char(8),char(0),char(104),char(0),char(8),char(0),char(105),char(0),char(8),char(0),char(106),char(0),char(8),char(0),char(107),char(0), +char(8),char(0),char(108),char(0),char(8),char(0),char(109),char(0),char(4),char(0),char(110),char(0),char(4),char(0),char(111),char(0),char(4),char(0),char(112),char(0), +char(4),char(0),char(113),char(0),char(4),char(0),char(114),char(0),char(8),char(0),char(115),char(0),char(8),char(0),char(116),char(0),char(8),char(0),char(117),char(0), +char(8),char(0),char(118),char(0),char(8),char(0),char(119),char(0),char(8),char(0),char(120),char(0),char(8),char(0),char(121),char(0),char(8),char(0),char(122),char(0), +char(8),char(0),char(123),char(0),char(4),char(0),char(124),char(0),char(4),char(0),char(125),char(0),char(4),char(0),char(126),char(0),char(4),char(0),char(127),char(0), +char(4),char(0),char(-128),char(0),char(4),char(0),char(-127),char(0),char(8),char(0),char(-126),char(0),char(8),char(0),char(-125),char(0),char(4),char(0),char(44),char(0), +char(48),char(0),char(-124),char(0),char(48),char(0),char(-123),char(0),char(49),char(0),char(39),char(0),char(13),char(0),char(96),char(0),char(13),char(0),char(97),char(0), +char(13),char(0),char(98),char(0),char(13),char(0),char(99),char(0),char(13),char(0),char(100),char(0),char(13),char(0),char(101),char(0),char(13),char(0),char(102),char(0), +char(7),char(0),char(103),char(0),char(7),char(0),char(104),char(0),char(7),char(0),char(105),char(0),char(7),char(0),char(106),char(0),char(7),char(0),char(107),char(0), +char(7),char(0),char(108),char(0),char(7),char(0),char(109),char(0),char(4),char(0),char(110),char(0),char(4),char(0),char(111),char(0),char(4),char(0),char(112),char(0), +char(4),char(0),char(113),char(0),char(4),char(0),char(114),char(0),char(7),char(0),char(115),char(0),char(7),char(0),char(116),char(0),char(7),char(0),char(117),char(0), +char(7),char(0),char(118),char(0),char(7),char(0),char(119),char(0),char(7),char(0),char(120),char(0),char(7),char(0),char(121),char(0),char(7),char(0),char(122),char(0), +char(7),char(0),char(123),char(0),char(4),char(0),char(124),char(0),char(4),char(0),char(125),char(0),char(4),char(0),char(126),char(0),char(4),char(0),char(127),char(0), +char(4),char(0),char(-128),char(0),char(4),char(0),char(-127),char(0),char(7),char(0),char(-126),char(0),char(7),char(0),char(-125),char(0),char(4),char(0),char(44),char(0), +char(50),char(0),char(-124),char(0),char(50),char(0),char(-123),char(0),char(51),char(0),char(5),char(0),char(27),char(0),char(38),char(0),char(37),char(0),char(65),char(0), +char(13),char(0),char(39),char(0),char(7),char(0),char(43),char(0),char(4),char(0),char(-122),char(0),char(52),char(0),char(5),char(0),char(29),char(0),char(47),char(0), +char(13),char(0),char(-121),char(0),char(14),char(0),char(-120),char(0),char(4),char(0),char(-119),char(0),char(0),char(0),char(-118),char(0),char(48),char(0),char(29),char(0), +char(9),char(0),char(-117),char(0),char(9),char(0),char(-116),char(0),char(27),char(0),char(-115),char(0),char(0),char(0),char(35),char(0),char(20),char(0),char(-114),char(0), +char(20),char(0),char(-113),char(0),char(14),char(0),char(-112),char(0),char(14),char(0),char(-111),char(0),char(14),char(0),char(-110),char(0),char(8),char(0),char(-125),char(0), +char(8),char(0),char(-109),char(0),char(8),char(0),char(-108),char(0),char(8),char(0),char(-107),char(0),char(8),char(0),char(-106),char(0),char(8),char(0),char(-105),char(0), +char(8),char(0),char(-104),char(0),char(8),char(0),char(-103),char(0),char(8),char(0),char(-102),char(0),char(8),char(0),char(-101),char(0),char(4),char(0),char(-100),char(0), +char(4),char(0),char(-99),char(0),char(4),char(0),char(-98),char(0),char(4),char(0),char(-97),char(0),char(4),char(0),char(-96),char(0),char(4),char(0),char(-95),char(0), +char(4),char(0),char(-94),char(0),char(4),char(0),char(-93),char(0),char(4),char(0),char(-92),char(0),char(4),char(0),char(-91),char(0),char(50),char(0),char(29),char(0), +char(9),char(0),char(-117),char(0),char(9),char(0),char(-116),char(0),char(27),char(0),char(-115),char(0),char(0),char(0),char(35),char(0),char(19),char(0),char(-114),char(0), +char(19),char(0),char(-113),char(0),char(13),char(0),char(-112),char(0),char(13),char(0),char(-111),char(0),char(13),char(0),char(-110),char(0),char(7),char(0),char(-125),char(0), +char(7),char(0),char(-109),char(0),char(7),char(0),char(-108),char(0),char(7),char(0),char(-107),char(0),char(7),char(0),char(-106),char(0),char(7),char(0),char(-105),char(0), +char(7),char(0),char(-104),char(0),char(7),char(0),char(-103),char(0),char(7),char(0),char(-102),char(0),char(7),char(0),char(-101),char(0),char(4),char(0),char(-100),char(0), +char(4),char(0),char(-99),char(0),char(4),char(0),char(-98),char(0),char(4),char(0),char(-97),char(0),char(4),char(0),char(-96),char(0),char(4),char(0),char(-95),char(0), +char(4),char(0),char(-94),char(0),char(4),char(0),char(-93),char(0),char(4),char(0),char(-92),char(0),char(4),char(0),char(-91),char(0),char(53),char(0),char(23),char(0), +char(8),char(0),char(-90),char(0),char(8),char(0),char(-89),char(0),char(8),char(0),char(-108),char(0),char(8),char(0),char(-88),char(0),char(8),char(0),char(-104),char(0), +char(8),char(0),char(-87),char(0),char(8),char(0),char(-86),char(0),char(8),char(0),char(-85),char(0),char(8),char(0),char(-84),char(0),char(8),char(0),char(-83),char(0), +char(8),char(0),char(-82),char(0),char(8),char(0),char(-81),char(0),char(8),char(0),char(-80),char(0),char(8),char(0),char(-79),char(0),char(8),char(0),char(-78),char(0), +char(8),char(0),char(-77),char(0),char(8),char(0),char(-76),char(0),char(4),char(0),char(-75),char(0),char(4),char(0),char(-74),char(0),char(4),char(0),char(-73),char(0), +char(4),char(0),char(-72),char(0),char(4),char(0),char(-71),char(0),char(0),char(0),char(37),char(0),char(54),char(0),char(22),char(0),char(7),char(0),char(-90),char(0), +char(7),char(0),char(-89),char(0),char(7),char(0),char(-108),char(0),char(7),char(0),char(-88),char(0),char(7),char(0),char(-104),char(0),char(7),char(0),char(-87),char(0), +char(7),char(0),char(-86),char(0),char(7),char(0),char(-85),char(0),char(7),char(0),char(-84),char(0),char(7),char(0),char(-83),char(0),char(7),char(0),char(-82),char(0), +char(7),char(0),char(-81),char(0),char(7),char(0),char(-80),char(0),char(7),char(0),char(-79),char(0),char(7),char(0),char(-78),char(0),char(7),char(0),char(-77),char(0), +char(7),char(0),char(-76),char(0),char(4),char(0),char(-75),char(0),char(4),char(0),char(-74),char(0),char(4),char(0),char(-73),char(0),char(4),char(0),char(-72),char(0), +char(4),char(0),char(-71),char(0),char(55),char(0),char(2),char(0),char(53),char(0),char(-70),char(0),char(14),char(0),char(-69),char(0),char(56),char(0),char(2),char(0), +char(54),char(0),char(-70),char(0),char(13),char(0),char(-69),char(0),char(57),char(0),char(21),char(0),char(50),char(0),char(-68),char(0),char(17),char(0),char(-67),char(0), +char(13),char(0),char(-66),char(0),char(13),char(0),char(-65),char(0),char(13),char(0),char(-64),char(0),char(13),char(0),char(-63),char(0),char(13),char(0),char(-69),char(0), +char(13),char(0),char(-62),char(0),char(13),char(0),char(-61),char(0),char(13),char(0),char(-60),char(0),char(13),char(0),char(-59),char(0),char(7),char(0),char(-58),char(0), +char(7),char(0),char(-57),char(0),char(7),char(0),char(-56),char(0),char(7),char(0),char(-55),char(0),char(7),char(0),char(-54),char(0),char(7),char(0),char(-53),char(0), +char(7),char(0),char(-52),char(0),char(7),char(0),char(-51),char(0),char(7),char(0),char(-50),char(0),char(4),char(0),char(-49),char(0),char(58),char(0),char(22),char(0), +char(48),char(0),char(-68),char(0),char(18),char(0),char(-67),char(0),char(14),char(0),char(-66),char(0),char(14),char(0),char(-65),char(0),char(14),char(0),char(-64),char(0), +char(14),char(0),char(-63),char(0),char(14),char(0),char(-69),char(0),char(14),char(0),char(-62),char(0),char(14),char(0),char(-61),char(0),char(14),char(0),char(-60),char(0), +char(14),char(0),char(-59),char(0),char(8),char(0),char(-58),char(0),char(8),char(0),char(-57),char(0),char(8),char(0),char(-56),char(0),char(8),char(0),char(-55),char(0), +char(8),char(0),char(-54),char(0),char(8),char(0),char(-53),char(0),char(8),char(0),char(-52),char(0),char(8),char(0),char(-51),char(0),char(8),char(0),char(-50),char(0), +char(4),char(0),char(-49),char(0),char(0),char(0),char(37),char(0),char(59),char(0),char(2),char(0),char(4),char(0),char(-48),char(0),char(4),char(0),char(-47),char(0), +char(60),char(0),char(13),char(0),char(57),char(0),char(-46),char(0),char(57),char(0),char(-45),char(0),char(0),char(0),char(35),char(0),char(4),char(0),char(-127),char(0), +char(4),char(0),char(-44),char(0),char(4),char(0),char(-43),char(0),char(4),char(0),char(-42),char(0),char(7),char(0),char(-41),char(0),char(7),char(0),char(-40),char(0), +char(4),char(0),char(-39),char(0),char(4),char(0),char(-38),char(0),char(7),char(0),char(-37),char(0),char(4),char(0),char(-36),char(0),char(61),char(0),char(13),char(0), +char(62),char(0),char(-46),char(0),char(62),char(0),char(-45),char(0),char(0),char(0),char(35),char(0),char(4),char(0),char(-127),char(0),char(4),char(0),char(-44),char(0), +char(4),char(0),char(-43),char(0),char(4),char(0),char(-42),char(0),char(7),char(0),char(-41),char(0),char(7),char(0),char(-40),char(0),char(4),char(0),char(-39),char(0), +char(4),char(0),char(-38),char(0),char(7),char(0),char(-37),char(0),char(4),char(0),char(-36),char(0),char(63),char(0),char(14),char(0),char(58),char(0),char(-46),char(0), +char(58),char(0),char(-45),char(0),char(0),char(0),char(35),char(0),char(4),char(0),char(-127),char(0),char(4),char(0),char(-44),char(0),char(4),char(0),char(-43),char(0), +char(4),char(0),char(-42),char(0),char(8),char(0),char(-41),char(0),char(8),char(0),char(-40),char(0),char(4),char(0),char(-39),char(0),char(4),char(0),char(-38),char(0), +char(8),char(0),char(-37),char(0),char(4),char(0),char(-36),char(0),char(0),char(0),char(-35),char(0),char(64),char(0),char(3),char(0),char(61),char(0),char(-34),char(0), +char(13),char(0),char(-33),char(0),char(13),char(0),char(-32),char(0),char(65),char(0),char(3),char(0),char(63),char(0),char(-34),char(0),char(14),char(0),char(-33),char(0), +char(14),char(0),char(-32),char(0),char(66),char(0),char(3),char(0),char(61),char(0),char(-34),char(0),char(14),char(0),char(-33),char(0),char(14),char(0),char(-32),char(0), +char(67),char(0),char(13),char(0),char(61),char(0),char(-34),char(0),char(20),char(0),char(-31),char(0),char(20),char(0),char(-30),char(0),char(4),char(0),char(-29),char(0), +char(4),char(0),char(-28),char(0),char(4),char(0),char(-27),char(0),char(7),char(0),char(-26),char(0),char(7),char(0),char(-25),char(0),char(7),char(0),char(-24),char(0), +char(7),char(0),char(-23),char(0),char(7),char(0),char(-22),char(0),char(7),char(0),char(-21),char(0),char(7),char(0),char(-20),char(0),char(68),char(0),char(13),char(0), +char(61),char(0),char(-34),char(0),char(19),char(0),char(-31),char(0),char(19),char(0),char(-30),char(0),char(4),char(0),char(-29),char(0),char(4),char(0),char(-28),char(0), +char(4),char(0),char(-27),char(0),char(7),char(0),char(-26),char(0),char(7),char(0),char(-25),char(0),char(7),char(0),char(-24),char(0),char(7),char(0),char(-23),char(0), +char(7),char(0),char(-22),char(0),char(7),char(0),char(-21),char(0),char(7),char(0),char(-20),char(0),char(69),char(0),char(14),char(0),char(63),char(0),char(-34),char(0), +char(20),char(0),char(-31),char(0),char(20),char(0),char(-30),char(0),char(4),char(0),char(-29),char(0),char(4),char(0),char(-28),char(0),char(4),char(0),char(-27),char(0), +char(8),char(0),char(-26),char(0),char(8),char(0),char(-25),char(0),char(8),char(0),char(-24),char(0),char(8),char(0),char(-23),char(0),char(8),char(0),char(-22),char(0), +char(8),char(0),char(-21),char(0),char(8),char(0),char(-20),char(0),char(0),char(0),char(-19),char(0),char(70),char(0),char(10),char(0),char(63),char(0),char(-34),char(0), +char(20),char(0),char(-31),char(0),char(20),char(0),char(-30),char(0),char(8),char(0),char(-18),char(0),char(8),char(0),char(-17),char(0),char(8),char(0),char(-16),char(0), +char(8),char(0),char(-22),char(0),char(8),char(0),char(-21),char(0),char(8),char(0),char(-20),char(0),char(8),char(0),char(-89),char(0),char(71),char(0),char(11),char(0), +char(61),char(0),char(-34),char(0),char(19),char(0),char(-31),char(0),char(19),char(0),char(-30),char(0),char(7),char(0),char(-18),char(0),char(7),char(0),char(-17),char(0), +char(7),char(0),char(-16),char(0),char(7),char(0),char(-22),char(0),char(7),char(0),char(-21),char(0),char(7),char(0),char(-20),char(0),char(7),char(0),char(-89),char(0), +char(0),char(0),char(21),char(0),char(72),char(0),char(9),char(0),char(61),char(0),char(-34),char(0),char(19),char(0),char(-31),char(0),char(19),char(0),char(-30),char(0), +char(13),char(0),char(-15),char(0),char(13),char(0),char(-14),char(0),char(13),char(0),char(-13),char(0),char(13),char(0),char(-12),char(0),char(4),char(0),char(-11),char(0), +char(4),char(0),char(-10),char(0),char(73),char(0),char(9),char(0),char(63),char(0),char(-34),char(0),char(20),char(0),char(-31),char(0),char(20),char(0),char(-30),char(0), +char(14),char(0),char(-15),char(0),char(14),char(0),char(-14),char(0),char(14),char(0),char(-13),char(0),char(14),char(0),char(-12),char(0),char(4),char(0),char(-11),char(0), +char(4),char(0),char(-10),char(0),char(74),char(0),char(5),char(0),char(72),char(0),char(-9),char(0),char(4),char(0),char(-8),char(0),char(7),char(0),char(-7),char(0), +char(7),char(0),char(-6),char(0),char(7),char(0),char(-5),char(0),char(75),char(0),char(5),char(0),char(73),char(0),char(-9),char(0),char(4),char(0),char(-8),char(0), +char(8),char(0),char(-7),char(0),char(8),char(0),char(-6),char(0),char(8),char(0),char(-5),char(0),char(76),char(0),char(41),char(0),char(61),char(0),char(-34),char(0), +char(19),char(0),char(-31),char(0),char(19),char(0),char(-30),char(0),char(13),char(0),char(-15),char(0),char(13),char(0),char(-14),char(0),char(13),char(0),char(-4),char(0), +char(13),char(0),char(-3),char(0),char(13),char(0),char(-2),char(0),char(13),char(0),char(-1),char(0),char(13),char(0),char(0),char(1),char(13),char(0),char(1),char(1), +char(13),char(0),char(2),char(1),char(13),char(0),char(3),char(1),char(13),char(0),char(4),char(1),char(13),char(0),char(5),char(1),char(13),char(0),char(6),char(1), +char(0),char(0),char(7),char(1),char(0),char(0),char(8),char(1),char(0),char(0),char(9),char(1),char(0),char(0),char(10),char(1),char(0),char(0),char(11),char(1), +char(0),char(0),char(-19),char(0),char(13),char(0),char(-13),char(0),char(13),char(0),char(-12),char(0),char(13),char(0),char(12),char(1),char(13),char(0),char(13),char(1), +char(13),char(0),char(14),char(1),char(13),char(0),char(15),char(1),char(13),char(0),char(16),char(1),char(13),char(0),char(17),char(1),char(13),char(0),char(18),char(1), +char(13),char(0),char(19),char(1),char(13),char(0),char(20),char(1),char(13),char(0),char(21),char(1),char(13),char(0),char(22),char(1),char(0),char(0),char(23),char(1), +char(0),char(0),char(24),char(1),char(0),char(0),char(25),char(1),char(0),char(0),char(26),char(1),char(0),char(0),char(27),char(1),char(4),char(0),char(28),char(1), +char(77),char(0),char(41),char(0),char(63),char(0),char(-34),char(0),char(20),char(0),char(-31),char(0),char(20),char(0),char(-30),char(0),char(14),char(0),char(-15),char(0), +char(14),char(0),char(-14),char(0),char(14),char(0),char(-4),char(0),char(14),char(0),char(-3),char(0),char(14),char(0),char(-2),char(0),char(14),char(0),char(-1),char(0), +char(14),char(0),char(0),char(1),char(14),char(0),char(1),char(1),char(14),char(0),char(2),char(1),char(14),char(0),char(3),char(1),char(14),char(0),char(4),char(1), +char(14),char(0),char(5),char(1),char(14),char(0),char(6),char(1),char(0),char(0),char(7),char(1),char(0),char(0),char(8),char(1),char(0),char(0),char(9),char(1), +char(0),char(0),char(10),char(1),char(0),char(0),char(11),char(1),char(0),char(0),char(-19),char(0),char(14),char(0),char(-13),char(0),char(14),char(0),char(-12),char(0), +char(14),char(0),char(12),char(1),char(14),char(0),char(13),char(1),char(14),char(0),char(14),char(1),char(14),char(0),char(15),char(1),char(14),char(0),char(16),char(1), +char(14),char(0),char(17),char(1),char(14),char(0),char(18),char(1),char(14),char(0),char(19),char(1),char(14),char(0),char(20),char(1),char(14),char(0),char(21),char(1), +char(14),char(0),char(22),char(1),char(0),char(0),char(23),char(1),char(0),char(0),char(24),char(1),char(0),char(0),char(25),char(1),char(0),char(0),char(26),char(1), +char(0),char(0),char(27),char(1),char(4),char(0),char(28),char(1),char(78),char(0),char(9),char(0),char(61),char(0),char(-34),char(0),char(19),char(0),char(-31),char(0), +char(19),char(0),char(-30),char(0),char(7),char(0),char(-15),char(0),char(7),char(0),char(-14),char(0),char(7),char(0),char(-13),char(0),char(7),char(0),char(-12),char(0), +char(4),char(0),char(-11),char(0),char(4),char(0),char(-10),char(0),char(79),char(0),char(9),char(0),char(63),char(0),char(-34),char(0),char(20),char(0),char(-31),char(0), +char(20),char(0),char(-30),char(0),char(8),char(0),char(-15),char(0),char(8),char(0),char(-14),char(0),char(8),char(0),char(-13),char(0),char(8),char(0),char(-12),char(0), +char(4),char(0),char(-11),char(0),char(4),char(0),char(-10),char(0),char(80),char(0),char(5),char(0),char(60),char(0),char(-34),char(0),char(13),char(0),char(29),char(1), +char(13),char(0),char(30),char(1),char(7),char(0),char(31),char(1),char(0),char(0),char(37),char(0),char(81),char(0),char(4),char(0),char(63),char(0),char(-34),char(0), +char(14),char(0),char(29),char(1),char(14),char(0),char(30),char(1),char(8),char(0),char(31),char(1),char(82),char(0),char(4),char(0),char(7),char(0),char(32),char(1), +char(7),char(0),char(33),char(1),char(7),char(0),char(34),char(1),char(4),char(0),char(79),char(0),char(83),char(0),char(10),char(0),char(82),char(0),char(35),char(1), +char(13),char(0),char(36),char(1),char(13),char(0),char(37),char(1),char(13),char(0),char(38),char(1),char(13),char(0),char(39),char(1),char(13),char(0),char(40),char(1), +char(7),char(0),char(-58),char(0),char(7),char(0),char(41),char(1),char(4),char(0),char(42),char(1),char(4),char(0),char(53),char(0),char(84),char(0),char(4),char(0), +char(82),char(0),char(35),char(1),char(4),char(0),char(43),char(1),char(7),char(0),char(44),char(1),char(4),char(0),char(45),char(1),char(85),char(0),char(4),char(0), +char(13),char(0),char(40),char(1),char(82),char(0),char(35),char(1),char(4),char(0),char(46),char(1),char(7),char(0),char(47),char(1),char(86),char(0),char(7),char(0), +char(13),char(0),char(48),char(1),char(82),char(0),char(35),char(1),char(4),char(0),char(49),char(1),char(7),char(0),char(50),char(1),char(7),char(0),char(51),char(1), +char(7),char(0),char(52),char(1),char(4),char(0),char(53),char(0),char(87),char(0),char(6),char(0),char(17),char(0),char(53),char(1),char(13),char(0),char(51),char(1), +char(13),char(0),char(54),char(1),char(62),char(0),char(55),char(1),char(4),char(0),char(56),char(1),char(7),char(0),char(52),char(1),char(88),char(0),char(26),char(0), +char(4),char(0),char(57),char(1),char(7),char(0),char(58),char(1),char(7),char(0),char(-89),char(0),char(7),char(0),char(59),char(1),char(7),char(0),char(60),char(1), +char(7),char(0),char(61),char(1),char(7),char(0),char(62),char(1),char(7),char(0),char(63),char(1),char(7),char(0),char(64),char(1),char(7),char(0),char(65),char(1), +char(7),char(0),char(66),char(1),char(7),char(0),char(67),char(1),char(7),char(0),char(68),char(1),char(7),char(0),char(69),char(1),char(7),char(0),char(70),char(1), +char(7),char(0),char(71),char(1),char(7),char(0),char(72),char(1),char(7),char(0),char(73),char(1),char(7),char(0),char(74),char(1),char(7),char(0),char(75),char(1), +char(7),char(0),char(76),char(1),char(4),char(0),char(77),char(1),char(4),char(0),char(78),char(1),char(4),char(0),char(79),char(1),char(4),char(0),char(80),char(1), +char(4),char(0),char(-99),char(0),char(89),char(0),char(12),char(0),char(17),char(0),char(81),char(1),char(17),char(0),char(82),char(1),char(17),char(0),char(83),char(1), +char(13),char(0),char(84),char(1),char(13),char(0),char(85),char(1),char(7),char(0),char(86),char(1),char(4),char(0),char(87),char(1),char(4),char(0),char(88),char(1), +char(4),char(0),char(89),char(1),char(4),char(0),char(90),char(1),char(7),char(0),char(50),char(1),char(4),char(0),char(53),char(0),char(90),char(0),char(27),char(0), +char(19),char(0),char(91),char(1),char(17),char(0),char(92),char(1),char(17),char(0),char(93),char(1),char(13),char(0),char(84),char(1),char(13),char(0),char(94),char(1), +char(13),char(0),char(95),char(1),char(13),char(0),char(96),char(1),char(13),char(0),char(97),char(1),char(13),char(0),char(98),char(1),char(4),char(0),char(99),char(1), +char(7),char(0),char(100),char(1),char(4),char(0),char(101),char(1),char(4),char(0),char(102),char(1),char(4),char(0),char(103),char(1),char(7),char(0),char(104),char(1), +char(7),char(0),char(105),char(1),char(4),char(0),char(106),char(1),char(4),char(0),char(107),char(1),char(7),char(0),char(108),char(1),char(7),char(0),char(109),char(1), +char(7),char(0),char(110),char(1),char(7),char(0),char(111),char(1),char(7),char(0),char(112),char(1),char(7),char(0),char(113),char(1),char(4),char(0),char(114),char(1), +char(4),char(0),char(115),char(1),char(4),char(0),char(116),char(1),char(91),char(0),char(12),char(0),char(9),char(0),char(117),char(1),char(9),char(0),char(118),char(1), +char(13),char(0),char(119),char(1),char(7),char(0),char(120),char(1),char(7),char(0),char(-85),char(0),char(7),char(0),char(121),char(1),char(4),char(0),char(122),char(1), +char(13),char(0),char(123),char(1),char(4),char(0),char(124),char(1),char(4),char(0),char(125),char(1),char(4),char(0),char(126),char(1),char(4),char(0),char(53),char(0), +char(92),char(0),char(19),char(0),char(50),char(0),char(-68),char(0),char(89),char(0),char(127),char(1),char(82),char(0),char(-128),char(1),char(83),char(0),char(-127),char(1), +char(84),char(0),char(-126),char(1),char(85),char(0),char(-125),char(1),char(86),char(0),char(-124),char(1),char(87),char(0),char(-123),char(1),char(90),char(0),char(-122),char(1), +char(91),char(0),char(-121),char(1),char(4),char(0),char(-120),char(1),char(4),char(0),char(102),char(1),char(4),char(0),char(-119),char(1),char(4),char(0),char(-118),char(1), +char(4),char(0),char(-117),char(1),char(4),char(0),char(-116),char(1),char(4),char(0),char(-115),char(1),char(4),char(0),char(-114),char(1),char(88),char(0),char(-113),char(1), +char(93),char(0),char(28),char(0),char(16),char(0),char(-112),char(1),char(14),char(0),char(-111),char(1),char(14),char(0),char(-110),char(1),char(14),char(0),char(-109),char(1), +char(14),char(0),char(-108),char(1),char(14),char(0),char(-107),char(1),char(14),char(0),char(-106),char(1),char(14),char(0),char(-105),char(1),char(14),char(0),char(-104),char(1), +char(14),char(0),char(-103),char(1),char(8),char(0),char(-102),char(1),char(4),char(0),char(-101),char(1),char(4),char(0),char(126),char(1),char(4),char(0),char(-100),char(1), +char(4),char(0),char(-99),char(1),char(8),char(0),char(-98),char(1),char(8),char(0),char(-97),char(1),char(8),char(0),char(-96),char(1),char(8),char(0),char(-95),char(1), +char(8),char(0),char(-94),char(1),char(8),char(0),char(-93),char(1),char(8),char(0),char(-92),char(1),char(8),char(0),char(-91),char(1),char(8),char(0),char(-90),char(1), +char(0),char(0),char(-89),char(1),char(0),char(0),char(-88),char(1),char(48),char(0),char(-87),char(1),char(0),char(0),char(-86),char(1),char(94),char(0),char(28),char(0), +char(15),char(0),char(-112),char(1),char(13),char(0),char(-111),char(1),char(13),char(0),char(-110),char(1),char(13),char(0),char(-109),char(1),char(13),char(0),char(-108),char(1), +char(13),char(0),char(-107),char(1),char(13),char(0),char(-106),char(1),char(13),char(0),char(-105),char(1),char(13),char(0),char(-104),char(1),char(13),char(0),char(-103),char(1), +char(4),char(0),char(-100),char(1),char(7),char(0),char(-102),char(1),char(4),char(0),char(-101),char(1),char(4),char(0),char(126),char(1),char(7),char(0),char(-98),char(1), +char(7),char(0),char(-97),char(1),char(7),char(0),char(-96),char(1),char(4),char(0),char(-99),char(1),char(7),char(0),char(-95),char(1),char(7),char(0),char(-94),char(1), +char(7),char(0),char(-93),char(1),char(7),char(0),char(-92),char(1),char(7),char(0),char(-91),char(1),char(7),char(0),char(-90),char(1),char(0),char(0),char(-89),char(1), +char(0),char(0),char(-88),char(1),char(50),char(0),char(-87),char(1),char(0),char(0),char(-86),char(1),char(95),char(0),char(11),char(0),char(14),char(0),char(-85),char(1), +char(16),char(0),char(-84),char(1),char(14),char(0),char(-83),char(1),char(14),char(0),char(-82),char(1),char(14),char(0),char(-81),char(1),char(8),char(0),char(-80),char(1), +char(4),char(0),char(-119),char(1),char(0),char(0),char(37),char(0),char(0),char(0),char(-79),char(1),char(93),char(0),char(-126),char(1),char(48),char(0),char(-78),char(1), +char(96),char(0),char(10),char(0),char(13),char(0),char(-85),char(1),char(15),char(0),char(-84),char(1),char(13),char(0),char(-83),char(1),char(13),char(0),char(-82),char(1), +char(13),char(0),char(-81),char(1),char(7),char(0),char(-80),char(1),char(4),char(0),char(-119),char(1),char(0),char(0),char(-79),char(1),char(94),char(0),char(-126),char(1), +char(50),char(0),char(-78),char(1),char(97),char(0),char(4),char(0),char(50),char(0),char(-77),char(1),char(96),char(0),char(-76),char(1),char(4),char(0),char(-75),char(1), +char(0),char(0),char(37),char(0),char(98),char(0),char(4),char(0),char(48),char(0),char(-77),char(1),char(95),char(0),char(-76),char(1),char(4),char(0),char(-75),char(1), +char(0),char(0),char(37),char(0),}; +int sBulletDNAlen64= sizeof(sBulletDNAstr64); diff --git a/pkg/mphysics/mbt/LinearMath/btSerializer64.cpp.i b/pkg/mphysics/mbt/LinearMath/btSerializer64.cpp.i new file mode 100644 index 00000000..74e0ba51 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btSerializer64.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btSerializer64.cpp ---------------- + +%include "LinearMath/btSerializer64.cpp" + +%{ +#include "LinearMath/btSerializer64.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btSpatialAlgebra.h b/pkg/mphysics/mbt/LinearMath/btSpatialAlgebra.h new file mode 100644 index 00000000..6ad67a10 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btSpatialAlgebra.h @@ -0,0 +1,389 @@ +/* +Copyright (c) 2003-2015 Erwin Coumans, Jakub Stepien + +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. +*/ + +///These spatial algebra classes are used for btMultiBody, +///see BulletDynamics/Featherstone + +#ifndef BT_SPATIAL_ALGEBRA_H +#define BT_SPATIAL_ALGEBRA_H + +#include "btMatrix3x3.h" + +struct btSpatialForceVector +{ + btVector3 m_topVec, m_bottomVec; + // + btSpatialForceVector() { setZero(); } + btSpatialForceVector(const btVector3 &angular, const btVector3 &linear) : m_topVec(linear), m_bottomVec(angular) {} + btSpatialForceVector(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz) + { + setValue(ax, ay, az, lx, ly, lz); + } + // + void setVector(const btVector3 &angular, const btVector3 &linear) + { + m_topVec = linear; + m_bottomVec = angular; + } + void setValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz) + { + m_bottomVec.setValue(ax, ay, az); + m_topVec.setValue(lx, ly, lz); + } + // + void addVector(const btVector3 &angular, const btVector3 &linear) + { + m_topVec += linear; + m_bottomVec += angular; + } + void addValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz) + { + m_bottomVec[0] += ax; + m_bottomVec[1] += ay; + m_bottomVec[2] += az; + m_topVec[0] += lx; + m_topVec[1] += ly; + m_topVec[2] += lz; + } + // + const btVector3 &getLinear() const { return m_topVec; } + const btVector3 &getAngular() const { return m_bottomVec; } + // + void setLinear(const btVector3 &linear) { m_topVec = linear; } + void setAngular(const btVector3 &angular) { m_bottomVec = angular; } + // + void addAngular(const btVector3 &angular) { m_bottomVec += angular; } + void addLinear(const btVector3 &linear) { m_topVec += linear; } + // + void setZero() + { + m_topVec.setZero(); + m_bottomVec.setZero(); + } + // + btSpatialForceVector &operator+=(const btSpatialForceVector &vec) + { + m_topVec += vec.m_topVec; + m_bottomVec += vec.m_bottomVec; + return *this; + } + btSpatialForceVector &operator-=(const btSpatialForceVector &vec) + { + m_topVec -= vec.m_topVec; + m_bottomVec -= vec.m_bottomVec; + return *this; + } + btSpatialForceVector operator-(const btSpatialForceVector &vec) const { return btSpatialForceVector(m_bottomVec - vec.m_bottomVec, m_topVec - vec.m_topVec); } + btSpatialForceVector operator+(const btSpatialForceVector &vec) const { return btSpatialForceVector(m_bottomVec + vec.m_bottomVec, m_topVec + vec.m_topVec); } + btSpatialForceVector operator-() const { return btSpatialForceVector(-m_bottomVec, -m_topVec); } + btSpatialForceVector operator*(const btScalar &s) const { return btSpatialForceVector(s * m_bottomVec, s * m_topVec); } + //btSpatialForceVector & operator = (const btSpatialForceVector &vec) { m_topVec = vec.m_topVec; m_bottomVec = vec.m_bottomVec; return *this; } +}; + +struct btSpatialMotionVector +{ + btVector3 m_topVec, m_bottomVec; + // + btSpatialMotionVector() { setZero(); } + btSpatialMotionVector(const btVector3 &angular, const btVector3 &linear) : m_topVec(angular), m_bottomVec(linear) {} + // + void setVector(const btVector3 &angular, const btVector3 &linear) + { + m_topVec = angular; + m_bottomVec = linear; + } + void setValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz) + { + m_topVec.setValue(ax, ay, az); + m_bottomVec.setValue(lx, ly, lz); + } + // + void addVector(const btVector3 &angular, const btVector3 &linear) + { + m_topVec += linear; + m_bottomVec += angular; + } + void addValue(const btScalar &ax, const btScalar &ay, const btScalar &az, const btScalar &lx, const btScalar &ly, const btScalar &lz) + { + m_topVec[0] += ax; + m_topVec[1] += ay; + m_topVec[2] += az; + m_bottomVec[0] += lx; + m_bottomVec[1] += ly; + m_bottomVec[2] += lz; + } + // + const btVector3 &getAngular() const { return m_topVec; } + const btVector3 &getLinear() const { return m_bottomVec; } + // + void setAngular(const btVector3 &angular) { m_topVec = angular; } + void setLinear(const btVector3 &linear) { m_bottomVec = linear; } + // + void addAngular(const btVector3 &angular) { m_topVec += angular; } + void addLinear(const btVector3 &linear) { m_bottomVec += linear; } + // + void setZero() + { + m_topVec.setZero(); + m_bottomVec.setZero(); + } + // + btScalar dot(const btSpatialForceVector &b) const + { + return m_bottomVec.dot(b.m_topVec) + m_topVec.dot(b.m_bottomVec); + } + // + template + void cross(const SpatialVectorType &b, SpatialVectorType &out) const + { + out.m_topVec = m_topVec.cross(b.m_topVec); + out.m_bottomVec = m_bottomVec.cross(b.m_topVec) + m_topVec.cross(b.m_bottomVec); + } + template + SpatialVectorType cross(const SpatialVectorType &b) const + { + SpatialVectorType out; + out.m_topVec = m_topVec.cross(b.m_topVec); + out.m_bottomVec = m_bottomVec.cross(b.m_topVec) + m_topVec.cross(b.m_bottomVec); + return out; + } + // + btSpatialMotionVector &operator+=(const btSpatialMotionVector &vec) + { + m_topVec += vec.m_topVec; + m_bottomVec += vec.m_bottomVec; + return *this; + } + btSpatialMotionVector &operator-=(const btSpatialMotionVector &vec) + { + m_topVec -= vec.m_topVec; + m_bottomVec -= vec.m_bottomVec; + return *this; + } + btSpatialMotionVector &operator*=(const btScalar &s) + { + m_topVec *= s; + m_bottomVec *= s; + return *this; + } + btSpatialMotionVector operator-(const btSpatialMotionVector &vec) const { return btSpatialMotionVector(m_topVec - vec.m_topVec, m_bottomVec - vec.m_bottomVec); } + btSpatialMotionVector operator+(const btSpatialMotionVector &vec) const { return btSpatialMotionVector(m_topVec + vec.m_topVec, m_bottomVec + vec.m_bottomVec); } + btSpatialMotionVector operator-() const { return btSpatialMotionVector(-m_topVec, -m_bottomVec); } + btSpatialMotionVector operator*(const btScalar &s) const { return btSpatialMotionVector(s * m_topVec, s * m_bottomVec); } +}; + +struct btSymmetricSpatialDyad +{ + btMatrix3x3 m_topLeftMat, m_topRightMat, m_bottomLeftMat; + // + btSymmetricSpatialDyad() { setIdentity(); } + btSymmetricSpatialDyad(const btMatrix3x3 &topLeftMat, const btMatrix3x3 &topRightMat, const btMatrix3x3 &bottomLeftMat) { setMatrix(topLeftMat, topRightMat, bottomLeftMat); } + // + void setMatrix(const btMatrix3x3 &topLeftMat, const btMatrix3x3 &topRightMat, const btMatrix3x3 &bottomLeftMat) + { + m_topLeftMat = topLeftMat; + m_topRightMat = topRightMat; + m_bottomLeftMat = bottomLeftMat; + } + // + void addMatrix(const btMatrix3x3 &topLeftMat, const btMatrix3x3 &topRightMat, const btMatrix3x3 &bottomLeftMat) + { + m_topLeftMat += topLeftMat; + m_topRightMat += topRightMat; + m_bottomLeftMat += bottomLeftMat; + } + // + void setIdentity() + { + m_topLeftMat.setIdentity(); + m_topRightMat.setIdentity(); + m_bottomLeftMat.setIdentity(); + } + // + btSymmetricSpatialDyad &operator-=(const btSymmetricSpatialDyad &mat) + { + m_topLeftMat -= mat.m_topLeftMat; + m_topRightMat -= mat.m_topRightMat; + m_bottomLeftMat -= mat.m_bottomLeftMat; + return *this; + } + // + btSpatialForceVector operator*(const btSpatialMotionVector &vec) + { + return btSpatialForceVector(m_bottomLeftMat * vec.m_topVec + m_topLeftMat.transpose() * vec.m_bottomVec, m_topLeftMat * vec.m_topVec + m_topRightMat * vec.m_bottomVec); + } +}; + +struct btSpatialTransformationMatrix +{ + btMatrix3x3 m_rotMat; //btMatrix3x3 m_trnCrossMat; + btVector3 m_trnVec; + // + enum eOutputOperation + { + None = 0, + Add = 1, + Subtract = 2 + }; + // + template + void transform(const SpatialVectorType &inVec, + SpatialVectorType &outVec, + eOutputOperation outOp = None) + { + if (outOp == None) + { + outVec.m_topVec = m_rotMat * inVec.m_topVec; + outVec.m_bottomVec = -m_trnVec.cross(outVec.m_topVec) + m_rotMat * inVec.m_bottomVec; + } + else if (outOp == Add) + { + outVec.m_topVec += m_rotMat * inVec.m_topVec; + outVec.m_bottomVec += -m_trnVec.cross(outVec.m_topVec) + m_rotMat * inVec.m_bottomVec; + } + else if (outOp == Subtract) + { + outVec.m_topVec -= m_rotMat * inVec.m_topVec; + outVec.m_bottomVec -= -m_trnVec.cross(outVec.m_topVec) + m_rotMat * inVec.m_bottomVec; + } + } + + template + void transformRotationOnly(const SpatialVectorType &inVec, + SpatialVectorType &outVec, + eOutputOperation outOp = None) + { + if (outOp == None) + { + outVec.m_topVec = m_rotMat * inVec.m_topVec; + outVec.m_bottomVec = m_rotMat * inVec.m_bottomVec; + } + else if (outOp == Add) + { + outVec.m_topVec += m_rotMat * inVec.m_topVec; + outVec.m_bottomVec += m_rotMat * inVec.m_bottomVec; + } + else if (outOp == Subtract) + { + outVec.m_topVec -= m_rotMat * inVec.m_topVec; + outVec.m_bottomVec -= m_rotMat * inVec.m_bottomVec; + } + } + + template + void transformInverse(const SpatialVectorType &inVec, + SpatialVectorType &outVec, + eOutputOperation outOp = None) + { + if (outOp == None) + { + outVec.m_topVec = m_rotMat.transpose() * inVec.m_topVec; + outVec.m_bottomVec = m_rotMat.transpose() * (inVec.m_bottomVec + m_trnVec.cross(inVec.m_topVec)); + } + else if (outOp == Add) + { + outVec.m_topVec += m_rotMat.transpose() * inVec.m_topVec; + outVec.m_bottomVec += m_rotMat.transpose() * (inVec.m_bottomVec + m_trnVec.cross(inVec.m_topVec)); + } + else if (outOp == Subtract) + { + outVec.m_topVec -= m_rotMat.transpose() * inVec.m_topVec; + outVec.m_bottomVec -= m_rotMat.transpose() * (inVec.m_bottomVec + m_trnVec.cross(inVec.m_topVec)); + } + } + + template + void transformInverseRotationOnly(const SpatialVectorType &inVec, + SpatialVectorType &outVec, + eOutputOperation outOp = None) + { + if (outOp == None) + { + outVec.m_topVec = m_rotMat.transpose() * inVec.m_topVec; + outVec.m_bottomVec = m_rotMat.transpose() * inVec.m_bottomVec; + } + else if (outOp == Add) + { + outVec.m_topVec += m_rotMat.transpose() * inVec.m_topVec; + outVec.m_bottomVec += m_rotMat.transpose() * inVec.m_bottomVec; + } + else if (outOp == Subtract) + { + outVec.m_topVec -= m_rotMat.transpose() * inVec.m_topVec; + outVec.m_bottomVec -= m_rotMat.transpose() * inVec.m_bottomVec; + } + } + + void transformInverse(const btSymmetricSpatialDyad &inMat, + btSymmetricSpatialDyad &outMat, + eOutputOperation outOp = None) + { + const btMatrix3x3 r_cross(0, -m_trnVec[2], m_trnVec[1], + m_trnVec[2], 0, -m_trnVec[0], + -m_trnVec[1], m_trnVec[0], 0); + + if (outOp == None) + { + outMat.m_topLeftMat = m_rotMat.transpose() * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) * m_rotMat; + outMat.m_topRightMat = m_rotMat.transpose() * inMat.m_topRightMat * m_rotMat; + outMat.m_bottomLeftMat = m_rotMat.transpose() * (r_cross * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) + inMat.m_bottomLeftMat - inMat.m_topLeftMat.transpose() * r_cross) * m_rotMat; + } + else if (outOp == Add) + { + outMat.m_topLeftMat += m_rotMat.transpose() * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) * m_rotMat; + outMat.m_topRightMat += m_rotMat.transpose() * inMat.m_topRightMat * m_rotMat; + outMat.m_bottomLeftMat += m_rotMat.transpose() * (r_cross * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) + inMat.m_bottomLeftMat - inMat.m_topLeftMat.transpose() * r_cross) * m_rotMat; + } + else if (outOp == Subtract) + { + outMat.m_topLeftMat -= m_rotMat.transpose() * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) * m_rotMat; + outMat.m_topRightMat -= m_rotMat.transpose() * inMat.m_topRightMat * m_rotMat; + outMat.m_bottomLeftMat -= m_rotMat.transpose() * (r_cross * (inMat.m_topLeftMat - inMat.m_topRightMat * r_cross) + inMat.m_bottomLeftMat - inMat.m_topLeftMat.transpose() * r_cross) * m_rotMat; + } + } + + template + SpatialVectorType operator*(const SpatialVectorType &vec) + { + SpatialVectorType out; + transform(vec, out); + return out; + } +}; + +template +void symmetricSpatialOuterProduct(const SpatialVectorType &a, const SpatialVectorType &b, btSymmetricSpatialDyad &out) +{ + //output op maybe? + + out.m_topLeftMat = outerProduct(a.m_topVec, b.m_bottomVec); + out.m_topRightMat = outerProduct(a.m_topVec, b.m_topVec); + out.m_topLeftMat = outerProduct(a.m_bottomVec, b.m_bottomVec); + //maybe simple a*spatTranspose(a) would be nicer? +} + +template +btSymmetricSpatialDyad symmetricSpatialOuterProduct(const SpatialVectorType &a, const SpatialVectorType &b) +{ + btSymmetricSpatialDyad out; + + out.m_topLeftMat = outerProduct(a.m_topVec, b.m_bottomVec); + out.m_topRightMat = outerProduct(a.m_topVec, b.m_topVec); + out.m_bottomLeftMat = outerProduct(a.m_bottomVec, b.m_bottomVec); + + return out; + //maybe simple a*spatTranspose(a) would be nicer? +} + +#endif //BT_SPATIAL_ALGEBRA_H diff --git a/pkg/mphysics/mbt/LinearMath/btSpatialAlgebra.h.i b/pkg/mphysics/mbt/LinearMath/btSpatialAlgebra.h.i new file mode 100644 index 00000000..7bb9b0d8 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btSpatialAlgebra.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btSpatialAlgebra.h ---------------- + +%include "LinearMath/btSpatialAlgebra.h" + +%{ +#include "LinearMath/btSpatialAlgebra.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btStackAlloc.h b/pkg/mphysics/mbt/LinearMath/btStackAlloc.h new file mode 100644 index 00000000..761d6a42 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btStackAlloc.h @@ -0,0 +1,118 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +StackAlloc extracted from GJK-EPA collision solver by Nathanael Presson +Nov.2006 +*/ + +#ifndef BT_STACK_ALLOC +#define BT_STACK_ALLOC + +#include "btScalar.h" //for btAssert +#include "btAlignedAllocator.h" + +///The btBlock class is an internal structure for the btStackAlloc memory allocator. +struct btBlock +{ + btBlock* previous; + unsigned char* address; +}; + +///The StackAlloc class provides some fast stack-based memory allocator (LIFO last-in first-out) +class btStackAlloc +{ +public: + btStackAlloc(unsigned int size) + { + ctor(); + create(size); + } + ~btStackAlloc() { destroy(); } + + inline void create(unsigned int size) + { + destroy(); + data = (unsigned char*)btAlignedAlloc(size, 16); + totalsize = size; + } + inline void destroy() + { + btAssert(usedsize == 0); + //Raise(L"StackAlloc is still in use"); + + if (usedsize == 0) + { + if (!ischild && data) + btAlignedFree(data); + + data = 0; + usedsize = 0; + } + } + + int getAvailableMemory() const + { + return static_cast(totalsize - usedsize); + } + + unsigned char* allocate(unsigned int size) + { + const unsigned int nus(usedsize + size); + if (nus < totalsize) + { + usedsize = nus; + return (data + (usedsize - size)); + } + btAssert(0); + //&& (L"Not enough memory")); + + return (0); + } + SIMD_FORCE_INLINE btBlock* beginBlock() + { + btBlock* pb = (btBlock*)allocate(sizeof(btBlock)); + pb->previous = current; + pb->address = data + usedsize; + current = pb; + return (pb); + } + SIMD_FORCE_INLINE void endBlock(btBlock* block) + { + btAssert(block == current); + //Raise(L"Unmatched blocks"); + if (block == current) + { + current = block->previous; + usedsize = (unsigned int)((block->address - data) - sizeof(btBlock)); + } + } + +private: + void ctor() + { + data = 0; + totalsize = 0; + usedsize = 0; + current = 0; + ischild = false; + } + unsigned char* data; + unsigned int totalsize; + unsigned int usedsize; + btBlock* current; + bool ischild; +}; + +#endif //BT_STACK_ALLOC diff --git a/pkg/mphysics/mbt/LinearMath/btStackAlloc.h.i b/pkg/mphysics/mbt/LinearMath/btStackAlloc.h.i new file mode 100644 index 00000000..d8d27180 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btStackAlloc.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btStackAlloc.h ---------------- + +%include "LinearMath/btStackAlloc.h" + +%{ +#include "LinearMath/btStackAlloc.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btThreads.cpp b/pkg/mphysics/mbt/LinearMath/btThreads.cpp new file mode 100644 index 00000000..c55cd67d --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btThreads.cpp @@ -0,0 +1,792 @@ +/* +Copyright (c) 2003-2014 Erwin Coumans http://bullet.googlecode.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btThreads.h" +#include "btQuickprof.h" +#include // for min and max + +#if BT_USE_OPENMP && BT_THREADSAFE + +#include + +#endif // #if BT_USE_OPENMP && BT_THREADSAFE + +#if BT_USE_PPL && BT_THREADSAFE + +// use Microsoft Parallel Patterns Library (installed with Visual Studio 2010 and later) +#include // if you get a compile error here, check whether your version of Visual Studio includes PPL +// Visual Studio 2010 and later should come with it +#include // for GetProcessorCount() + +#endif // #if BT_USE_PPL && BT_THREADSAFE + +#if BT_USE_TBB && BT_THREADSAFE + +// use Intel Threading Building Blocks for thread management +#define __TBB_NO_IMPLICIT_LINKAGE 1 +#include +#include +#include +#include + +#endif // #if BT_USE_TBB && BT_THREADSAFE + +#if BT_THREADSAFE +// +// Lightweight spin-mutex based on atomics +// Using ordinary system-provided mutexes like Windows critical sections was noticeably slower +// presumably because when it fails to lock at first it would sleep the thread and trigger costly +// context switching. +// + +#if __cplusplus >= 201103L + +// for anything claiming full C++11 compliance, use C++11 atomics +// on GCC or Clang you need to compile with -std=c++11 +#define USE_CPP11_ATOMICS 1 + +#elif defined(_MSC_VER) + +// on MSVC, use intrinsics instead +#define USE_MSVC_INTRINSICS 1 + +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) + +// available since GCC 4.7 and some versions of clang +// todo: check for clang +#define USE_GCC_BUILTIN_ATOMICS 1 + +#elif defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) + +// available since GCC 4.1 +#define USE_GCC_BUILTIN_ATOMICS_OLD 1 + +#endif + +#if USE_CPP11_ATOMICS + +#include +#include + +#define THREAD_LOCAL_STATIC thread_local static + +bool btSpinMutex::tryLock() +{ + std::atomic* aDest = reinterpret_cast*>(&mLock); + int expected = 0; + return std::atomic_compare_exchange_weak_explicit(aDest, &expected, int(1), std::memory_order_acq_rel, std::memory_order_acquire); +} + +void btSpinMutex::lock() +{ + // note: this lock does not sleep the thread. + while (!tryLock()) + { + // spin + } +} + +void btSpinMutex::unlock() +{ + std::atomic* aDest = reinterpret_cast*>(&mLock); + std::atomic_store_explicit(aDest, int(0), std::memory_order_release); +} + +#elif USE_MSVC_INTRINSICS + +#define WIN32_LEAN_AND_MEAN + +#include +#include + +#define THREAD_LOCAL_STATIC __declspec(thread) static + +bool btSpinMutex::tryLock() +{ + volatile long* aDest = reinterpret_cast(&mLock); + return (0 == _InterlockedCompareExchange(aDest, 1, 0)); +} + +void btSpinMutex::lock() +{ + // note: this lock does not sleep the thread + while (!tryLock()) + { + // spin + } +} + +void btSpinMutex::unlock() +{ + volatile long* aDest = reinterpret_cast(&mLock); + _InterlockedExchange(aDest, 0); +} + +#elif USE_GCC_BUILTIN_ATOMICS + +#define THREAD_LOCAL_STATIC static __thread + +bool btSpinMutex::tryLock() +{ + int expected = 0; + bool weak = false; + const int memOrderSuccess = __ATOMIC_ACQ_REL; + const int memOrderFail = __ATOMIC_ACQUIRE; + return __atomic_compare_exchange_n(&mLock, &expected, int(1), weak, memOrderSuccess, memOrderFail); +} + +void btSpinMutex::lock() +{ + // note: this lock does not sleep the thread + while (!tryLock()) + { + // spin + } +} + +void btSpinMutex::unlock() +{ + __atomic_store_n(&mLock, int(0), __ATOMIC_RELEASE); +} + +#elif USE_GCC_BUILTIN_ATOMICS_OLD + +#define THREAD_LOCAL_STATIC static __thread + +bool btSpinMutex::tryLock() +{ + return __sync_bool_compare_and_swap(&mLock, int(0), int(1)); +} + +void btSpinMutex::lock() +{ + // note: this lock does not sleep the thread + while (!tryLock()) + { + // spin + } +} + +void btSpinMutex::unlock() +{ + // write 0 + __sync_fetch_and_and(&mLock, int(0)); +} + +#else //#elif USE_MSVC_INTRINSICS + +#error "no threading primitives defined -- unknown platform" + +#endif //#else //#elif USE_MSVC_INTRINSICS + +#else //#if BT_THREADSAFE + +// These should not be called ever +void btSpinMutex::lock() +{ + btAssert(!"unimplemented btSpinMutex::lock() called"); +} + +void btSpinMutex::unlock() +{ + btAssert(!"unimplemented btSpinMutex::unlock() called"); +} + +bool btSpinMutex::tryLock() +{ + btAssert(!"unimplemented btSpinMutex::tryLock() called"); + return true; +} + +#define THREAD_LOCAL_STATIC static + +#endif // #else //#if BT_THREADSAFE + +struct ThreadsafeCounter +{ + unsigned int mCounter; + btSpinMutex mMutex; + + ThreadsafeCounter() + { + mCounter = 0; + --mCounter; // first count should come back 0 + } + + unsigned int getNext() + { + // no need to optimize this with atomics, it is only called ONCE per thread! + mMutex.lock(); + mCounter++; + if (mCounter >= BT_MAX_THREAD_COUNT) + { + btAssert(!"thread counter exceeded"); + // wrap back to the first worker index + mCounter = 1; + } + unsigned int val = mCounter; + mMutex.unlock(); + return val; + } +}; + +static btITaskScheduler* gBtTaskScheduler=0; +static int gThreadsRunningCounter = 0; // useful for detecting if we are trying to do nested parallel-for calls +static btSpinMutex gThreadsRunningCounterMutex; +static ThreadsafeCounter gThreadCounter; + +// +// BT_DETECT_BAD_THREAD_INDEX tries to detect when there are multiple threads assigned the same thread index. +// +// BT_DETECT_BAD_THREAD_INDEX is a developer option to test if +// certain assumptions about how the task scheduler manages its threads +// holds true. +// The main assumption is: +// - when the threadpool is resized, the task scheduler either +// 1. destroys all worker threads and creates all new ones in the correct number, OR +// 2. never destroys a worker thread +// +// We make that assumption because we can't easily enumerate the worker threads of a task scheduler +// to assign nice sequential thread-indexes. We also do not get notified if a worker thread is destroyed, +// so we can't tell when a thread-index is no longer being used. +// We allocate thread-indexes as needed with a sequential global thread counter. +// +// Our simple thread-counting scheme falls apart if the task scheduler destroys some threads but +// continues to re-use other threads and the application repeatedly resizes the thread pool of the +// task scheduler. +// In order to prevent the thread-counter from exceeding the global max (BT_MAX_THREAD_COUNT), we +// wrap the thread counter back to 1. This should only happen if the worker threads have all been +// destroyed and re-created. +// +// BT_DETECT_BAD_THREAD_INDEX only works for Win32 right now, +// but could be adapted to work with pthreads +#define BT_DETECT_BAD_THREAD_INDEX 0 + +#if BT_DETECT_BAD_THREAD_INDEX + +typedef DWORD ThreadId_t; +const static ThreadId_t kInvalidThreadId = 0; +ThreadId_t gDebugThreadIds[BT_MAX_THREAD_COUNT]; + +static ThreadId_t getDebugThreadId() +{ + return GetCurrentThreadId(); +} + +#endif // #if BT_DETECT_BAD_THREAD_INDEX + +// return a unique index per thread, main thread is 0, worker threads are in [1, BT_MAX_THREAD_COUNT) +unsigned int btGetCurrentThreadIndex() +{ + const unsigned int kNullIndex = ~0U; + THREAD_LOCAL_STATIC unsigned int sThreadIndex = kNullIndex; + if (sThreadIndex == kNullIndex) + { + sThreadIndex = gThreadCounter.getNext(); + btAssert(sThreadIndex < BT_MAX_THREAD_COUNT); + } +#if BT_DETECT_BAD_THREAD_INDEX + if (gBtTaskScheduler && sThreadIndex > 0) + { + ThreadId_t tid = getDebugThreadId(); + // if not set + if (gDebugThreadIds[sThreadIndex] == kInvalidThreadId) + { + // set it + gDebugThreadIds[sThreadIndex] = tid; + } + else + { + if (gDebugThreadIds[sThreadIndex] != tid) + { + // this could indicate the task scheduler is breaking our assumptions about + // how threads are managed when threadpool is resized + btAssert(!"there are 2 or more threads with the same thread-index!"); + __debugbreak(); + } + } + } +#endif // #if BT_DETECT_BAD_THREAD_INDEX + return sThreadIndex; +} + +bool btIsMainThread() +{ + return btGetCurrentThreadIndex() == 0; +} + +void btResetThreadIndexCounter() +{ + // for when all current worker threads are destroyed + btAssert(btIsMainThread()); + gThreadCounter.mCounter = 0; +} + +btITaskScheduler::btITaskScheduler(const char* name) +{ + m_name = name; + m_savedThreadCounter = 0; + m_isActive = false; +} + +void btITaskScheduler::activate() +{ + // gThreadCounter is used to assign a thread-index to each worker thread in a task scheduler. + // The main thread is always thread-index 0, and worker threads are numbered from 1 to 63 (BT_MAX_THREAD_COUNT-1) + // The thread-indexes need to be unique amongst the threads that can be running simultaneously. + // Since only one task scheduler can be used at a time, it is OK for a pair of threads that belong to different + // task schedulers to share the same thread index because they can't be running at the same time. + // So each task scheduler needs to keep its own thread counter value + if (!m_isActive) + { + gThreadCounter.mCounter = m_savedThreadCounter; // restore saved thread counter + m_isActive = true; + } +} + +void btITaskScheduler::deactivate() +{ + if (m_isActive) + { + m_savedThreadCounter = gThreadCounter.mCounter; // save thread counter + m_isActive = false; + } +} + +void btPushThreadsAreRunning() +{ + gThreadsRunningCounterMutex.lock(); + gThreadsRunningCounter++; + gThreadsRunningCounterMutex.unlock(); +} + +void btPopThreadsAreRunning() +{ + gThreadsRunningCounterMutex.lock(); + gThreadsRunningCounter--; + gThreadsRunningCounterMutex.unlock(); +} + +bool btThreadsAreRunning() +{ + return gThreadsRunningCounter != 0; +} + +void btSetTaskScheduler(btITaskScheduler* ts) +{ + int threadId = btGetCurrentThreadIndex(); // make sure we call this on main thread at least once before any workers run + if (threadId != 0) + { + btAssert(!"btSetTaskScheduler must be called from the main thread!"); + return; + } + if (gBtTaskScheduler) + { + // deactivate old task scheduler + gBtTaskScheduler->deactivate(); + } + gBtTaskScheduler = ts; + if (ts) + { + // activate new task scheduler + ts->activate(); + } +} + +btITaskScheduler* btGetTaskScheduler() +{ + return gBtTaskScheduler; +} + +void btParallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody& body) +{ +#if BT_THREADSAFE + +#if BT_DETECT_BAD_THREAD_INDEX + if (!btThreadsAreRunning()) + { + // clear out thread ids + for (int i = 0; i < BT_MAX_THREAD_COUNT; ++i) + { + gDebugThreadIds[i] = kInvalidThreadId; + } + } +#endif // #if BT_DETECT_BAD_THREAD_INDEX + + btAssert(gBtTaskScheduler != NULL); // call btSetTaskScheduler() with a valid task scheduler first! + gBtTaskScheduler->parallelFor(iBegin, iEnd, grainSize, body); + +#else // #if BT_THREADSAFE + + // non-parallel version of btParallelFor + btAssert(!"called btParallelFor in non-threadsafe build. enable BT_THREADSAFE"); + body.forLoop(iBegin, iEnd); + +#endif // #if BT_THREADSAFE +} + +btScalar btParallelSum(int iBegin, int iEnd, int grainSize, const btIParallelSumBody& body) +{ +#if BT_THREADSAFE + +#if BT_DETECT_BAD_THREAD_INDEX + if (!btThreadsAreRunning()) + { + // clear out thread ids + for (int i = 0; i < BT_MAX_THREAD_COUNT; ++i) + { + gDebugThreadIds[i] = kInvalidThreadId; + } + } +#endif // #if BT_DETECT_BAD_THREAD_INDEX + + btAssert(gBtTaskScheduler != NULL); // call btSetTaskScheduler() with a valid task scheduler first! + return gBtTaskScheduler->parallelSum(iBegin, iEnd, grainSize, body); + +#else // #if BT_THREADSAFE + + // non-parallel version of btParallelSum + btAssert(!"called btParallelFor in non-threadsafe build. enable BT_THREADSAFE"); + return body.sumLoop(iBegin, iEnd); + +#endif //#else // #if BT_THREADSAFE +} + +/// +/// btTaskSchedulerSequential -- non-threaded implementation of task scheduler +/// (really just useful for testing performance of single threaded vs multi) +/// +class btTaskSchedulerSequential : public btITaskScheduler +{ +public: + btTaskSchedulerSequential() : btITaskScheduler("Sequential") {} + virtual int getMaxNumThreads() const BT_OVERRIDE { return 1; } + virtual int getNumThreads() const BT_OVERRIDE { return 1; } + virtual void setNumThreads(int numThreads) BT_OVERRIDE {} + virtual void parallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody& body) BT_OVERRIDE + { +//\1("parallelFor_sequential"); + body.forLoop(iBegin, iEnd); + } + virtual btScalar parallelSum(int iBegin, int iEnd, int grainSize, const btIParallelSumBody& body) BT_OVERRIDE + { +//\1("parallelSum_sequential"); + return body.sumLoop(iBegin, iEnd); + } +}; + +#if BT_USE_OPENMP && BT_THREADSAFE +/// +/// btTaskSchedulerOpenMP -- wrapper around OpenMP task scheduler +/// +class btTaskSchedulerOpenMP : public btITaskScheduler +{ + int m_numThreads; + +public: + btTaskSchedulerOpenMP() : btITaskScheduler("OpenMP") + { + m_numThreads = 0; + } + virtual int getMaxNumThreads() const BT_OVERRIDE + { + return omp_get_max_threads(); + } + virtual int getNumThreads() const BT_OVERRIDE + { + return m_numThreads; + } + virtual void setNumThreads(int numThreads) BT_OVERRIDE + { + // With OpenMP, because it is a standard with various implementations, we can't + // know for sure if every implementation has the same behavior of destroying all + // previous threads when resizing the threadpool + m_numThreads = (std::max)(1, (std::min)(int(BT_MAX_THREAD_COUNT), numThreads)); + omp_set_num_threads(1); // hopefully, all previous threads get destroyed here + omp_set_num_threads(m_numThreads); + m_savedThreadCounter = 0; + if (m_isActive) + { + btResetThreadIndexCounter(); + } + } + virtual void parallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody& body) BT_OVERRIDE + { +//\1("parallelFor_OpenMP"); + btPushThreadsAreRunning(); +#pragma omp parallel for schedule(static, 1) + for (int i = iBegin; i < iEnd; i += grainSize) + { +//\1("OpenMP_forJob"); + body.forLoop(i, (std::min)(i + grainSize, iEnd)); + } + btPopThreadsAreRunning(); + } + virtual btScalar parallelSum(int iBegin, int iEnd, int grainSize, const btIParallelSumBody& body) BT_OVERRIDE + { +//\1("parallelFor_OpenMP"); + btPushThreadsAreRunning(); + btScalar sum = btScalar(0); +#pragma omp parallel for schedule(static, 1) reduction(+ \ + : sum) + for (int i = iBegin; i < iEnd; i += grainSize) + { +//\1("OpenMP_sumJob"); + sum += body.sumLoop(i, (std::min)(i + grainSize, iEnd)); + } + btPopThreadsAreRunning(); + return sum; + } +}; +#endif // #if BT_USE_OPENMP && BT_THREADSAFE + +#if BT_USE_TBB && BT_THREADSAFE +/// +/// btTaskSchedulerTBB -- wrapper around Intel Threaded Building Blocks task scheduler +/// +class btTaskSchedulerTBB : public btITaskScheduler +{ + int m_numThreads; + tbb::task_scheduler_init* m_tbbSchedulerInit; + +public: + btTaskSchedulerTBB() : btITaskScheduler("IntelTBB") + { + m_numThreads = 0; + m_tbbSchedulerInit = NULL; + } + ~btTaskSchedulerTBB() + { + if (m_tbbSchedulerInit) + { + delete m_tbbSchedulerInit; + m_tbbSchedulerInit = NULL; + } + } + + virtual int getMaxNumThreads() const BT_OVERRIDE + { + return tbb::task_scheduler_init::default_num_threads(); + } + virtual int getNumThreads() const BT_OVERRIDE + { + return m_numThreads; + } + virtual void setNumThreads(int numThreads) BT_OVERRIDE + { + m_numThreads = (std::max)(1, (std::min)(int(BT_MAX_THREAD_COUNT), numThreads)); + if (m_tbbSchedulerInit) + { + // destroys all previous threads + delete m_tbbSchedulerInit; + m_tbbSchedulerInit = NULL; + } + m_tbbSchedulerInit = new tbb::task_scheduler_init(m_numThreads); + m_savedThreadCounter = 0; + if (m_isActive) + { + btResetThreadIndexCounter(); + } + } + struct ForBodyAdapter + { + const btIParallelForBody* mBody; + + ForBodyAdapter(const btIParallelForBody* body) : mBody(body) {} + void operator()(const tbb::blocked_range& range) const + { +//\1("TBB_forJob"); + mBody->forLoop(range.begin(), range.end()); + } + }; + virtual void parallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody& body) BT_OVERRIDE + { +//\1("parallelFor_TBB"); + ForBodyAdapter tbbBody(&body); + btPushThreadsAreRunning(); + tbb::parallel_for(tbb::blocked_range(iBegin, iEnd, grainSize), + tbbBody, + tbb::simple_partitioner()); + btPopThreadsAreRunning(); + } + struct SumBodyAdapter + { + const btIParallelSumBody* mBody; + btScalar mSum; + + SumBodyAdapter(const btIParallelSumBody* body) : mBody(body), mSum(btScalar(0)) {} + SumBodyAdapter(const SumBodyAdapter& src, tbb::split) : mBody(src.mBody), mSum(btScalar(0)) {} + void join(const SumBodyAdapter& src) { mSum += src.mSum; } + void operator()(const tbb::blocked_range& range) + { +//\1("TBB_sumJob"); + mSum += mBody->sumLoop(range.begin(), range.end()); + } + }; + virtual btScalar parallelSum(int iBegin, int iEnd, int grainSize, const btIParallelSumBody& body) BT_OVERRIDE + { +//\1("parallelSum_TBB"); + SumBodyAdapter tbbBody(&body); + btPushThreadsAreRunning(); + tbb::parallel_deterministic_reduce(tbb::blocked_range(iBegin, iEnd, grainSize), tbbBody); + btPopThreadsAreRunning(); + return tbbBody.mSum; + } +}; +#endif // #if BT_USE_TBB && BT_THREADSAFE + +#if BT_USE_PPL && BT_THREADSAFE +/// +/// btTaskSchedulerPPL -- wrapper around Microsoft Parallel Patterns Lib task scheduler +/// +class btTaskSchedulerPPL : public btITaskScheduler +{ + int m_numThreads; + concurrency::combinable m_sum; // for parallelSum +public: + btTaskSchedulerPPL() : btITaskScheduler("PPL") + { + m_numThreads = 0; + } + virtual int getMaxNumThreads() const BT_OVERRIDE + { + return concurrency::GetProcessorCount(); + } + virtual int getNumThreads() const BT_OVERRIDE + { + return m_numThreads; + } + virtual void setNumThreads(int numThreads) BT_OVERRIDE + { + // capping the thread count for PPL due to a thread-index issue + const int maxThreadCount = (std::min)(int(BT_MAX_THREAD_COUNT), 31); + m_numThreads = (std::max)(1, (std::min)(maxThreadCount, numThreads)); + using namespace concurrency; + if (CurrentScheduler::Id() != -1) + { + CurrentScheduler::Detach(); + } + SchedulerPolicy policy; + { + // PPL seems to destroy threads when threadpool is shrunk, but keeps reusing old threads + // force it to destroy old threads + policy.SetConcurrencyLimits(1, 1); + CurrentScheduler::Create(policy); + CurrentScheduler::Detach(); + } + policy.SetConcurrencyLimits(m_numThreads, m_numThreads); + CurrentScheduler::Create(policy); + m_savedThreadCounter = 0; + if (m_isActive) + { + btResetThreadIndexCounter(); + } + } + struct ForBodyAdapter + { + const btIParallelForBody* mBody; + int mGrainSize; + int mIndexEnd; + + ForBodyAdapter(const btIParallelForBody* body, int grainSize, int end) : mBody(body), mGrainSize(grainSize), mIndexEnd(end) {} + void operator()(int i) const + { +//\1("PPL_forJob"); + mBody->forLoop(i, (std::min)(i + mGrainSize, mIndexEnd)); + } + }; + virtual void parallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody& body) BT_OVERRIDE + { +//\1("parallelFor_PPL"); + // PPL dispatch + ForBodyAdapter pplBody(&body, grainSize, iEnd); + btPushThreadsAreRunning(); + // note: MSVC 2010 doesn't support partitioner args, so avoid them + concurrency::parallel_for(iBegin, + iEnd, + grainSize, + pplBody); + btPopThreadsAreRunning(); + } + struct SumBodyAdapter + { + const btIParallelSumBody* mBody; + concurrency::combinable* mSum; + int mGrainSize; + int mIndexEnd; + + SumBodyAdapter(const btIParallelSumBody* body, concurrency::combinable* sum, int grainSize, int end) : mBody(body), mSum(sum), mGrainSize(grainSize), mIndexEnd(end) {} + void operator()(int i) const + { +//\1("PPL_sumJob"); + mSum->local() += mBody->sumLoop(i, (std::min)(i + mGrainSize, mIndexEnd)); + } + }; + static btScalar sumFunc(btScalar a, btScalar b) { return a + b; } + virtual btScalar parallelSum(int iBegin, int iEnd, int grainSize, const btIParallelSumBody& body) BT_OVERRIDE + { +//\1("parallelSum_PPL"); + m_sum.clear(); + SumBodyAdapter pplBody(&body, &m_sum, grainSize, iEnd); + btPushThreadsAreRunning(); + // note: MSVC 2010 doesn't support partitioner args, so avoid them + concurrency::parallel_for(iBegin, + iEnd, + grainSize, + pplBody); + btPopThreadsAreRunning(); + return m_sum.combine(sumFunc); + } +}; +#endif // #if BT_USE_PPL && BT_THREADSAFE + +// create a non-threaded task scheduler (always available) +btITaskScheduler* btGetSequentialTaskScheduler() +{ + static btTaskSchedulerSequential sTaskScheduler; + return &sTaskScheduler; +} + +// create an OpenMP task scheduler (if available, otherwise returns null) +btITaskScheduler* btGetOpenMPTaskScheduler() +{ +#if BT_USE_OPENMP && BT_THREADSAFE + static btTaskSchedulerOpenMP sTaskScheduler; + return &sTaskScheduler; +#else + return NULL; +#endif +} + +// create an Intel TBB task scheduler (if available, otherwise returns null) +btITaskScheduler* btGetTBBTaskScheduler() +{ +#if BT_USE_TBB && BT_THREADSAFE + static btTaskSchedulerTBB sTaskScheduler; + return &sTaskScheduler; +#else + return NULL; +#endif +} + +// create a PPL task scheduler (if available, otherwise returns null) +btITaskScheduler* btGetPPLTaskScheduler() +{ +#if BT_USE_PPL && BT_THREADSAFE + static btTaskSchedulerPPL sTaskScheduler; + return &sTaskScheduler; +#else + return NULL; +#endif +} diff --git a/pkg/mphysics/mbt/LinearMath/btThreads.cpp.i b/pkg/mphysics/mbt/LinearMath/btThreads.cpp.i new file mode 100644 index 00000000..60b2bb7b --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btThreads.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btThreads.cpp ---------------- + +%include "LinearMath/btThreads.cpp" + +%{ +#include "LinearMath/btThreads.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btThreads.h b/pkg/mphysics/mbt/LinearMath/btThreads.h new file mode 100644 index 00000000..0a164a33 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btThreads.h @@ -0,0 +1,177 @@ +/* +Copyright (c) 2003-2014 Erwin Coumans http://bullet.googlecode.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_THREADS_H +#define BT_THREADS_H + +#include "btScalar.h" // has definitions like SIMD_FORCE_INLINE + +#if defined(_MSC_VER) && _MSC_VER >= 1600 +// give us a compile error if any signatures of overriden methods is changed +#define BT_OVERRIDE override +#endif + +#ifndef BT_OVERRIDE +#define BT_OVERRIDE +#endif + +// Don't set this to larger than 64, without modifying btThreadSupportPosix +// and btThreadSupportWin32. They use UINT64 bit-masks. +const unsigned int BT_MAX_THREAD_COUNT = 64; // only if BT_THREADSAFE is 1 + +// for internal use only +bool btIsMainThread(); +bool btThreadsAreRunning(); +unsigned int btGetCurrentThreadIndex(); +void btResetThreadIndexCounter(); // notify that all worker threads have been destroyed + +/// +/// btSpinMutex -- lightweight spin-mutex implemented with atomic ops, never puts +/// a thread to sleep because it is designed to be used with a task scheduler +/// which has one thread per core and the threads don't sleep until they +/// run out of tasks. Not good for general purpose use. +/// +class btSpinMutex +{ + int mLock; + +public: + btSpinMutex() + { + mLock = 0; + } + void lock(); + void unlock(); + bool tryLock(); +}; + +// +// NOTE: btMutex* is for internal Bullet use only +// +// If BT_THREADSAFE is undefined or 0, should optimize away to nothing. +// This is good because for the single-threaded build of Bullet, any calls +// to these functions will be optimized out. +// +// However, for users of the multi-threaded build of Bullet this is kind +// of bad because if you call any of these functions from external code +// (where BT_THREADSAFE is undefined) you will get unexpected race conditions. +// +SIMD_FORCE_INLINE void btMutexLock(btSpinMutex* mutex) +{ +#if BT_THREADSAFE + mutex->lock(); +#else + (void)mutex; +#endif // #if BT_THREADSAFE +} + +SIMD_FORCE_INLINE void btMutexUnlock(btSpinMutex* mutex) +{ +#if BT_THREADSAFE + mutex->unlock(); +#else + (void)mutex; +#endif // #if BT_THREADSAFE +} + +SIMD_FORCE_INLINE bool btMutexTryLock(btSpinMutex* mutex) +{ +#if BT_THREADSAFE + return mutex->tryLock(); +#else + (void)mutex; + return true; +#endif // #if BT_THREADSAFE +} + +// +// btIParallelForBody -- subclass this to express work that can be done in parallel +// +class btIParallelForBody +{ +public: + virtual ~btIParallelForBody() {} + virtual void forLoop(int iBegin, int iEnd) const = 0; +}; + +// +// btIParallelSumBody -- subclass this to express work that can be done in parallel +// and produces a sum over all loop elements +// +class btIParallelSumBody +{ +public: + virtual ~btIParallelSumBody() {} + virtual btScalar sumLoop(int iBegin, int iEnd) const = 0; +}; + +// +// btITaskScheduler -- subclass this to implement a task scheduler that can dispatch work to +// worker threads +// +class btITaskScheduler +{ +public: + btITaskScheduler(const char* name); + virtual ~btITaskScheduler() {} + const char* getName() const { return m_name; } + + virtual int getMaxNumThreads() const = 0; + virtual int getNumThreads() const = 0; + virtual void setNumThreads(int numThreads) = 0; + virtual void parallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody& body) = 0; + virtual btScalar parallelSum(int iBegin, int iEnd, int grainSize, const btIParallelSumBody& body) = 0; + virtual void sleepWorkerThreadsHint() {} // hint the task scheduler that we may not be using these threads for a little while + + // internal use only + virtual void activate(); + virtual void deactivate(); + +protected: + const char* m_name; + unsigned int m_savedThreadCounter; + bool m_isActive; +}; + +// set the task scheduler to use for all calls to btParallelFor() +// NOTE: you must set this prior to using any of the multi-threaded "Mt" classes +void btSetTaskScheduler(btITaskScheduler* ts); + +// get the current task scheduler +btITaskScheduler* btGetTaskScheduler(); + +// get non-threaded task scheduler (always available) +btITaskScheduler* btGetSequentialTaskScheduler(); + +// // create a default task scheduler (Win32 or pthreads based) +// btITaskScheduler* btCreateDefaultTaskScheduler(); + +// get OpenMP task scheduler (if available, otherwise returns null) +btITaskScheduler* btGetOpenMPTaskScheduler(); + +// get Intel TBB task scheduler (if available, otherwise returns null) +btITaskScheduler* btGetTBBTaskScheduler(); + +// get PPL task scheduler (if available, otherwise returns null) +btITaskScheduler* btGetPPLTaskScheduler(); + +// btParallelFor -- call this to dispatch work like a for-loop +// (iterations may be done out of order, so no dependencies are allowed) +void btParallelFor(int iBegin, int iEnd, int grainSize, const btIParallelForBody& body); + +// btParallelSum -- call this to dispatch work like a for-loop, returns the sum of all iterations +// (iterations may be done out of order, so no dependencies are allowed) +btScalar btParallelSum(int iBegin, int iEnd, int grainSize, const btIParallelSumBody& body); + +#endif diff --git a/pkg/mphysics/mbt/LinearMath/btThreads.h.i b/pkg/mphysics/mbt/LinearMath/btThreads.h.i new file mode 100644 index 00000000..a573c215 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btThreads.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btThreads.h ---------------- + +%include "LinearMath/btThreads.h" + +%{ +#include "LinearMath/btThreads.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btTransform.h b/pkg/mphysics/mbt/LinearMath/btTransform.h new file mode 100644 index 00000000..b60c061e --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btTransform.h @@ -0,0 +1,287 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_TRANSFORM_H +#define BT_TRANSFORM_H + +#include "btMatrix3x3.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define btTransformData btTransformDoubleData +#else +#define btTransformData btTransformFloatData +#endif + +/**@brief The btTransform class supports rigid transforms with only translation and rotation and no scaling/shear. + *It can be used in combination with btVector3, btQuaternion and btMatrix3x3 linear algebra classes. */ +ATTRIBUTE_ALIGNED16(class) +btTransform +{ + ///Storage for the rotation + btMatrix3x3 m_basis; + ///Storage for the translation + btVector3 m_origin; + +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + /**@brief No initialization constructor */ + btTransform() {} + /**@brief Constructor from btQuaternion (optional btVector3 ) + * @param q Rotation from quaternion + * @param c Translation from Vector (default 0,0,0) */ + explicit SIMD_FORCE_INLINE btTransform(const btQuaternion& q, + const btVector3& c = btVector3(btScalar(0), btScalar(0), btScalar(0))) + : m_basis(q), + m_origin(c) + { + } + + /**@brief Constructor from btMatrix3x3 (optional btVector3) + * @param b Rotation from Matrix + * @param c Translation from Vector default (0,0,0)*/ + explicit SIMD_FORCE_INLINE btTransform(const btMatrix3x3& b, + const btVector3& c = btVector3(btScalar(0), btScalar(0), btScalar(0))) + : m_basis(b), + m_origin(c) + { + } + /**@brief Copy constructor */ + SIMD_FORCE_INLINE btTransform(const btTransform& other) + : m_basis(other.m_basis), + m_origin(other.m_origin) + { + } + /**@brief Assignment Operator */ + SIMD_FORCE_INLINE btTransform& operator=(const btTransform& other) + { + m_basis = other.m_basis; + m_origin = other.m_origin; + return *this; + } + + /**@brief Set the current transform as the value of the product of two transforms + * @param t1 Transform 1 + * @param t2 Transform 2 + * This = Transform1 * Transform2 */ + SIMD_FORCE_INLINE void mult(const btTransform& t1, const btTransform& t2) + { + m_basis = t1.m_basis * t2.m_basis; + m_origin = t1(t2.m_origin); + } + + /* void multInverseLeft(const btTransform& t1, const btTransform& t2) { + btVector3 v = t2.m_origin - t1.m_origin; + m_basis = btMultTransposeLeft(t1.m_basis, t2.m_basis); + m_origin = v * t1.m_basis; + } + */ + + /**@brief Return the transform of the vector */ + SIMD_FORCE_INLINE btVector3 operator()(const btVector3& x) const + { + return x.dot3(m_basis[0], m_basis[1], m_basis[2]) + m_origin; + } + + /**@brief Return the transform of the vector */ + SIMD_FORCE_INLINE btVector3 operator*(const btVector3& x) const + { + return (*this)(x); + } + + /**@brief Return the transform of the btQuaternion */ + SIMD_FORCE_INLINE btQuaternion operator*(const btQuaternion& q) const + { + return getRotation() * q; + } + + /**@brief Return the basis matrix for the rotation */ + SIMD_FORCE_INLINE btMatrix3x3& getBasis() { return m_basis; } + /**@brief Return the basis matrix for the rotation */ + SIMD_FORCE_INLINE const btMatrix3x3& getBasis() const { return m_basis; } + + /**@brief Return the origin vector translation */ + SIMD_FORCE_INLINE btVector3& getOrigin() { return m_origin; } + /**@brief Return the origin vector translation */ + SIMD_FORCE_INLINE const btVector3& getOrigin() const { return m_origin; } + + /**@brief Return a quaternion representing the rotation */ + btQuaternion getRotation() const + { + btQuaternion q; + m_basis.getRotation(q); + return q; + } + + /**@brief Set from an array + * @param m A pointer to a 16 element array (12 rotation(row major padded on the right by 1), and 3 translation */ + void setFromOpenGLMatrix(const btScalar* m) + { + m_basis.setFromOpenGLSubMatrix(m); + m_origin.setValue(m[12], m[13], m[14]); + } + + /**@brief Fill an array representation + * @param m A pointer to a 16 element array (12 rotation(row major padded on the right by 1), and 3 translation */ + void getOpenGLMatrix(btScalar * m) const + { + m_basis.getOpenGLSubMatrix(m); + m[12] = m_origin.x(); + m[13] = m_origin.y(); + m[14] = m_origin.z(); + m[15] = btScalar(1.0); + } + + /**@brief Set the translational element + * @param origin The vector to set the translation to */ + SIMD_FORCE_INLINE void setOrigin(const btVector3& origin) + { + m_origin = origin; + } + + SIMD_FORCE_INLINE btVector3 invXform(const btVector3& inVec) const; + + /**@brief Set the rotational element by btMatrix3x3 */ + SIMD_FORCE_INLINE void setBasis(const btMatrix3x3& basis) + { + m_basis = basis; + } + + /**@brief Set the rotational element by btQuaternion */ + SIMD_FORCE_INLINE void setRotation(const btQuaternion& q) + { + m_basis.setRotation(q); + } + + /**@brief Set this transformation to the identity */ + void setIdentity() + { + m_basis.setIdentity(); + m_origin.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)); + } + + /**@brief Multiply this Transform by another(this = this * another) + * @param t The other transform */ + btTransform& operator*=(const btTransform& t) + { + m_origin += m_basis * t.m_origin; + m_basis *= t.m_basis; + return *this; + } + + /**@brief Return the inverse of this transform */ + btTransform inverse() const + { + btMatrix3x3 inv = m_basis.transpose(); + return btTransform(inv, inv * -m_origin); + } + + /**@brief Return the inverse of this transform times the other transform + * @param t The other transform + * return this.inverse() * the other */ + btTransform inverseTimes(const btTransform& t) const; + + /**@brief Return the product of this transform and the other */ + btTransform operator*(const btTransform& t) const; + + /**@brief Return an identity transform */ + static const btTransform& getIdentity() + { + static const btTransform identityTransform(btMatrix3x3::getIdentity()); + return identityTransform; + } + + void serialize(struct btTransformData & dataOut) const; + + void serializeFloat(struct btTransformFloatData & dataOut) const; + + void deSerialize(const struct btTransformData& dataIn); + + void deSerializeDouble(const struct btTransformDoubleData& dataIn); + + void deSerializeFloat(const struct btTransformFloatData& dataIn); +}; + +SIMD_FORCE_INLINE btVector3 +btTransform::invXform(const btVector3& inVec) const +{ + btVector3 v = inVec - m_origin; + return (m_basis.transpose() * v); +} + +SIMD_FORCE_INLINE btTransform +btTransform::inverseTimes(const btTransform& t) const +{ + btVector3 v = t.getOrigin() - m_origin; + return btTransform(m_basis.transposeTimes(t.m_basis), + v * m_basis); +} + +SIMD_FORCE_INLINE btTransform + btTransform::operator*(const btTransform& t) const +{ + return btTransform(m_basis * t.m_basis, + (*this)(t.m_origin)); +} + +/**@brief Test if two transforms have all elements equal */ +SIMD_FORCE_INLINE bool operator==(const btTransform& t1, const btTransform& t2) +{ + return (t1.getBasis() == t2.getBasis() && + t1.getOrigin() == t2.getOrigin()); +} + +///for serialization +struct btTransformFloatData +{ + btMatrix3x3FloatData m_basis; + btVector3FloatData m_origin; +}; + +struct btTransformDoubleData +{ + btMatrix3x3DoubleData m_basis; + btVector3DoubleData m_origin; +}; + +SIMD_FORCE_INLINE void btTransform::serialize(btTransformData& dataOut) const +{ + m_basis.serialize(dataOut.m_basis); + m_origin.serialize(dataOut.m_origin); +} + +SIMD_FORCE_INLINE void btTransform::serializeFloat(btTransformFloatData& dataOut) const +{ + m_basis.serializeFloat(dataOut.m_basis); + m_origin.serializeFloat(dataOut.m_origin); +} + +SIMD_FORCE_INLINE void btTransform::deSerialize(const btTransformData& dataIn) +{ + m_basis.deSerialize(dataIn.m_basis); + m_origin.deSerialize(dataIn.m_origin); +} + +SIMD_FORCE_INLINE void btTransform::deSerializeFloat(const btTransformFloatData& dataIn) +{ + m_basis.deSerializeFloat(dataIn.m_basis); + m_origin.deSerializeFloat(dataIn.m_origin); +} + +SIMD_FORCE_INLINE void btTransform::deSerializeDouble(const btTransformDoubleData& dataIn) +{ + m_basis.deSerializeDouble(dataIn.m_basis); + m_origin.deSerializeDouble(dataIn.m_origin); +} + +#endif //BT_TRANSFORM_H diff --git a/pkg/mphysics/mbt/LinearMath/btTransform.h.i b/pkg/mphysics/mbt/LinearMath/btTransform.h.i new file mode 100644 index 00000000..80ebb948 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btTransform.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btTransform.h ---------------- + +%include "LinearMath/btTransform.h" + +%{ +#include "LinearMath/btTransform.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btTransformUtil.h b/pkg/mphysics/mbt/LinearMath/btTransformUtil.h new file mode 100644 index 00000000..a5aab208 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btTransformUtil.h @@ -0,0 +1,223 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_TRANSFORM_UTIL_H +#define BT_TRANSFORM_UTIL_H + +#include "btTransform.h" +#define ANGULAR_MOTION_THRESHOLD btScalar(0.5) * SIMD_HALF_PI + +SIMD_FORCE_INLINE btVector3 btAabbSupport(const btVector3& halfExtents, const btVector3& supportDir) +{ + return btVector3(supportDir.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(), + supportDir.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(), + supportDir.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z()); +} + +/// Utils related to temporal transforms +class btTransformUtil +{ +public: + static void integrateTransform(const btTransform& curTrans, const btVector3& linvel, const btVector3& angvel, btScalar timeStep, btTransform& predictedTransform) + { + predictedTransform.setOrigin(curTrans.getOrigin() + linvel * timeStep); + // #define QUATERNION_DERIVATIVE +#ifdef QUATERNION_DERIVATIVE + btQuaternion predictedOrn = curTrans.getRotation(); + predictedOrn += (angvel * predictedOrn) * (timeStep * btScalar(0.5)); + predictedOrn.safeNormalize(); +#else + //Exponential map + //google for "Practical Parameterization of Rotations Using the Exponential Map", F. Sebastian Grassia + + btVector3 axis; + btScalar fAngle2 = angvel.length2(); + btScalar fAngle = 0; + if (fAngle2 > SIMD_EPSILON) + { + fAngle = btSqrt(fAngle2); + } + + //limit the angular motion + if (fAngle * timeStep > ANGULAR_MOTION_THRESHOLD) + { + fAngle = ANGULAR_MOTION_THRESHOLD / timeStep; + } + + if (fAngle < btScalar(0.001)) + { + // use Taylor's expansions of sync function + axis = angvel * (btScalar(0.5) * timeStep - (timeStep * timeStep * timeStep) * (btScalar(0.020833333333)) * fAngle * fAngle); + } + else + { + // sync(fAngle) = sin(c*fAngle)/t + axis = angvel * (btSin(btScalar(0.5) * fAngle * timeStep) / fAngle); + } + btQuaternion dorn(axis.x(), axis.y(), axis.z(), btCos(fAngle * timeStep * btScalar(0.5))); + btQuaternion orn0 = curTrans.getRotation(); + + btQuaternion predictedOrn = dorn * orn0; + predictedOrn.safeNormalize(); +#endif + if (predictedOrn.length2() > SIMD_EPSILON) + { + predictedTransform.setRotation(predictedOrn); + } + else + { + predictedTransform.setBasis(curTrans.getBasis()); + } + } + + static void calculateVelocityQuaternion(const btVector3& pos0, const btVector3& pos1, const btQuaternion& orn0, const btQuaternion& orn1, btScalar timeStep, btVector3& linVel, btVector3& angVel) + { + linVel = (pos1 - pos0) / timeStep; + btVector3 axis; + btScalar angle; + if (orn0 != orn1) + { + calculateDiffAxisAngleQuaternion(orn0, orn1, axis, angle); + angVel = axis * angle / timeStep; + } + else + { + angVel.setValue(0, 0, 0); + } + } + + static void calculateDiffAxisAngleQuaternion(const btQuaternion& orn0, const btQuaternion& orn1a, btVector3& axis, btScalar& angle) + { + btQuaternion orn1 = orn0.nearest(orn1a); + btQuaternion dorn = orn1 * orn0.inverse(); + angle = dorn.getAngle(); + axis = btVector3(dorn.x(), dorn.y(), dorn.z()); + axis[3] = btScalar(0.); + //check for axis length + btScalar len = axis.length2(); + if (len < SIMD_EPSILON * SIMD_EPSILON) + axis = btVector3(btScalar(1.), btScalar(0.), btScalar(0.)); + else + axis /= btSqrt(len); + } + + static void calculateVelocity(const btTransform& transform0, const btTransform& transform1, btScalar timeStep, btVector3& linVel, btVector3& angVel) + { + linVel = (transform1.getOrigin() - transform0.getOrigin()) / timeStep; + btVector3 axis; + btScalar angle; + calculateDiffAxisAngle(transform0, transform1, axis, angle); + angVel = axis * angle / timeStep; + } + + static void calculateDiffAxisAngle(const btTransform& transform0, const btTransform& transform1, btVector3& axis, btScalar& angle) + { + btMatrix3x3 dmat = transform1.getBasis() * transform0.getBasis().inverse(); + btQuaternion dorn; + dmat.getRotation(dorn); + + ///floating point inaccuracy can lead to w component > 1..., which breaks + dorn.normalize(); + + angle = dorn.getAngle(); + axis = btVector3(dorn.x(), dorn.y(), dorn.z()); + axis[3] = btScalar(0.); + //check for axis length + btScalar len = axis.length2(); + if (len < SIMD_EPSILON * SIMD_EPSILON) + axis = btVector3(btScalar(1.), btScalar(0.), btScalar(0.)); + else + axis /= btSqrt(len); + } +}; + +///The btConvexSeparatingDistanceUtil can help speed up convex collision detection +///by conservatively updating a cached separating distance/vector instead of re-calculating the closest distance +class btConvexSeparatingDistanceUtil +{ + btQuaternion m_ornA; + btQuaternion m_ornB; + btVector3 m_posA; + btVector3 m_posB; + + btVector3 m_separatingNormal; + + btScalar m_boundingRadiusA; + btScalar m_boundingRadiusB; + btScalar m_separatingDistance; + +public: + btConvexSeparatingDistanceUtil(btScalar boundingRadiusA, btScalar boundingRadiusB) + : m_boundingRadiusA(boundingRadiusA), + m_boundingRadiusB(boundingRadiusB), + m_separatingDistance(0.f) + { + } + + btScalar getConservativeSeparatingDistance() + { + return m_separatingDistance; + } + + void updateSeparatingDistance(const btTransform& transA, const btTransform& transB) + { + const btVector3& toPosA = transA.getOrigin(); + const btVector3& toPosB = transB.getOrigin(); + btQuaternion toOrnA = transA.getRotation(); + btQuaternion toOrnB = transB.getRotation(); + + if (m_separatingDistance > 0.f) + { + btVector3 linVelA, angVelA, linVelB, angVelB; + btTransformUtil::calculateVelocityQuaternion(m_posA, toPosA, m_ornA, toOrnA, btScalar(1.), linVelA, angVelA); + btTransformUtil::calculateVelocityQuaternion(m_posB, toPosB, m_ornB, toOrnB, btScalar(1.), linVelB, angVelB); + btScalar maxAngularProjectedVelocity = angVelA.length() * m_boundingRadiusA + angVelB.length() * m_boundingRadiusB; + btVector3 relLinVel = (linVelB - linVelA); + btScalar relLinVelocLength = relLinVel.dot(m_separatingNormal); + if (relLinVelocLength < 0.f) + { + relLinVelocLength = 0.f; + } + + btScalar projectedMotion = maxAngularProjectedVelocity + relLinVelocLength; + m_separatingDistance -= projectedMotion; + } + + m_posA = toPosA; + m_posB = toPosB; + m_ornA = toOrnA; + m_ornB = toOrnB; + } + + void initSeparatingDistance(const btVector3& separatingVector, btScalar separatingDistance, const btTransform& transA, const btTransform& transB) + { + m_separatingDistance = separatingDistance; + + if (m_separatingDistance > 0.f) + { + m_separatingNormal = separatingVector; + + const btVector3& toPosA = transA.getOrigin(); + const btVector3& toPosB = transB.getOrigin(); + btQuaternion toOrnA = transA.getRotation(); + btQuaternion toOrnB = transB.getRotation(); + m_posA = toPosA; + m_posB = toPosB; + m_ornA = toOrnA; + m_ornB = toOrnB; + } + } +}; + +#endif //BT_TRANSFORM_UTIL_H diff --git a/pkg/mphysics/mbt/LinearMath/btTransformUtil.h.i b/pkg/mphysics/mbt/LinearMath/btTransformUtil.h.i new file mode 100644 index 00000000..9314d17e --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btTransformUtil.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btTransformUtil.h ---------------- + +%include "LinearMath/btTransformUtil.h" + +%{ +#include "LinearMath/btTransformUtil.h" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btVector3.cpp b/pkg/mphysics/mbt/LinearMath/btVector3.cpp new file mode 100644 index 00000000..55796c41 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btVector3.cpp @@ -0,0 +1,1664 @@ +/* + Copyright (c) 2011 Apple Inc. + https://bulletphysics.org + + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + This source version has been altered. + */ + +#if defined(_WIN32) || defined(__i386__) +#define BT_USE_SSE_IN_API +#endif + +#include "btVector3.h" + +#if defined BT_USE_SIMD_VECTOR3 + +#if DEBUG +#include //for memset +#endif + +#ifdef __APPLE__ +#include +typedef float float4 __attribute__((vector_size(16))); +#else +#define float4 __m128 +#endif +//typedef uint32_t uint4 __attribute__ ((vector_size(16))); + +#if defined BT_USE_SSE || defined _WIN32 + +#define LOG2_ARRAY_SIZE 6 +#define STACK_ARRAY_COUNT (1UL << LOG2_ARRAY_SIZE) + +#include + +long _maxdot_large(const float *vv, const float *vec, unsigned long count, float *dotResult); +long _maxdot_large(const float *vv, const float *vec, unsigned long count, float *dotResult) +{ + const float4 *vertices = (const float4 *)vv; + static const unsigned char indexTable[16] = {(unsigned char)-1, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0}; + float4 dotMax = btAssign128(-BT_INFINITY, -BT_INFINITY, -BT_INFINITY, -BT_INFINITY); + float4 vvec = _mm_loadu_ps(vec); + float4 vHi = btCastiTo128f(_mm_shuffle_epi32(btCastfTo128i(vvec), 0xaa)); /// zzzz + float4 vLo = _mm_movelh_ps(vvec, vvec); /// xyxy + + long maxIndex = -1L; + + size_t segment = 0; + float4 stack_array[STACK_ARRAY_COUNT]; + +#if DEBUG + //memset( stack_array, -1, STACK_ARRAY_COUNT * sizeof(stack_array[0]) ); +#endif + + size_t index; + float4 max; + // Faster loop without cleanup code for full tiles + for (segment = 0; segment + STACK_ARRAY_COUNT * 4 <= count; segment += STACK_ARRAY_COUNT * 4) + { + max = dotMax; + + for (index = 0; index < STACK_ARRAY_COUNT; index += 4) + { // do four dot products at a time. Carefully avoid touching the w element. + float4 v0 = vertices[0]; + float4 v1 = vertices[1]; + float4 v2 = vertices[2]; + float4 v3 = vertices[3]; + vertices += 4; + + float4 lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + float4 hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + float4 lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + float4 hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + float4 z = _mm_shuffle_ps(hi0, hi1, 0x88); + float4 x = _mm_shuffle_ps(lo0, lo1, 0x88); + float4 y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index] = x; + max = _mm_max_ps(x, max); // control the order here so that max is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 1] = x; + max = _mm_max_ps(x, max); // control the order here so that max is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 2] = x; + max = _mm_max_ps(x, max); // control the order here so that max is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 3] = x; + max = _mm_max_ps(x, max); // control the order here so that max is never NaN even if x is nan + + // It is too costly to keep the index of the max here. We will look for it again later. We save a lot of work this way. + } + + // If we found a new max + if (0xf != _mm_movemask_ps((float4)_mm_cmpeq_ps(max, dotMax))) + { + // copy the new max across all lanes of our max accumulator + max = _mm_max_ps(max, (float4)_mm_shuffle_ps(max, max, 0x4e)); + max = _mm_max_ps(max, (float4)_mm_shuffle_ps(max, max, 0xb1)); + + dotMax = max; + + // find first occurrence of that max + size_t test; + for (index = 0; 0 == (test = _mm_movemask_ps(_mm_cmpeq_ps(stack_array[index], max))); index++) // local_count must be a multiple of 4 + { + } + // record where it is. + maxIndex = 4 * index + segment + indexTable[test]; + } + } + + // account for work we've already done + count -= segment; + + // Deal with the last < STACK_ARRAY_COUNT vectors + max = dotMax; + index = 0; + + if (btUnlikely(count > 16)) + { + for (; index + 4 <= count / 4; index += 4) + { // do four dot products at a time. Carefully avoid touching the w element. + float4 v0 = vertices[0]; + float4 v1 = vertices[1]; + float4 v2 = vertices[2]; + float4 v3 = vertices[3]; + vertices += 4; + + float4 lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + float4 hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + float4 lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + float4 hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + float4 z = _mm_shuffle_ps(hi0, hi1, 0x88); + float4 x = _mm_shuffle_ps(lo0, lo1, 0x88); + float4 y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index] = x; + max = _mm_max_ps(x, max); // control the order here so that max is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 1] = x; + max = _mm_max_ps(x, max); // control the order here so that max is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 2] = x; + max = _mm_max_ps(x, max); // control the order here so that max is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 3] = x; + max = _mm_max_ps(x, max); // control the order here so that max is never NaN even if x is nan + + // It is too costly to keep the index of the max here. We will look for it again later. We save a lot of work this way. + } + } + + size_t localCount = (count & -4L) - 4 * index; + if (localCount) + { +#ifdef __APPLE__ + float4 t0, t1, t2, t3, t4; + float4 *sap = &stack_array[index + localCount / 4]; + vertices += localCount; // counter the offset + size_t byteIndex = -(localCount) * sizeof(float); + //AT&T Code style assembly + asm volatile( + ".align 4 \n\ + 0: movaps %[max], %[t2] // move max out of the way to avoid propagating NaNs in max \n\ + movaps (%[vertices], %[byteIndex], 4), %[t0] // vertices[0] \n\ + movaps 16(%[vertices], %[byteIndex], 4), %[t1] // vertices[1] \n\ + movaps %[t0], %[max] // vertices[0] \n\ + movlhps %[t1], %[max] // x0y0x1y1 \n\ + movaps 32(%[vertices], %[byteIndex], 4), %[t3] // vertices[2] \n\ + movaps 48(%[vertices], %[byteIndex], 4), %[t4] // vertices[3] \n\ + mulps %[vLo], %[max] // x0y0x1y1 * vLo \n\ + movhlps %[t0], %[t1] // z0w0z1w1 \n\ + movaps %[t3], %[t0] // vertices[2] \n\ + movlhps %[t4], %[t0] // x2y2x3y3 \n\ + mulps %[vLo], %[t0] // x2y2x3y3 * vLo \n\ + movhlps %[t3], %[t4] // z2w2z3w3 \n\ + shufps $0x88, %[t4], %[t1] // z0z1z2z3 \n\ + mulps %[vHi], %[t1] // z0z1z2z3 * vHi \n\ + movaps %[max], %[t3] // x0y0x1y1 * vLo \n\ + shufps $0x88, %[t0], %[max] // x0x1x2x3 * vLo.x \n\ + shufps $0xdd, %[t0], %[t3] // y0y1y2y3 * vLo.y \n\ + addps %[t3], %[max] // x + y \n\ + addps %[t1], %[max] // x + y + z \n\ + movaps %[max], (%[sap], %[byteIndex]) // record result for later scrutiny \n\ + maxps %[t2], %[max] // record max, restore max \n\ + add $16, %[byteIndex] // advance loop counter\n\ + jnz 0b \n\ + " + : [max] "+x"(max), [t0] "=&x"(t0), [t1] "=&x"(t1), [t2] "=&x"(t2), [t3] "=&x"(t3), [t4] "=&x"(t4), [byteIndex] "+r"(byteIndex) + : [vLo] "x"(vLo), [vHi] "x"(vHi), [vertices] "r"(vertices), [sap] "r"(sap) + : "memory", "cc"); + index += localCount / 4; +#else + { + for (unsigned int i = 0; i < localCount / 4; i++, index++) + { // do four dot products at a time. Carefully avoid touching the w element. + float4 v0 = vertices[0]; + float4 v1 = vertices[1]; + float4 v2 = vertices[2]; + float4 v3 = vertices[3]; + vertices += 4; + + float4 lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + float4 hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + float4 lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + float4 hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + float4 z = _mm_shuffle_ps(hi0, hi1, 0x88); + float4 x = _mm_shuffle_ps(lo0, lo1, 0x88); + float4 y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index] = x; + max = _mm_max_ps(x, max); // control the order here so that max is never NaN even if x is nan + } + } +#endif //__APPLE__ + } + + // process the last few points + if (count & 3) + { + float4 v0, v1, v2, x, y, z; + switch (count & 3) + { + case 3: + { + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + + // Calculate 3 dot products, transpose, duplicate v2 + float4 lo0 = _mm_movelh_ps(v0, v1); // xyxy.lo + float4 hi0 = _mm_movehl_ps(v1, v0); // z?z?.lo + lo0 = lo0 * vLo; + z = _mm_shuffle_ps(hi0, v2, 0xa8); // z0z1z2z2 + z = z * vHi; + float4 lo1 = _mm_movelh_ps(v2, v2); // xyxy + lo1 = lo1 * vLo; + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + } + break; + case 2: + { + v0 = vertices[0]; + v1 = vertices[1]; + float4 xy = _mm_movelh_ps(v0, v1); + z = _mm_movehl_ps(v1, v0); + xy = xy * vLo; + z = _mm_shuffle_ps(z, z, 0xa8); + x = _mm_shuffle_ps(xy, xy, 0xa8); + y = _mm_shuffle_ps(xy, xy, 0xfd); + z = z * vHi; + } + break; + case 1: + { + float4 xy = vertices[0]; + z = _mm_shuffle_ps(xy, xy, 0xaa); + xy = xy * vLo; + z = z * vHi; + x = _mm_shuffle_ps(xy, xy, 0); + y = _mm_shuffle_ps(xy, xy, 0x55); + } + break; + } + x = x + y; + x = x + z; + stack_array[index] = x; + max = _mm_max_ps(x, max); // control the order here so that max is never NaN even if x is nan + index++; + } + + // if we found a new max. + if (0 == segment || 0xf != _mm_movemask_ps((float4)_mm_cmpeq_ps(max, dotMax))) + { // we found a new max. Search for it + // find max across the max vector, place in all elements of max -- big latency hit here + max = _mm_max_ps(max, (float4)_mm_shuffle_ps(max, max, 0x4e)); + max = _mm_max_ps(max, (float4)_mm_shuffle_ps(max, max, 0xb1)); + + // It is slightly faster to do this part in scalar code when count < 8. However, the common case for + // this where it actually makes a difference is handled in the early out at the top of the function, + // so it is less than a 1% difference here. I opted for improved code size, fewer branches and reduced + // complexity, and removed it. + + dotMax = max; + + // scan for the first occurence of max in the array + size_t test; + for (index = 0; 0 == (test = _mm_movemask_ps(_mm_cmpeq_ps(stack_array[index], max))); index++) // local_count must be a multiple of 4 + { + } + maxIndex = 4 * index + segment + indexTable[test]; + } + + _mm_store_ss(dotResult, dotMax); + return maxIndex; +} + +long _mindot_large(const float *vv, const float *vec, unsigned long count, float *dotResult); + +long _mindot_large(const float *vv, const float *vec, unsigned long count, float *dotResult) +{ + const float4 *vertices = (const float4 *)vv; + static const unsigned char indexTable[16] = {(unsigned char)-1, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0}; + float4 dotmin = btAssign128(BT_INFINITY, BT_INFINITY, BT_INFINITY, BT_INFINITY); + float4 vvec = _mm_loadu_ps(vec); + float4 vHi = btCastiTo128f(_mm_shuffle_epi32(btCastfTo128i(vvec), 0xaa)); /// zzzz + float4 vLo = _mm_movelh_ps(vvec, vvec); /// xyxy + + long minIndex = -1L; + + size_t segment = 0; + float4 stack_array[STACK_ARRAY_COUNT]; + +#if DEBUG + //memset( stack_array, -1, STACK_ARRAY_COUNT * sizeof(stack_array[0]) ); +#endif + + size_t index; + float4 min; + // Faster loop without cleanup code for full tiles + for (segment = 0; segment + STACK_ARRAY_COUNT * 4 <= count; segment += STACK_ARRAY_COUNT * 4) + { + min = dotmin; + + for (index = 0; index < STACK_ARRAY_COUNT; index += 4) + { // do four dot products at a time. Carefully avoid touching the w element. + float4 v0 = vertices[0]; + float4 v1 = vertices[1]; + float4 v2 = vertices[2]; + float4 v3 = vertices[3]; + vertices += 4; + + float4 lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + float4 hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + float4 lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + float4 hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + float4 z = _mm_shuffle_ps(hi0, hi1, 0x88); + float4 x = _mm_shuffle_ps(lo0, lo1, 0x88); + float4 y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index] = x; + min = _mm_min_ps(x, min); // control the order here so that min is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 1] = x; + min = _mm_min_ps(x, min); // control the order here so that min is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 2] = x; + min = _mm_min_ps(x, min); // control the order here so that min is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 3] = x; + min = _mm_min_ps(x, min); // control the order here so that min is never NaN even if x is nan + + // It is too costly to keep the index of the min here. We will look for it again later. We save a lot of work this way. + } + + // If we found a new min + if (0xf != _mm_movemask_ps((float4)_mm_cmpeq_ps(min, dotmin))) + { + // copy the new min across all lanes of our min accumulator + min = _mm_min_ps(min, (float4)_mm_shuffle_ps(min, min, 0x4e)); + min = _mm_min_ps(min, (float4)_mm_shuffle_ps(min, min, 0xb1)); + + dotmin = min; + + // find first occurrence of that min + size_t test; + for (index = 0; 0 == (test = _mm_movemask_ps(_mm_cmpeq_ps(stack_array[index], min))); index++) // local_count must be a multiple of 4 + { + } + // record where it is. + minIndex = 4 * index + segment + indexTable[test]; + } + } + + // account for work we've already done + count -= segment; + + // Deal with the last < STACK_ARRAY_COUNT vectors + min = dotmin; + index = 0; + + if (btUnlikely(count > 16)) + { + for (; index + 4 <= count / 4; index += 4) + { // do four dot products at a time. Carefully avoid touching the w element. + float4 v0 = vertices[0]; + float4 v1 = vertices[1]; + float4 v2 = vertices[2]; + float4 v3 = vertices[3]; + vertices += 4; + + float4 lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + float4 hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + float4 lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + float4 hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + float4 z = _mm_shuffle_ps(hi0, hi1, 0x88); + float4 x = _mm_shuffle_ps(lo0, lo1, 0x88); + float4 y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index] = x; + min = _mm_min_ps(x, min); // control the order here so that min is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 1] = x; + min = _mm_min_ps(x, min); // control the order here so that min is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 2] = x; + min = _mm_min_ps(x, min); // control the order here so that min is never NaN even if x is nan + + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + v3 = vertices[3]; + vertices += 4; + + lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + z = _mm_shuffle_ps(hi0, hi1, 0x88); + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index + 3] = x; + min = _mm_min_ps(x, min); // control the order here so that min is never NaN even if x is nan + + // It is too costly to keep the index of the min here. We will look for it again later. We save a lot of work this way. + } + } + + size_t localCount = (count & -4L) - 4 * index; + if (localCount) + { +#ifdef __APPLE__ + vertices += localCount; // counter the offset + float4 t0, t1, t2, t3, t4; + size_t byteIndex = -(localCount) * sizeof(float); + float4 *sap = &stack_array[index + localCount / 4]; + + asm volatile( + ".align 4 \n\ + 0: movaps %[min], %[t2] // move min out of the way to avoid propagating NaNs in min \n\ + movaps (%[vertices], %[byteIndex], 4), %[t0] // vertices[0] \n\ + movaps 16(%[vertices], %[byteIndex], 4), %[t1] // vertices[1] \n\ + movaps %[t0], %[min] // vertices[0] \n\ + movlhps %[t1], %[min] // x0y0x1y1 \n\ + movaps 32(%[vertices], %[byteIndex], 4), %[t3] // vertices[2] \n\ + movaps 48(%[vertices], %[byteIndex], 4), %[t4] // vertices[3] \n\ + mulps %[vLo], %[min] // x0y0x1y1 * vLo \n\ + movhlps %[t0], %[t1] // z0w0z1w1 \n\ + movaps %[t3], %[t0] // vertices[2] \n\ + movlhps %[t4], %[t0] // x2y2x3y3 \n\ + movhlps %[t3], %[t4] // z2w2z3w3 \n\ + mulps %[vLo], %[t0] // x2y2x3y3 * vLo \n\ + shufps $0x88, %[t4], %[t1] // z0z1z2z3 \n\ + mulps %[vHi], %[t1] // z0z1z2z3 * vHi \n\ + movaps %[min], %[t3] // x0y0x1y1 * vLo \n\ + shufps $0x88, %[t0], %[min] // x0x1x2x3 * vLo.x \n\ + shufps $0xdd, %[t0], %[t3] // y0y1y2y3 * vLo.y \n\ + addps %[t3], %[min] // x + y \n\ + addps %[t1], %[min] // x + y + z \n\ + movaps %[min], (%[sap], %[byteIndex]) // record result for later scrutiny \n\ + minps %[t2], %[min] // record min, restore min \n\ + add $16, %[byteIndex] // advance loop counter\n\ + jnz 0b \n\ + " + : [min] "+x"(min), [t0] "=&x"(t0), [t1] "=&x"(t1), [t2] "=&x"(t2), [t3] "=&x"(t3), [t4] "=&x"(t4), [byteIndex] "+r"(byteIndex) + : [vLo] "x"(vLo), [vHi] "x"(vHi), [vertices] "r"(vertices), [sap] "r"(sap) + : "memory", "cc"); + index += localCount / 4; +#else + { + for (unsigned int i = 0; i < localCount / 4; i++, index++) + { // do four dot products at a time. Carefully avoid touching the w element. + float4 v0 = vertices[0]; + float4 v1 = vertices[1]; + float4 v2 = vertices[2]; + float4 v3 = vertices[3]; + vertices += 4; + + float4 lo0 = _mm_movelh_ps(v0, v1); // x0y0x1y1 + float4 hi0 = _mm_movehl_ps(v1, v0); // z0?0z1?1 + float4 lo1 = _mm_movelh_ps(v2, v3); // x2y2x3y3 + float4 hi1 = _mm_movehl_ps(v3, v2); // z2?2z3?3 + + lo0 = lo0 * vLo; + lo1 = lo1 * vLo; + float4 z = _mm_shuffle_ps(hi0, hi1, 0x88); + float4 x = _mm_shuffle_ps(lo0, lo1, 0x88); + float4 y = _mm_shuffle_ps(lo0, lo1, 0xdd); + z = z * vHi; + x = x + y; + x = x + z; + stack_array[index] = x; + min = _mm_min_ps(x, min); // control the order here so that max is never NaN even if x is nan + } + } + +#endif + } + + // process the last few points + if (count & 3) + { + float4 v0, v1, v2, x, y, z; + switch (count & 3) + { + case 3: + { + v0 = vertices[0]; + v1 = vertices[1]; + v2 = vertices[2]; + + // Calculate 3 dot products, transpose, duplicate v2 + float4 lo0 = _mm_movelh_ps(v0, v1); // xyxy.lo + float4 hi0 = _mm_movehl_ps(v1, v0); // z?z?.lo + lo0 = lo0 * vLo; + z = _mm_shuffle_ps(hi0, v2, 0xa8); // z0z1z2z2 + z = z * vHi; + float4 lo1 = _mm_movelh_ps(v2, v2); // xyxy + lo1 = lo1 * vLo; + x = _mm_shuffle_ps(lo0, lo1, 0x88); + y = _mm_shuffle_ps(lo0, lo1, 0xdd); + } + break; + case 2: + { + v0 = vertices[0]; + v1 = vertices[1]; + float4 xy = _mm_movelh_ps(v0, v1); + z = _mm_movehl_ps(v1, v0); + xy = xy * vLo; + z = _mm_shuffle_ps(z, z, 0xa8); + x = _mm_shuffle_ps(xy, xy, 0xa8); + y = _mm_shuffle_ps(xy, xy, 0xfd); + z = z * vHi; + } + break; + case 1: + { + float4 xy = vertices[0]; + z = _mm_shuffle_ps(xy, xy, 0xaa); + xy = xy * vLo; + z = z * vHi; + x = _mm_shuffle_ps(xy, xy, 0); + y = _mm_shuffle_ps(xy, xy, 0x55); + } + break; + } + x = x + y; + x = x + z; + stack_array[index] = x; + min = _mm_min_ps(x, min); // control the order here so that min is never NaN even if x is nan + index++; + } + + // if we found a new min. + if (0 == segment || 0xf != _mm_movemask_ps((float4)_mm_cmpeq_ps(min, dotmin))) + { // we found a new min. Search for it + // find min across the min vector, place in all elements of min -- big latency hit here + min = _mm_min_ps(min, (float4)_mm_shuffle_ps(min, min, 0x4e)); + min = _mm_min_ps(min, (float4)_mm_shuffle_ps(min, min, 0xb1)); + + // It is slightly faster to do this part in scalar code when count < 8. However, the common case for + // this where it actually makes a difference is handled in the early out at the top of the function, + // so it is less than a 1% difference here. I opted for improved code size, fewer branches and reduced + // complexity, and removed it. + + dotmin = min; + + // scan for the first occurence of min in the array + size_t test; + for (index = 0; 0 == (test = _mm_movemask_ps(_mm_cmpeq_ps(stack_array[index], min))); index++) // local_count must be a multiple of 4 + { + } + minIndex = 4 * index + segment + indexTable[test]; + } + + _mm_store_ss(dotResult, dotmin); + return minIndex; +} + +#elif defined BT_USE_NEON + +#define ARM_NEON_GCC_COMPATIBILITY 1 +#include +#include +#include //for sysctlbyname + +static long _maxdot_large_v0(const float *vv, const float *vec, unsigned long count, float *dotResult); +static long _maxdot_large_v1(const float *vv, const float *vec, unsigned long count, float *dotResult); +static long _maxdot_large_sel(const float *vv, const float *vec, unsigned long count, float *dotResult); +static long _mindot_large_v0(const float *vv, const float *vec, unsigned long count, float *dotResult); +static long _mindot_large_v1(const float *vv, const float *vec, unsigned long count, float *dotResult); +static long _mindot_large_sel(const float *vv, const float *vec, unsigned long count, float *dotResult); + +long (*_maxdot_large)(const float *vv, const float *vec, unsigned long count, float *dotResult) = _maxdot_large_sel; +long (*_mindot_large)(const float *vv, const float *vec, unsigned long count, float *dotResult) = _mindot_large_sel; + +static inline uint32_t btGetCpuCapabilities(void) +{ + static uint32_t capabilities = 0; + static bool testedCapabilities = false; + + if (0 == testedCapabilities) + { + uint32_t hasFeature = 0; + size_t featureSize = sizeof(hasFeature); + int err = sysctlbyname("hw.optional.neon_hpfp", &hasFeature, &featureSize, NULL, 0); + + if (0 == err && hasFeature) + capabilities |= 0x2000; + + testedCapabilities = true; + } + + return capabilities; +} + +static long _maxdot_large_sel(const float *vv, const float *vec, unsigned long count, float *dotResult) +{ + if (btGetCpuCapabilities() & 0x2000) + _maxdot_large = _maxdot_large_v1; + else + _maxdot_large = _maxdot_large_v0; + + return _maxdot_large(vv, vec, count, dotResult); +} + +static long _mindot_large_sel(const float *vv, const float *vec, unsigned long count, float *dotResult) +{ + if (btGetCpuCapabilities() & 0x2000) + _mindot_large = _mindot_large_v1; + else + _mindot_large = _mindot_large_v0; + + return _mindot_large(vv, vec, count, dotResult); +} + +#if defined __arm__ +#define vld1q_f32_aligned_postincrement(_ptr) ({ float32x4_t _r; asm( "vld1.f32 {%0}, [%1, :128]!\n" : "=w" (_r), "+r" (_ptr) ); /*return*/ _r; }) +#else +//support 64bit arm +#define vld1q_f32_aligned_postincrement(_ptr) ({ float32x4_t _r = ((float32x4_t*)(_ptr))[0]; (_ptr) = (const float*) ((const char*)(_ptr) + 16L); /*return*/ _r; }) +#endif + +long _maxdot_large_v0(const float *vv, const float *vec, unsigned long count, float *dotResult) +{ + unsigned long i = 0; + float32x4_t vvec = vld1q_f32_aligned_postincrement(vec); + float32x2_t vLo = vget_low_f32(vvec); + float32x2_t vHi = vdup_lane_f32(vget_high_f32(vvec), 0); + float32x2_t dotMaxLo = (float32x2_t){-BT_INFINITY, -BT_INFINITY}; + float32x2_t dotMaxHi = (float32x2_t){-BT_INFINITY, -BT_INFINITY}; + uint32x2_t indexLo = (uint32x2_t){0, 1}; + uint32x2_t indexHi = (uint32x2_t){2, 3}; + uint32x2_t iLo = (uint32x2_t){static_cast(-1), static_cast(-1)}; + uint32x2_t iHi = (uint32x2_t){static_cast(-1), static_cast(-1)}; + const uint32x2_t four = (uint32x2_t){4, 4}; + + for (; i + 8 <= count; i += 8) + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v3 = vld1q_f32_aligned_postincrement(vv); + + float32x2_t xy0 = vmul_f32(vget_low_f32(v0), vLo); + float32x2_t xy1 = vmul_f32(vget_low_f32(v1), vLo); + float32x2_t xy2 = vmul_f32(vget_low_f32(v2), vLo); + float32x2_t xy3 = vmul_f32(vget_low_f32(v3), vLo); + + float32x2x2_t z0 = vtrn_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x2x2_t z1 = vtrn_f32(vget_high_f32(v2), vget_high_f32(v3)); + float32x2_t zLo = vmul_f32(z0.val[0], vHi); + float32x2_t zHi = vmul_f32(z1.val[0], vHi); + + float32x2_t rLo = vpadd_f32(xy0, xy1); + float32x2_t rHi = vpadd_f32(xy2, xy3); + rLo = vadd_f32(rLo, zLo); + rHi = vadd_f32(rHi, zHi); + + uint32x2_t maskLo = vcgt_f32(rLo, dotMaxLo); + uint32x2_t maskHi = vcgt_f32(rHi, dotMaxHi); + dotMaxLo = vbsl_f32(maskLo, rLo, dotMaxLo); + dotMaxHi = vbsl_f32(maskHi, rHi, dotMaxHi); + iLo = vbsl_u32(maskLo, indexLo, iLo); + iHi = vbsl_u32(maskHi, indexHi, iHi); + indexLo = vadd_u32(indexLo, four); + indexHi = vadd_u32(indexHi, four); + + v0 = vld1q_f32_aligned_postincrement(vv); + v1 = vld1q_f32_aligned_postincrement(vv); + v2 = vld1q_f32_aligned_postincrement(vv); + v3 = vld1q_f32_aligned_postincrement(vv); + + xy0 = vmul_f32(vget_low_f32(v0), vLo); + xy1 = vmul_f32(vget_low_f32(v1), vLo); + xy2 = vmul_f32(vget_low_f32(v2), vLo); + xy3 = vmul_f32(vget_low_f32(v3), vLo); + + z0 = vtrn_f32(vget_high_f32(v0), vget_high_f32(v1)); + z1 = vtrn_f32(vget_high_f32(v2), vget_high_f32(v3)); + zLo = vmul_f32(z0.val[0], vHi); + zHi = vmul_f32(z1.val[0], vHi); + + rLo = vpadd_f32(xy0, xy1); + rHi = vpadd_f32(xy2, xy3); + rLo = vadd_f32(rLo, zLo); + rHi = vadd_f32(rHi, zHi); + + maskLo = vcgt_f32(rLo, dotMaxLo); + maskHi = vcgt_f32(rHi, dotMaxHi); + dotMaxLo = vbsl_f32(maskLo, rLo, dotMaxLo); + dotMaxHi = vbsl_f32(maskHi, rHi, dotMaxHi); + iLo = vbsl_u32(maskLo, indexLo, iLo); + iHi = vbsl_u32(maskHi, indexHi, iHi); + indexLo = vadd_u32(indexLo, four); + indexHi = vadd_u32(indexHi, four); + } + + for (; i + 4 <= count; i += 4) + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v3 = vld1q_f32_aligned_postincrement(vv); + + float32x2_t xy0 = vmul_f32(vget_low_f32(v0), vLo); + float32x2_t xy1 = vmul_f32(vget_low_f32(v1), vLo); + float32x2_t xy2 = vmul_f32(vget_low_f32(v2), vLo); + float32x2_t xy3 = vmul_f32(vget_low_f32(v3), vLo); + + float32x2x2_t z0 = vtrn_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x2x2_t z1 = vtrn_f32(vget_high_f32(v2), vget_high_f32(v3)); + float32x2_t zLo = vmul_f32(z0.val[0], vHi); + float32x2_t zHi = vmul_f32(z1.val[0], vHi); + + float32x2_t rLo = vpadd_f32(xy0, xy1); + float32x2_t rHi = vpadd_f32(xy2, xy3); + rLo = vadd_f32(rLo, zLo); + rHi = vadd_f32(rHi, zHi); + + uint32x2_t maskLo = vcgt_f32(rLo, dotMaxLo); + uint32x2_t maskHi = vcgt_f32(rHi, dotMaxHi); + dotMaxLo = vbsl_f32(maskLo, rLo, dotMaxLo); + dotMaxHi = vbsl_f32(maskHi, rHi, dotMaxHi); + iLo = vbsl_u32(maskLo, indexLo, iLo); + iHi = vbsl_u32(maskHi, indexHi, iHi); + indexLo = vadd_u32(indexLo, four); + indexHi = vadd_u32(indexHi, four); + } + + switch (count & 3) + { + case 3: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + + float32x2_t xy0 = vmul_f32(vget_low_f32(v0), vLo); + float32x2_t xy1 = vmul_f32(vget_low_f32(v1), vLo); + float32x2_t xy2 = vmul_f32(vget_low_f32(v2), vLo); + + float32x2x2_t z0 = vtrn_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x2_t zLo = vmul_f32(z0.val[0], vHi); + float32x2_t zHi = vmul_f32(vdup_lane_f32(vget_high_f32(v2), 0), vHi); + + float32x2_t rLo = vpadd_f32(xy0, xy1); + float32x2_t rHi = vpadd_f32(xy2, xy2); + rLo = vadd_f32(rLo, zLo); + rHi = vadd_f32(rHi, zHi); + + uint32x2_t maskLo = vcgt_f32(rLo, dotMaxLo); + uint32x2_t maskHi = vcgt_f32(rHi, dotMaxHi); + dotMaxLo = vbsl_f32(maskLo, rLo, dotMaxLo); + dotMaxHi = vbsl_f32(maskHi, rHi, dotMaxHi); + iLo = vbsl_u32(maskLo, indexLo, iLo); + iHi = vbsl_u32(maskHi, indexHi, iHi); + } + break; + case 2: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + + float32x2_t xy0 = vmul_f32(vget_low_f32(v0), vLo); + float32x2_t xy1 = vmul_f32(vget_low_f32(v1), vLo); + + float32x2x2_t z0 = vtrn_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x2_t zLo = vmul_f32(z0.val[0], vHi); + + float32x2_t rLo = vpadd_f32(xy0, xy1); + rLo = vadd_f32(rLo, zLo); + + uint32x2_t maskLo = vcgt_f32(rLo, dotMaxLo); + dotMaxLo = vbsl_f32(maskLo, rLo, dotMaxLo); + iLo = vbsl_u32(maskLo, indexLo, iLo); + } + break; + case 1: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x2_t xy0 = vmul_f32(vget_low_f32(v0), vLo); + float32x2_t z0 = vdup_lane_f32(vget_high_f32(v0), 0); + float32x2_t zLo = vmul_f32(z0, vHi); + float32x2_t rLo = vpadd_f32(xy0, xy0); + rLo = vadd_f32(rLo, zLo); + uint32x2_t maskLo = vcgt_f32(rLo, dotMaxLo); + dotMaxLo = vbsl_f32(maskLo, rLo, dotMaxLo); + iLo = vbsl_u32(maskLo, indexLo, iLo); + } + break; + + default: + break; + } + + // select best answer between hi and lo results + uint32x2_t mask = vcgt_f32(dotMaxHi, dotMaxLo); + dotMaxLo = vbsl_f32(mask, dotMaxHi, dotMaxLo); + iLo = vbsl_u32(mask, iHi, iLo); + + // select best answer between even and odd results + dotMaxHi = vdup_lane_f32(dotMaxLo, 1); + iHi = vdup_lane_u32(iLo, 1); + mask = vcgt_f32(dotMaxHi, dotMaxLo); + dotMaxLo = vbsl_f32(mask, dotMaxHi, dotMaxLo); + iLo = vbsl_u32(mask, iHi, iLo); + + *dotResult = vget_lane_f32(dotMaxLo, 0); + return vget_lane_u32(iLo, 0); +} + +long _maxdot_large_v1(const float *vv, const float *vec, unsigned long count, float *dotResult) +{ + float32x4_t vvec = vld1q_f32_aligned_postincrement(vec); + float32x4_t vLo = vcombine_f32(vget_low_f32(vvec), vget_low_f32(vvec)); + float32x4_t vHi = vdupq_lane_f32(vget_high_f32(vvec), 0); + const uint32x4_t four = (uint32x4_t){4, 4, 4, 4}; + uint32x4_t local_index = (uint32x4_t){0, 1, 2, 3}; + uint32x4_t index = (uint32x4_t){static_cast(-1), static_cast(-1), static_cast(-1), static_cast(-1)}; + float32x4_t maxDot = (float32x4_t){-BT_INFINITY, -BT_INFINITY, -BT_INFINITY, -BT_INFINITY}; + + unsigned long i = 0; + for (; i + 8 <= count; i += 8) + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v3 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + float32x4_t xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v1)); + float32x4_t xy1 = vcombine_f32(vget_low_f32(v2), vget_low_f32(v3)); + // the next two lines should resolve to a single vswp d, d + float32x4_t z0 = vcombine_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x4_t z1 = vcombine_f32(vget_high_f32(v2), vget_high_f32(v3)); + + xy0 = vmulq_f32(xy0, vLo); + xy1 = vmulq_f32(xy1, vLo); + + float32x4x2_t zb = vuzpq_f32(z0, z1); + float32x4_t z = vmulq_f32(zb.val[0], vHi); + float32x4x2_t xy = vuzpq_f32(xy0, xy1); + float32x4_t x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + uint32x4_t mask = vcgtq_f32(x, maxDot); + maxDot = vbslq_f32(mask, x, maxDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + + v0 = vld1q_f32_aligned_postincrement(vv); + v1 = vld1q_f32_aligned_postincrement(vv); + v2 = vld1q_f32_aligned_postincrement(vv); + v3 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v1)); + xy1 = vcombine_f32(vget_low_f32(v2), vget_low_f32(v3)); + // the next two lines should resolve to a single vswp d, d + z0 = vcombine_f32(vget_high_f32(v0), vget_high_f32(v1)); + z1 = vcombine_f32(vget_high_f32(v2), vget_high_f32(v3)); + + xy0 = vmulq_f32(xy0, vLo); + xy1 = vmulq_f32(xy1, vLo); + + zb = vuzpq_f32(z0, z1); + z = vmulq_f32(zb.val[0], vHi); + xy = vuzpq_f32(xy0, xy1); + x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + mask = vcgtq_f32(x, maxDot); + maxDot = vbslq_f32(mask, x, maxDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + } + + for (; i + 4 <= count; i += 4) + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v3 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + float32x4_t xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v1)); + float32x4_t xy1 = vcombine_f32(vget_low_f32(v2), vget_low_f32(v3)); + // the next two lines should resolve to a single vswp d, d + float32x4_t z0 = vcombine_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x4_t z1 = vcombine_f32(vget_high_f32(v2), vget_high_f32(v3)); + + xy0 = vmulq_f32(xy0, vLo); + xy1 = vmulq_f32(xy1, vLo); + + float32x4x2_t zb = vuzpq_f32(z0, z1); + float32x4_t z = vmulq_f32(zb.val[0], vHi); + float32x4x2_t xy = vuzpq_f32(xy0, xy1); + float32x4_t x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + uint32x4_t mask = vcgtq_f32(x, maxDot); + maxDot = vbslq_f32(mask, x, maxDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + } + + switch (count & 3) + { + case 3: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + float32x4_t xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v1)); + float32x4_t xy1 = vcombine_f32(vget_low_f32(v2), vget_low_f32(v2)); + // the next two lines should resolve to a single vswp d, d + float32x4_t z0 = vcombine_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x4_t z1 = vcombine_f32(vget_high_f32(v2), vget_high_f32(v2)); + + xy0 = vmulq_f32(xy0, vLo); + xy1 = vmulq_f32(xy1, vLo); + + float32x4x2_t zb = vuzpq_f32(z0, z1); + float32x4_t z = vmulq_f32(zb.val[0], vHi); + float32x4x2_t xy = vuzpq_f32(xy0, xy1); + float32x4_t x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + uint32x4_t mask = vcgtq_f32(x, maxDot); + maxDot = vbslq_f32(mask, x, maxDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + } + break; + + case 2: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + float32x4_t xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v1)); + // the next two lines should resolve to a single vswp d, d + float32x4_t z0 = vcombine_f32(vget_high_f32(v0), vget_high_f32(v1)); + + xy0 = vmulq_f32(xy0, vLo); + + float32x4x2_t zb = vuzpq_f32(z0, z0); + float32x4_t z = vmulq_f32(zb.val[0], vHi); + float32x4x2_t xy = vuzpq_f32(xy0, xy0); + float32x4_t x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + uint32x4_t mask = vcgtq_f32(x, maxDot); + maxDot = vbslq_f32(mask, x, maxDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + } + break; + + case 1: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + float32x4_t xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v0)); + // the next two lines should resolve to a single vswp d, d + float32x4_t z = vdupq_lane_f32(vget_high_f32(v0), 0); + + xy0 = vmulq_f32(xy0, vLo); + + z = vmulq_f32(z, vHi); + float32x4x2_t xy = vuzpq_f32(xy0, xy0); + float32x4_t x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + uint32x4_t mask = vcgtq_f32(x, maxDot); + maxDot = vbslq_f32(mask, x, maxDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + } + break; + + default: + break; + } + + // select best answer between hi and lo results + uint32x2_t mask = vcgt_f32(vget_high_f32(maxDot), vget_low_f32(maxDot)); + float32x2_t maxDot2 = vbsl_f32(mask, vget_high_f32(maxDot), vget_low_f32(maxDot)); + uint32x2_t index2 = vbsl_u32(mask, vget_high_u32(index), vget_low_u32(index)); + + // select best answer between even and odd results + float32x2_t maxDotO = vdup_lane_f32(maxDot2, 1); + uint32x2_t indexHi = vdup_lane_u32(index2, 1); + mask = vcgt_f32(maxDotO, maxDot2); + maxDot2 = vbsl_f32(mask, maxDotO, maxDot2); + index2 = vbsl_u32(mask, indexHi, index2); + + *dotResult = vget_lane_f32(maxDot2, 0); + return vget_lane_u32(index2, 0); +} + +long _mindot_large_v0(const float *vv, const float *vec, unsigned long count, float *dotResult) +{ + unsigned long i = 0; + float32x4_t vvec = vld1q_f32_aligned_postincrement(vec); + float32x2_t vLo = vget_low_f32(vvec); + float32x2_t vHi = vdup_lane_f32(vget_high_f32(vvec), 0); + float32x2_t dotMinLo = (float32x2_t){BT_INFINITY, BT_INFINITY}; + float32x2_t dotMinHi = (float32x2_t){BT_INFINITY, BT_INFINITY}; + uint32x2_t indexLo = (uint32x2_t){0, 1}; + uint32x2_t indexHi = (uint32x2_t){2, 3}; + uint32x2_t iLo = (uint32x2_t){static_cast(-1), static_cast(-1)}; + uint32x2_t iHi = (uint32x2_t){static_cast(-1), static_cast(-1)}; + const uint32x2_t four = (uint32x2_t){4, 4}; + + for (; i + 8 <= count; i += 8) + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v3 = vld1q_f32_aligned_postincrement(vv); + + float32x2_t xy0 = vmul_f32(vget_low_f32(v0), vLo); + float32x2_t xy1 = vmul_f32(vget_low_f32(v1), vLo); + float32x2_t xy2 = vmul_f32(vget_low_f32(v2), vLo); + float32x2_t xy3 = vmul_f32(vget_low_f32(v3), vLo); + + float32x2x2_t z0 = vtrn_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x2x2_t z1 = vtrn_f32(vget_high_f32(v2), vget_high_f32(v3)); + float32x2_t zLo = vmul_f32(z0.val[0], vHi); + float32x2_t zHi = vmul_f32(z1.val[0], vHi); + + float32x2_t rLo = vpadd_f32(xy0, xy1); + float32x2_t rHi = vpadd_f32(xy2, xy3); + rLo = vadd_f32(rLo, zLo); + rHi = vadd_f32(rHi, zHi); + + uint32x2_t maskLo = vclt_f32(rLo, dotMinLo); + uint32x2_t maskHi = vclt_f32(rHi, dotMinHi); + dotMinLo = vbsl_f32(maskLo, rLo, dotMinLo); + dotMinHi = vbsl_f32(maskHi, rHi, dotMinHi); + iLo = vbsl_u32(maskLo, indexLo, iLo); + iHi = vbsl_u32(maskHi, indexHi, iHi); + indexLo = vadd_u32(indexLo, four); + indexHi = vadd_u32(indexHi, four); + + v0 = vld1q_f32_aligned_postincrement(vv); + v1 = vld1q_f32_aligned_postincrement(vv); + v2 = vld1q_f32_aligned_postincrement(vv); + v3 = vld1q_f32_aligned_postincrement(vv); + + xy0 = vmul_f32(vget_low_f32(v0), vLo); + xy1 = vmul_f32(vget_low_f32(v1), vLo); + xy2 = vmul_f32(vget_low_f32(v2), vLo); + xy3 = vmul_f32(vget_low_f32(v3), vLo); + + z0 = vtrn_f32(vget_high_f32(v0), vget_high_f32(v1)); + z1 = vtrn_f32(vget_high_f32(v2), vget_high_f32(v3)); + zLo = vmul_f32(z0.val[0], vHi); + zHi = vmul_f32(z1.val[0], vHi); + + rLo = vpadd_f32(xy0, xy1); + rHi = vpadd_f32(xy2, xy3); + rLo = vadd_f32(rLo, zLo); + rHi = vadd_f32(rHi, zHi); + + maskLo = vclt_f32(rLo, dotMinLo); + maskHi = vclt_f32(rHi, dotMinHi); + dotMinLo = vbsl_f32(maskLo, rLo, dotMinLo); + dotMinHi = vbsl_f32(maskHi, rHi, dotMinHi); + iLo = vbsl_u32(maskLo, indexLo, iLo); + iHi = vbsl_u32(maskHi, indexHi, iHi); + indexLo = vadd_u32(indexLo, four); + indexHi = vadd_u32(indexHi, four); + } + + for (; i + 4 <= count; i += 4) + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v3 = vld1q_f32_aligned_postincrement(vv); + + float32x2_t xy0 = vmul_f32(vget_low_f32(v0), vLo); + float32x2_t xy1 = vmul_f32(vget_low_f32(v1), vLo); + float32x2_t xy2 = vmul_f32(vget_low_f32(v2), vLo); + float32x2_t xy3 = vmul_f32(vget_low_f32(v3), vLo); + + float32x2x2_t z0 = vtrn_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x2x2_t z1 = vtrn_f32(vget_high_f32(v2), vget_high_f32(v3)); + float32x2_t zLo = vmul_f32(z0.val[0], vHi); + float32x2_t zHi = vmul_f32(z1.val[0], vHi); + + float32x2_t rLo = vpadd_f32(xy0, xy1); + float32x2_t rHi = vpadd_f32(xy2, xy3); + rLo = vadd_f32(rLo, zLo); + rHi = vadd_f32(rHi, zHi); + + uint32x2_t maskLo = vclt_f32(rLo, dotMinLo); + uint32x2_t maskHi = vclt_f32(rHi, dotMinHi); + dotMinLo = vbsl_f32(maskLo, rLo, dotMinLo); + dotMinHi = vbsl_f32(maskHi, rHi, dotMinHi); + iLo = vbsl_u32(maskLo, indexLo, iLo); + iHi = vbsl_u32(maskHi, indexHi, iHi); + indexLo = vadd_u32(indexLo, four); + indexHi = vadd_u32(indexHi, four); + } + switch (count & 3) + { + case 3: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + + float32x2_t xy0 = vmul_f32(vget_low_f32(v0), vLo); + float32x2_t xy1 = vmul_f32(vget_low_f32(v1), vLo); + float32x2_t xy2 = vmul_f32(vget_low_f32(v2), vLo); + + float32x2x2_t z0 = vtrn_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x2_t zLo = vmul_f32(z0.val[0], vHi); + float32x2_t zHi = vmul_f32(vdup_lane_f32(vget_high_f32(v2), 0), vHi); + + float32x2_t rLo = vpadd_f32(xy0, xy1); + float32x2_t rHi = vpadd_f32(xy2, xy2); + rLo = vadd_f32(rLo, zLo); + rHi = vadd_f32(rHi, zHi); + + uint32x2_t maskLo = vclt_f32(rLo, dotMinLo); + uint32x2_t maskHi = vclt_f32(rHi, dotMinHi); + dotMinLo = vbsl_f32(maskLo, rLo, dotMinLo); + dotMinHi = vbsl_f32(maskHi, rHi, dotMinHi); + iLo = vbsl_u32(maskLo, indexLo, iLo); + iHi = vbsl_u32(maskHi, indexHi, iHi); + } + break; + case 2: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + + float32x2_t xy0 = vmul_f32(vget_low_f32(v0), vLo); + float32x2_t xy1 = vmul_f32(vget_low_f32(v1), vLo); + + float32x2x2_t z0 = vtrn_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x2_t zLo = vmul_f32(z0.val[0], vHi); + + float32x2_t rLo = vpadd_f32(xy0, xy1); + rLo = vadd_f32(rLo, zLo); + + uint32x2_t maskLo = vclt_f32(rLo, dotMinLo); + dotMinLo = vbsl_f32(maskLo, rLo, dotMinLo); + iLo = vbsl_u32(maskLo, indexLo, iLo); + } + break; + case 1: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x2_t xy0 = vmul_f32(vget_low_f32(v0), vLo); + float32x2_t z0 = vdup_lane_f32(vget_high_f32(v0), 0); + float32x2_t zLo = vmul_f32(z0, vHi); + float32x2_t rLo = vpadd_f32(xy0, xy0); + rLo = vadd_f32(rLo, zLo); + uint32x2_t maskLo = vclt_f32(rLo, dotMinLo); + dotMinLo = vbsl_f32(maskLo, rLo, dotMinLo); + iLo = vbsl_u32(maskLo, indexLo, iLo); + } + break; + + default: + break; + } + + // select best answer between hi and lo results + uint32x2_t mask = vclt_f32(dotMinHi, dotMinLo); + dotMinLo = vbsl_f32(mask, dotMinHi, dotMinLo); + iLo = vbsl_u32(mask, iHi, iLo); + + // select best answer between even and odd results + dotMinHi = vdup_lane_f32(dotMinLo, 1); + iHi = vdup_lane_u32(iLo, 1); + mask = vclt_f32(dotMinHi, dotMinLo); + dotMinLo = vbsl_f32(mask, dotMinHi, dotMinLo); + iLo = vbsl_u32(mask, iHi, iLo); + + *dotResult = vget_lane_f32(dotMinLo, 0); + return vget_lane_u32(iLo, 0); +} + +long _mindot_large_v1(const float *vv, const float *vec, unsigned long count, float *dotResult) +{ + float32x4_t vvec = vld1q_f32_aligned_postincrement(vec); + float32x4_t vLo = vcombine_f32(vget_low_f32(vvec), vget_low_f32(vvec)); + float32x4_t vHi = vdupq_lane_f32(vget_high_f32(vvec), 0); + const uint32x4_t four = (uint32x4_t){4, 4, 4, 4}; + uint32x4_t local_index = (uint32x4_t){0, 1, 2, 3}; + uint32x4_t index = (uint32x4_t){static_cast(-1), static_cast(-1), static_cast(-1), static_cast(-1)}; + float32x4_t minDot = (float32x4_t){BT_INFINITY, BT_INFINITY, BT_INFINITY, BT_INFINITY}; + + unsigned long i = 0; + for (; i + 8 <= count; i += 8) + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v3 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + float32x4_t xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v1)); + float32x4_t xy1 = vcombine_f32(vget_low_f32(v2), vget_low_f32(v3)); + // the next two lines should resolve to a single vswp d, d + float32x4_t z0 = vcombine_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x4_t z1 = vcombine_f32(vget_high_f32(v2), vget_high_f32(v3)); + + xy0 = vmulq_f32(xy0, vLo); + xy1 = vmulq_f32(xy1, vLo); + + float32x4x2_t zb = vuzpq_f32(z0, z1); + float32x4_t z = vmulq_f32(zb.val[0], vHi); + float32x4x2_t xy = vuzpq_f32(xy0, xy1); + float32x4_t x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + uint32x4_t mask = vcltq_f32(x, minDot); + minDot = vbslq_f32(mask, x, minDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + + v0 = vld1q_f32_aligned_postincrement(vv); + v1 = vld1q_f32_aligned_postincrement(vv); + v2 = vld1q_f32_aligned_postincrement(vv); + v3 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v1)); + xy1 = vcombine_f32(vget_low_f32(v2), vget_low_f32(v3)); + // the next two lines should resolve to a single vswp d, d + z0 = vcombine_f32(vget_high_f32(v0), vget_high_f32(v1)); + z1 = vcombine_f32(vget_high_f32(v2), vget_high_f32(v3)); + + xy0 = vmulq_f32(xy0, vLo); + xy1 = vmulq_f32(xy1, vLo); + + zb = vuzpq_f32(z0, z1); + z = vmulq_f32(zb.val[0], vHi); + xy = vuzpq_f32(xy0, xy1); + x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + mask = vcltq_f32(x, minDot); + minDot = vbslq_f32(mask, x, minDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + } + + for (; i + 4 <= count; i += 4) + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v3 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + float32x4_t xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v1)); + float32x4_t xy1 = vcombine_f32(vget_low_f32(v2), vget_low_f32(v3)); + // the next two lines should resolve to a single vswp d, d + float32x4_t z0 = vcombine_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x4_t z1 = vcombine_f32(vget_high_f32(v2), vget_high_f32(v3)); + + xy0 = vmulq_f32(xy0, vLo); + xy1 = vmulq_f32(xy1, vLo); + + float32x4x2_t zb = vuzpq_f32(z0, z1); + float32x4_t z = vmulq_f32(zb.val[0], vHi); + float32x4x2_t xy = vuzpq_f32(xy0, xy1); + float32x4_t x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + uint32x4_t mask = vcltq_f32(x, minDot); + minDot = vbslq_f32(mask, x, minDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + } + + switch (count & 3) + { + case 3: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v2 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + float32x4_t xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v1)); + float32x4_t xy1 = vcombine_f32(vget_low_f32(v2), vget_low_f32(v2)); + // the next two lines should resolve to a single vswp d, d + float32x4_t z0 = vcombine_f32(vget_high_f32(v0), vget_high_f32(v1)); + float32x4_t z1 = vcombine_f32(vget_high_f32(v2), vget_high_f32(v2)); + + xy0 = vmulq_f32(xy0, vLo); + xy1 = vmulq_f32(xy1, vLo); + + float32x4x2_t zb = vuzpq_f32(z0, z1); + float32x4_t z = vmulq_f32(zb.val[0], vHi); + float32x4x2_t xy = vuzpq_f32(xy0, xy1); + float32x4_t x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + uint32x4_t mask = vcltq_f32(x, minDot); + minDot = vbslq_f32(mask, x, minDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + } + break; + + case 2: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + float32x4_t v1 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + float32x4_t xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v1)); + // the next two lines should resolve to a single vswp d, d + float32x4_t z0 = vcombine_f32(vget_high_f32(v0), vget_high_f32(v1)); + + xy0 = vmulq_f32(xy0, vLo); + + float32x4x2_t zb = vuzpq_f32(z0, z0); + float32x4_t z = vmulq_f32(zb.val[0], vHi); + float32x4x2_t xy = vuzpq_f32(xy0, xy0); + float32x4_t x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + uint32x4_t mask = vcltq_f32(x, minDot); + minDot = vbslq_f32(mask, x, minDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + } + break; + + case 1: + { + float32x4_t v0 = vld1q_f32_aligned_postincrement(vv); + + // the next two lines should resolve to a single vswp d, d + float32x4_t xy0 = vcombine_f32(vget_low_f32(v0), vget_low_f32(v0)); + // the next two lines should resolve to a single vswp d, d + float32x4_t z = vdupq_lane_f32(vget_high_f32(v0), 0); + + xy0 = vmulq_f32(xy0, vLo); + + z = vmulq_f32(z, vHi); + float32x4x2_t xy = vuzpq_f32(xy0, xy0); + float32x4_t x = vaddq_f32(xy.val[0], xy.val[1]); + x = vaddq_f32(x, z); + + uint32x4_t mask = vcltq_f32(x, minDot); + minDot = vbslq_f32(mask, x, minDot); + index = vbslq_u32(mask, local_index, index); + local_index = vaddq_u32(local_index, four); + } + break; + + default: + break; + } + + // select best answer between hi and lo results + uint32x2_t mask = vclt_f32(vget_high_f32(minDot), vget_low_f32(minDot)); + float32x2_t minDot2 = vbsl_f32(mask, vget_high_f32(minDot), vget_low_f32(minDot)); + uint32x2_t index2 = vbsl_u32(mask, vget_high_u32(index), vget_low_u32(index)); + + // select best answer between even and odd results + float32x2_t minDotO = vdup_lane_f32(minDot2, 1); + uint32x2_t indexHi = vdup_lane_u32(index2, 1); + mask = vclt_f32(minDotO, minDot2); + minDot2 = vbsl_f32(mask, minDotO, minDot2); + index2 = vbsl_u32(mask, indexHi, index2); + + *dotResult = vget_lane_f32(minDot2, 0); + return vget_lane_u32(index2, 0); +} + +#else +#error Unhandled __APPLE__ arch +#endif + +#endif /* __APPLE__ */ diff --git a/pkg/mphysics/mbt/LinearMath/btVector3.cpp.i b/pkg/mphysics/mbt/LinearMath/btVector3.cpp.i new file mode 100644 index 00000000..a43396bb --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btVector3.cpp.i @@ -0,0 +1,7 @@ +////// LinearMath/btVector3.cpp ---------------- + +%include "LinearMath/btVector3.cpp" + +%{ +#include "LinearMath/btVector3.cpp" +%} diff --git a/pkg/mphysics/mbt/LinearMath/btVector3.h b/pkg/mphysics/mbt/LinearMath/btVector3.h new file mode 100644 index 00000000..9da16277 --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btVector3.h @@ -0,0 +1,1336 @@ +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_VECTOR3_H +#define BT_VECTOR3_H + +//#include +#include "btScalar.h" +#include "btMinMax.h" +#include "btAlignedAllocator.h" + +#ifdef BT_USE_DOUBLE_PRECISION +#define btVector3Data btVector3DoubleData +#define btVector3DataName "btVector3DoubleData" +#else +#define btVector3Data btVector3FloatData +#define btVector3DataName "btVector3FloatData" +#endif //BT_USE_DOUBLE_PRECISION + +#if defined BT_USE_SSE + +//typedef uint32_t __m128i __attribute__ ((vector_size(16))); + +#ifdef _MSC_VER +#pragma warning(disable : 4556) // value of intrinsic immediate argument '4294967239' is out of range '0 - 255' +#endif + +#define BT_SHUFFLE(x, y, z, w) (((w) << 6 | (z) << 4 | (y) << 2 | (x)) & 0xff) +//#define bt_pshufd_ps( _a, _mask ) (__m128) _mm_shuffle_epi32((__m128i)(_a), (_mask) ) +#define bt_pshufd_ps(_a, _mask) _mm_shuffle_ps((_a), (_a), (_mask)) +#define bt_splat3_ps(_a, _i) bt_pshufd_ps((_a), BT_SHUFFLE(_i, _i, _i, 3)) +#define bt_splat_ps(_a, _i) bt_pshufd_ps((_a), BT_SHUFFLE(_i, _i, _i, _i)) + +#define btv3AbsiMask (_mm_set_epi32(0x00000000, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF)) +#define btvAbsMask (_mm_set_epi32(0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF)) +#define btvFFF0Mask (_mm_set_epi32(0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF)) +#define btv3AbsfMask btCastiTo128f(btv3AbsiMask) +#define btvFFF0fMask btCastiTo128f(btvFFF0Mask) +#define btvxyzMaskf btvFFF0fMask +#define btvAbsfMask btCastiTo128f(btvAbsMask) + +//there is an issue with XCode 3.2 (LCx errors) +#define btvMzeroMask (_mm_set_ps(-0.0f, -0.0f, -0.0f, -0.0f)) +#define v1110 (_mm_set_ps(0.0f, 1.0f, 1.0f, 1.0f)) +#define vHalf (_mm_set_ps(0.5f, 0.5f, 0.5f, 0.5f)) +#define v1_5 (_mm_set_ps(1.5f, 1.5f, 1.5f, 1.5f)) + +//const __m128 ATTRIBUTE_ALIGNED16(btvMzeroMask) = {-0.0f, -0.0f, -0.0f, -0.0f}; +//const __m128 ATTRIBUTE_ALIGNED16(v1110) = {1.0f, 1.0f, 1.0f, 0.0f}; +//const __m128 ATTRIBUTE_ALIGNED16(vHalf) = {0.5f, 0.5f, 0.5f, 0.5f}; +//const __m128 ATTRIBUTE_ALIGNED16(v1_5) = {1.5f, 1.5f, 1.5f, 1.5f}; + +#endif + +#ifdef BT_USE_NEON + +const float32x4_t ATTRIBUTE_ALIGNED16(btvMzeroMask) = (float32x4_t){-0.0f, -0.0f, -0.0f, -0.0f}; +const int32x4_t ATTRIBUTE_ALIGNED16(btvFFF0Mask) = (int32x4_t){static_cast(0xFFFFFFFF), + static_cast(0xFFFFFFFF), static_cast(0xFFFFFFFF), 0x0}; +const int32x4_t ATTRIBUTE_ALIGNED16(btvAbsMask) = (int32x4_t){0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF}; +const int32x4_t ATTRIBUTE_ALIGNED16(btv3AbsMask) = (int32x4_t){0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x0}; + +#endif + +/**@brief btVector3 can be used to represent 3D points and vectors. + * It has an un-used w component to suit 16-byte alignment when btVector3 is stored in containers. This extra component can be used by derived classes (Quaternion?) or by user + * Ideally, this class should be replaced by a platform optimized SIMD version that keeps the data in registers + */ +ATTRIBUTE_ALIGNED16(class) +btVector3 +{ +public: + BT_DECLARE_ALIGNED_ALLOCATOR(); + +#if defined(__SPU__) && defined(__CELLOS_LV2__) + btScalar m_floats[4]; + +public: + SIMD_FORCE_INLINE const vec_float4& get128() const + { + return *((const vec_float4*)&m_floats[0]); + } + +public: +#else //__CELLOS_LV2__ __SPU__ +#if defined(BT_USE_SSE) || defined(BT_USE_NEON) // _WIN32 || ARM + union { + btSimdFloat4 mVec128; + btScalar m_floats[4]; + }; + SIMD_FORCE_INLINE btSimdFloat4 get128() const + { + return mVec128; + } + SIMD_FORCE_INLINE void set128(btSimdFloat4 v128) + { + mVec128 = v128; + } +#else + btScalar m_floats[4]; +#endif +#endif //__CELLOS_LV2__ __SPU__ + +public: + /**@brief No initialization constructor */ + SIMD_FORCE_INLINE btVector3() + { + } + + /**@brief Constructor from scalars + * @param x X value + * @param y Y value + * @param z Z value + */ + SIMD_FORCE_INLINE btVector3(const btScalar& _x, const btScalar& _y, const btScalar& _z) + { + m_floats[0] = _x; + m_floats[1] = _y; + m_floats[2] = _z; + m_floats[3] = btScalar(0.f); + } + +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + // Set Vector + SIMD_FORCE_INLINE btVector3(btSimdFloat4 v) + { + mVec128 = v; + } + + // Copy constructor + SIMD_FORCE_INLINE btVector3(const btVector3& rhs) + { + mVec128 = rhs.mVec128; + } + + // Assignment Operator + SIMD_FORCE_INLINE btVector3& + operator=(const btVector3& v) + { + mVec128 = v.mVec128; + + return *this; + } +#endif // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON) + + /**@brief Add a vector to this one + * @param The vector to add to this one */ + SIMD_FORCE_INLINE btVector3& operator+=(const btVector3& v) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + mVec128 = _mm_add_ps(mVec128, v.mVec128); +#elif defined(BT_USE_NEON) + mVec128 = vaddq_f32(mVec128, v.mVec128); +#else + m_floats[0] += v.m_floats[0]; + m_floats[1] += v.m_floats[1]; + m_floats[2] += v.m_floats[2]; +#endif + return *this; + } + + /**@brief Subtract a vector from this one + * @param The vector to subtract */ + SIMD_FORCE_INLINE btVector3& operator-=(const btVector3& v) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + mVec128 = _mm_sub_ps(mVec128, v.mVec128); +#elif defined(BT_USE_NEON) + mVec128 = vsubq_f32(mVec128, v.mVec128); +#else + m_floats[0] -= v.m_floats[0]; + m_floats[1] -= v.m_floats[1]; + m_floats[2] -= v.m_floats[2]; +#endif + return *this; + } + + /**@brief Scale the vector + * @param s Scale factor */ + SIMD_FORCE_INLINE btVector3& operator*=(const btScalar& s) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vs = _mm_load_ss(&s); // (S 0 0 0) + vs = bt_pshufd_ps(vs, 0x80); // (S S S 0.0) + mVec128 = _mm_mul_ps(mVec128, vs); +#elif defined(BT_USE_NEON) + mVec128 = vmulq_n_f32(mVec128, s); +#else + m_floats[0] *= s; + m_floats[1] *= s; + m_floats[2] *= s; +#endif + return *this; + } + + /**@brief Inversely scale the vector + * @param s Scale factor to divide by */ + SIMD_FORCE_INLINE btVector3& operator/=(const btScalar& s) + { + btFullAssert(s != btScalar(0.0)); + +#if 0 //defined(BT_USE_SSE_IN_API) +// this code is not faster ! + __m128 vs = _mm_load_ss(&s); + vs = _mm_div_ss(v1110, vs); + vs = bt_pshufd_ps(vs, 0x00); // (S S S S) + + mVec128 = _mm_mul_ps(mVec128, vs); + + return *this; +#else + return *this *= btScalar(1.0) / s; +#endif + } + + /**@brief Return the dot product + * @param v The other vector in the dot product */ + SIMD_FORCE_INLINE btScalar dot(const btVector3& v) const + { +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vd = _mm_mul_ps(mVec128, v.mVec128); + __m128 z = _mm_movehl_ps(vd, vd); + __m128 y = _mm_shuffle_ps(vd, vd, 0x55); + vd = _mm_add_ss(vd, y); + vd = _mm_add_ss(vd, z); + return _mm_cvtss_f32(vd); +#elif defined(BT_USE_NEON) + float32x4_t vd = vmulq_f32(mVec128, v.mVec128); + float32x2_t x = vpadd_f32(vget_low_f32(vd), vget_low_f32(vd)); + x = vadd_f32(x, vget_high_f32(vd)); + return vget_lane_f32(x, 0); +#else + return m_floats[0] * v.m_floats[0] + + m_floats[1] * v.m_floats[1] + + m_floats[2] * v.m_floats[2]; +#endif + } + + /**@brief Return the length of the vector squared */ + SIMD_FORCE_INLINE btScalar length2() const + { + return dot(*this); + } + + /**@brief Return the length of the vector */ + SIMD_FORCE_INLINE btScalar length() const + { + return btSqrt(length2()); + } + + /**@brief Return the norm (length) of the vector */ + SIMD_FORCE_INLINE btScalar norm() const + { + return length(); + } + + /**@brief Return the norm (length) of the vector */ + SIMD_FORCE_INLINE btScalar safeNorm() const + { + btScalar d = length2(); + //workaround for some clang/gcc issue of sqrtf(tiny number) = -INF + if (d > SIMD_EPSILON) + return btSqrt(d); + return btScalar(0); + } + + /**@brief Return the distance squared between the ends of this and another vector + * This is symantically treating the vector like a point */ + SIMD_FORCE_INLINE btScalar distance2(const btVector3& v) const; + + /**@brief Return the distance between the ends of this and another vector + * This is symantically treating the vector like a point */ + SIMD_FORCE_INLINE btScalar distance(const btVector3& v) const; + + SIMD_FORCE_INLINE btVector3& safeNormalize() + { + btScalar l2 = length2(); + //triNormal.normalize(); + if (l2 >= SIMD_EPSILON * SIMD_EPSILON) + { + (*this) /= btSqrt(l2); + } + else + { + setValue(1, 0, 0); + } + return *this; + } + + /**@brief Normalize this vector + * x^2 + y^2 + z^2 = 1 */ + SIMD_FORCE_INLINE btVector3& normalize() + { + btAssert(!fuzzyZero()); + +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + // dot product first + __m128 vd = _mm_mul_ps(mVec128, mVec128); + __m128 z = _mm_movehl_ps(vd, vd); + __m128 y = _mm_shuffle_ps(vd, vd, 0x55); + vd = _mm_add_ss(vd, y); + vd = _mm_add_ss(vd, z); + +#if 0 + vd = _mm_sqrt_ss(vd); + vd = _mm_div_ss(v1110, vd); + vd = bt_splat_ps(vd, 0x80); + mVec128 = _mm_mul_ps(mVec128, vd); +#else + + // NR step 1/sqrt(x) - vd is x, y is output + y = _mm_rsqrt_ss(vd); // estimate + + // one step NR + z = v1_5; + vd = _mm_mul_ss(vd, vHalf); // vd * 0.5 + //x2 = vd; + vd = _mm_mul_ss(vd, y); // vd * 0.5 * y0 + vd = _mm_mul_ss(vd, y); // vd * 0.5 * y0 * y0 + z = _mm_sub_ss(z, vd); // 1.5 - vd * 0.5 * y0 * y0 + + y = _mm_mul_ss(y, z); // y0 * (1.5 - vd * 0.5 * y0 * y0) + + y = bt_splat_ps(y, 0x80); + mVec128 = _mm_mul_ps(mVec128, y); + +#endif + + return *this; +#else + return *this /= length(); +#endif + } + + /**@brief Return a normalized version of this vector */ + SIMD_FORCE_INLINE btVector3 normalized() const; + + /**@brief Return a rotated version of this vector + * @param wAxis The axis to rotate about + * @param angle The angle to rotate by */ + SIMD_FORCE_INLINE btVector3 rotate(const btVector3& wAxis, const btScalar angle) const; + + /**@brief Return the angle between this and another vector + * @param v The other vector */ + SIMD_FORCE_INLINE btScalar angle(const btVector3& v) const + { + btScalar s = btSqrt(length2() * v.length2()); + btFullAssert(s != btScalar(0.0)); + return btAcos(dot(v) / s); + } + + /**@brief Return a vector with the absolute values of each element */ + SIMD_FORCE_INLINE btVector3 absolute() const + { +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + return btVector3(_mm_and_ps(mVec128, btv3AbsfMask)); +#elif defined(BT_USE_NEON) + return btVector3(vabsq_f32(mVec128)); +#else + return btVector3( + btFabs(m_floats[0]), + btFabs(m_floats[1]), + btFabs(m_floats[2])); +#endif + } + + /**@brief Return the cross product between this and another vector + * @param v The other vector */ + SIMD_FORCE_INLINE btVector3 cross(const btVector3& v) const + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 T, V; + + T = bt_pshufd_ps(mVec128, BT_SHUFFLE(1, 2, 0, 3)); // (Y Z X 0) + V = bt_pshufd_ps(v.mVec128, BT_SHUFFLE(1, 2, 0, 3)); // (Y Z X 0) + + V = _mm_mul_ps(V, mVec128); + T = _mm_mul_ps(T, v.mVec128); + V = _mm_sub_ps(V, T); + + V = bt_pshufd_ps(V, BT_SHUFFLE(1, 2, 0, 3)); + return btVector3(V); +#elif defined(BT_USE_NEON) + float32x4_t T, V; + // form (Y, Z, X, _) of mVec128 and v.mVec128 + float32x2_t Tlow = vget_low_f32(mVec128); + float32x2_t Vlow = vget_low_f32(v.mVec128); + T = vcombine_f32(vext_f32(Tlow, vget_high_f32(mVec128), 1), Tlow); + V = vcombine_f32(vext_f32(Vlow, vget_high_f32(v.mVec128), 1), Vlow); + + V = vmulq_f32(V, mVec128); + T = vmulq_f32(T, v.mVec128); + V = vsubq_f32(V, T); + Vlow = vget_low_f32(V); + // form (Y, Z, X, _); + V = vcombine_f32(vext_f32(Vlow, vget_high_f32(V), 1), Vlow); + V = (float32x4_t)vandq_s32((int32x4_t)V, btvFFF0Mask); + + return btVector3(V); +#else + return btVector3( + m_floats[1] * v.m_floats[2] - m_floats[2] * v.m_floats[1], + m_floats[2] * v.m_floats[0] - m_floats[0] * v.m_floats[2], + m_floats[0] * v.m_floats[1] - m_floats[1] * v.m_floats[0]); +#endif + } + + SIMD_FORCE_INLINE btScalar triple(const btVector3& v1, const btVector3& v2) const + { +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + // cross: + __m128 T = _mm_shuffle_ps(v1.mVec128, v1.mVec128, BT_SHUFFLE(1, 2, 0, 3)); // (Y Z X 0) + __m128 V = _mm_shuffle_ps(v2.mVec128, v2.mVec128, BT_SHUFFLE(1, 2, 0, 3)); // (Y Z X 0) + + V = _mm_mul_ps(V, v1.mVec128); + T = _mm_mul_ps(T, v2.mVec128); + V = _mm_sub_ps(V, T); + + V = _mm_shuffle_ps(V, V, BT_SHUFFLE(1, 2, 0, 3)); + + // dot: + V = _mm_mul_ps(V, mVec128); + __m128 z = _mm_movehl_ps(V, V); + __m128 y = _mm_shuffle_ps(V, V, 0x55); + V = _mm_add_ss(V, y); + V = _mm_add_ss(V, z); + return _mm_cvtss_f32(V); + +#elif defined(BT_USE_NEON) + // cross: + float32x4_t T, V; + // form (Y, Z, X, _) of mVec128 and v.mVec128 + float32x2_t Tlow = vget_low_f32(v1.mVec128); + float32x2_t Vlow = vget_low_f32(v2.mVec128); + T = vcombine_f32(vext_f32(Tlow, vget_high_f32(v1.mVec128), 1), Tlow); + V = vcombine_f32(vext_f32(Vlow, vget_high_f32(v2.mVec128), 1), Vlow); + + V = vmulq_f32(V, v1.mVec128); + T = vmulq_f32(T, v2.mVec128); + V = vsubq_f32(V, T); + Vlow = vget_low_f32(V); + // form (Y, Z, X, _); + V = vcombine_f32(vext_f32(Vlow, vget_high_f32(V), 1), Vlow); + + // dot: + V = vmulq_f32(mVec128, V); + float32x2_t x = vpadd_f32(vget_low_f32(V), vget_low_f32(V)); + x = vadd_f32(x, vget_high_f32(V)); + return vget_lane_f32(x, 0); +#else + return m_floats[0] * (v1.m_floats[1] * v2.m_floats[2] - v1.m_floats[2] * v2.m_floats[1]) + + m_floats[1] * (v1.m_floats[2] * v2.m_floats[0] - v1.m_floats[0] * v2.m_floats[2]) + + m_floats[2] * (v1.m_floats[0] * v2.m_floats[1] - v1.m_floats[1] * v2.m_floats[0]); +#endif + } + + /**@brief Return the axis with the smallest value + * Note return values are 0,1,2 for x, y, or z */ + SIMD_FORCE_INLINE int minAxis() const + { + return m_floats[0] < m_floats[1] ? (m_floats[0] < m_floats[2] ? 0 : 2) : (m_floats[1] < m_floats[2] ? 1 : 2); + } + + /**@brief Return the axis with the largest value + * Note return values are 0,1,2 for x, y, or z */ + SIMD_FORCE_INLINE int maxAxis() const + { + return m_floats[0] < m_floats[1] ? (m_floats[1] < m_floats[2] ? 2 : 1) : (m_floats[0] < m_floats[2] ? 2 : 0); + } + + SIMD_FORCE_INLINE int furthestAxis() const + { + return absolute().minAxis(); + } + + SIMD_FORCE_INLINE int closestAxis() const + { + return absolute().maxAxis(); + } + + SIMD_FORCE_INLINE void setInterpolate3(const btVector3& v0, const btVector3& v1, btScalar rt) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vrt = _mm_load_ss(&rt); // (rt 0 0 0) + btScalar s = btScalar(1.0) - rt; + __m128 vs = _mm_load_ss(&s); // (S 0 0 0) + vs = bt_pshufd_ps(vs, 0x80); // (S S S 0.0) + __m128 r0 = _mm_mul_ps(v0.mVec128, vs); + vrt = bt_pshufd_ps(vrt, 0x80); // (rt rt rt 0.0) + __m128 r1 = _mm_mul_ps(v1.mVec128, vrt); + __m128 tmp3 = _mm_add_ps(r0, r1); + mVec128 = tmp3; +#elif defined(BT_USE_NEON) + float32x4_t vl = vsubq_f32(v1.mVec128, v0.mVec128); + vl = vmulq_n_f32(vl, rt); + mVec128 = vaddq_f32(vl, v0.mVec128); +#else + btScalar s = btScalar(1.0) - rt; + m_floats[0] = s * v0.m_floats[0] + rt * v1.m_floats[0]; + m_floats[1] = s * v0.m_floats[1] + rt * v1.m_floats[1]; + m_floats[2] = s * v0.m_floats[2] + rt * v1.m_floats[2]; + //don't do the unused w component + // m_co[3] = s * v0[3] + rt * v1[3]; +#endif + } + + /**@brief Return the linear interpolation between this and another vector + * @param v The other vector + * @param t The ration of this to v (t = 0 => return this, t=1 => return other) */ + SIMD_FORCE_INLINE btVector3 lerp(const btVector3& v, const btScalar& t) const + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vt = _mm_load_ss(&t); // (t 0 0 0) + vt = bt_pshufd_ps(vt, 0x80); // (rt rt rt 0.0) + __m128 vl = _mm_sub_ps(v.mVec128, mVec128); + vl = _mm_mul_ps(vl, vt); + vl = _mm_add_ps(vl, mVec128); + + return btVector3(vl); +#elif defined(BT_USE_NEON) + float32x4_t vl = vsubq_f32(v.mVec128, mVec128); + vl = vmulq_n_f32(vl, t); + vl = vaddq_f32(vl, mVec128); + + return btVector3(vl); +#else + return btVector3(m_floats[0] + (v.m_floats[0] - m_floats[0]) * t, + m_floats[1] + (v.m_floats[1] - m_floats[1]) * t, + m_floats[2] + (v.m_floats[2] - m_floats[2]) * t); +#endif + } + + /**@brief Elementwise multiply this vector by the other + * @param v The other vector */ + SIMD_FORCE_INLINE btVector3& operator*=(const btVector3& v) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + mVec128 = _mm_mul_ps(mVec128, v.mVec128); +#elif defined(BT_USE_NEON) + mVec128 = vmulq_f32(mVec128, v.mVec128); +#else + m_floats[0] *= v.m_floats[0]; + m_floats[1] *= v.m_floats[1]; + m_floats[2] *= v.m_floats[2]; +#endif + return *this; + } + + /**@brief Return the x value */ + SIMD_FORCE_INLINE const btScalar& getX() const { return m_floats[0]; } + /**@brief Return the y value */ + SIMD_FORCE_INLINE const btScalar& getY() const { return m_floats[1]; } + /**@brief Return the z value */ + SIMD_FORCE_INLINE const btScalar& getZ() const { return m_floats[2]; } + /**@brief Set the x value */ + SIMD_FORCE_INLINE void setX(btScalar _x) { m_floats[0] = _x; }; + /**@brief Set the y value */ + SIMD_FORCE_INLINE void setY(btScalar _y) { m_floats[1] = _y; }; + /**@brief Set the z value */ + SIMD_FORCE_INLINE void setZ(btScalar _z) { m_floats[2] = _z; }; + /**@brief Set the w value */ + SIMD_FORCE_INLINE void setW(btScalar _w) { m_floats[3] = _w; }; + /**@brief Return the x value */ + SIMD_FORCE_INLINE const btScalar& x() const { return m_floats[0]; } + /**@brief Return the y value */ + SIMD_FORCE_INLINE const btScalar& y() const { return m_floats[1]; } + /**@brief Return the z value */ + SIMD_FORCE_INLINE const btScalar& z() const { return m_floats[2]; } + /**@brief Return the w value */ + SIMD_FORCE_INLINE const btScalar& w() const { return m_floats[3]; } + + //SIMD_FORCE_INLINE btScalar& operator[](int i) { return (&m_floats[0])[i]; } + //SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; } + ///operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons. + SIMD_FORCE_INLINE operator btScalar*() { return &m_floats[0]; } + SIMD_FORCE_INLINE operator const btScalar*() const { return &m_floats[0]; } + + SIMD_FORCE_INLINE bool operator==(const btVector3& other) const + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + return (0xf == _mm_movemask_ps((__m128)_mm_cmpeq_ps(mVec128, other.mVec128))); +#else + return ((m_floats[3] == other.m_floats[3]) && + (m_floats[2] == other.m_floats[2]) && + (m_floats[1] == other.m_floats[1]) && + (m_floats[0] == other.m_floats[0])); +#endif + } + + SIMD_FORCE_INLINE bool operator!=(const btVector3& other) const + { + return !(*this == other); + } + + /**@brief Set each element to the max of the current values and the values of another btVector3 + * @param other The other btVector3 to compare with + */ + SIMD_FORCE_INLINE void setMax(const btVector3& other) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + mVec128 = _mm_max_ps(mVec128, other.mVec128); +#elif defined(BT_USE_NEON) + mVec128 = vmaxq_f32(mVec128, other.mVec128); +#else + btSetMax(m_floats[0], other.m_floats[0]); + btSetMax(m_floats[1], other.m_floats[1]); + btSetMax(m_floats[2], other.m_floats[2]); + btSetMax(m_floats[3], other.w()); +#endif + } + + /**@brief Set each element to the min of the current values and the values of another btVector3 + * @param other The other btVector3 to compare with + */ + SIMD_FORCE_INLINE void setMin(const btVector3& other) + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + mVec128 = _mm_min_ps(mVec128, other.mVec128); +#elif defined(BT_USE_NEON) + mVec128 = vminq_f32(mVec128, other.mVec128); +#else + btSetMin(m_floats[0], other.m_floats[0]); + btSetMin(m_floats[1], other.m_floats[1]); + btSetMin(m_floats[2], other.m_floats[2]); + btSetMin(m_floats[3], other.w()); +#endif + } + + SIMD_FORCE_INLINE void setValue(const btScalar& _x, const btScalar& _y, const btScalar& _z) + { + m_floats[0] = _x; + m_floats[1] = _y; + m_floats[2] = _z; + m_floats[3] = btScalar(0.f); + } + + void getSkewSymmetricMatrix(btVector3 * v0, btVector3 * v1, btVector3 * v2) const + { +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + + __m128 V = _mm_and_ps(mVec128, btvFFF0fMask); + __m128 V0 = _mm_xor_ps(btvMzeroMask, V); + __m128 V2 = _mm_movelh_ps(V0, V); + + __m128 V1 = _mm_shuffle_ps(V, V0, 0xCE); + + V0 = _mm_shuffle_ps(V0, V, 0xDB); + V2 = _mm_shuffle_ps(V2, V, 0xF9); + + v0->mVec128 = V0; + v1->mVec128 = V1; + v2->mVec128 = V2; +#else + v0->setValue(0., -z(), y()); + v1->setValue(z(), 0., -x()); + v2->setValue(-y(), x(), 0.); +#endif + } + + void setZero() + { +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + mVec128 = (__m128)_mm_xor_ps(mVec128, mVec128); +#elif defined(BT_USE_NEON) + int32x4_t vi = vdupq_n_s32(0); + mVec128 = vreinterpretq_f32_s32(vi); +#else + setValue(btScalar(0.), btScalar(0.), btScalar(0.)); +#endif + } + + SIMD_FORCE_INLINE bool isZero() const + { + return m_floats[0] == btScalar(0) && m_floats[1] == btScalar(0) && m_floats[2] == btScalar(0); + } + + SIMD_FORCE_INLINE bool fuzzyZero() const + { + return length2() < SIMD_EPSILON * SIMD_EPSILON; + } + + SIMD_FORCE_INLINE void serialize(struct btVector3Data & dataOut) const; + + SIMD_FORCE_INLINE void deSerialize(const struct btVector3DoubleData& dataIn); + + SIMD_FORCE_INLINE void deSerialize(const struct btVector3FloatData& dataIn); + + SIMD_FORCE_INLINE void serializeFloat(struct btVector3FloatData & dataOut) const; + + SIMD_FORCE_INLINE void deSerializeFloat(const struct btVector3FloatData& dataIn); + + SIMD_FORCE_INLINE void serializeDouble(struct btVector3DoubleData & dataOut) const; + + SIMD_FORCE_INLINE void deSerializeDouble(const struct btVector3DoubleData& dataIn); + + /**@brief returns index of maximum dot product between this and vectors in array[] + * @param array The other vectors + * @param array_count The number of other vectors + * @param dotOut The maximum dot product */ + SIMD_FORCE_INLINE long maxDot(const btVector3* array, long array_count, btScalar& dotOut) const; + + /**@brief returns index of minimum dot product between this and vectors in array[] + * @param array The other vectors + * @param array_count The number of other vectors + * @param dotOut The minimum dot product */ + SIMD_FORCE_INLINE long minDot(const btVector3* array, long array_count, btScalar& dotOut) const; + + /* create a vector as btVector3( this->dot( btVector3 v0 ), this->dot( btVector3 v1), this->dot( btVector3 v2 )) */ + SIMD_FORCE_INLINE btVector3 dot3(const btVector3& v0, const btVector3& v1, const btVector3& v2) const + { +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + + __m128 a0 = _mm_mul_ps(v0.mVec128, this->mVec128); + __m128 a1 = _mm_mul_ps(v1.mVec128, this->mVec128); + __m128 a2 = _mm_mul_ps(v2.mVec128, this->mVec128); + __m128 b0 = _mm_unpacklo_ps(a0, a1); + __m128 b1 = _mm_unpackhi_ps(a0, a1); + __m128 b2 = _mm_unpacklo_ps(a2, _mm_setzero_ps()); + __m128 r = _mm_movelh_ps(b0, b2); + r = _mm_add_ps(r, _mm_movehl_ps(b2, b0)); + a2 = _mm_and_ps(a2, btvxyzMaskf); + r = _mm_add_ps(r, btCastdTo128f(_mm_move_sd(btCastfTo128d(a2), btCastfTo128d(b1)))); + return btVector3(r); + +#elif defined(BT_USE_NEON) + static const uint32x4_t xyzMask = (const uint32x4_t){static_cast(-1), static_cast(-1), static_cast(-1), 0}; + float32x4_t a0 = vmulq_f32(v0.mVec128, this->mVec128); + float32x4_t a1 = vmulq_f32(v1.mVec128, this->mVec128); + float32x4_t a2 = vmulq_f32(v2.mVec128, this->mVec128); + float32x2x2_t zLo = vtrn_f32(vget_high_f32(a0), vget_high_f32(a1)); + a2 = (float32x4_t)vandq_u32((uint32x4_t)a2, xyzMask); + float32x2_t b0 = vadd_f32(vpadd_f32(vget_low_f32(a0), vget_low_f32(a1)), zLo.val[0]); + float32x2_t b1 = vpadd_f32(vpadd_f32(vget_low_f32(a2), vget_high_f32(a2)), vdup_n_f32(0.0f)); + return btVector3(vcombine_f32(b0, b1)); +#else + return btVector3(dot(v0), dot(v1), dot(v2)); +#endif + } +}; + +/**@brief Return the sum of two vectors (Point symantics)*/ +SIMD_FORCE_INLINE btVector3 +operator+(const btVector3& v1, const btVector3& v2) +{ +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + return btVector3(_mm_add_ps(v1.mVec128, v2.mVec128)); +#elif defined(BT_USE_NEON) + return btVector3(vaddq_f32(v1.mVec128, v2.mVec128)); +#else + return btVector3( + v1.m_floats[0] + v2.m_floats[0], + v1.m_floats[1] + v2.m_floats[1], + v1.m_floats[2] + v2.m_floats[2]); +#endif +} + +/**@brief Return the elementwise product of two vectors */ +SIMD_FORCE_INLINE btVector3 +operator*(const btVector3& v1, const btVector3& v2) +{ +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + return btVector3(_mm_mul_ps(v1.mVec128, v2.mVec128)); +#elif defined(BT_USE_NEON) + return btVector3(vmulq_f32(v1.mVec128, v2.mVec128)); +#else + return btVector3( + v1.m_floats[0] * v2.m_floats[0], + v1.m_floats[1] * v2.m_floats[1], + v1.m_floats[2] * v2.m_floats[2]); +#endif +} + +/**@brief Return the difference between two vectors */ +SIMD_FORCE_INLINE btVector3 +operator-(const btVector3& v1, const btVector3& v2) +{ +#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + + // without _mm_and_ps this code causes slowdown in Concave moving + __m128 r = _mm_sub_ps(v1.mVec128, v2.mVec128); + return btVector3(_mm_and_ps(r, btvFFF0fMask)); +#elif defined(BT_USE_NEON) + float32x4_t r = vsubq_f32(v1.mVec128, v2.mVec128); + return btVector3((float32x4_t)vandq_s32((int32x4_t)r, btvFFF0Mask)); +#else + return btVector3( + v1.m_floats[0] - v2.m_floats[0], + v1.m_floats[1] - v2.m_floats[1], + v1.m_floats[2] - v2.m_floats[2]); +#endif +} + +/**@brief Return the negative of the vector */ +SIMD_FORCE_INLINE btVector3 +operator-(const btVector3& v) +{ +#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + __m128 r = _mm_xor_ps(v.mVec128, btvMzeroMask); + return btVector3(_mm_and_ps(r, btvFFF0fMask)); +#elif defined(BT_USE_NEON) + return btVector3((btSimdFloat4)veorq_s32((int32x4_t)v.mVec128, (int32x4_t)btvMzeroMask)); +#else + return btVector3(-v.m_floats[0], -v.m_floats[1], -v.m_floats[2]); +#endif +} + +/**@brief Return the vector scaled by s */ +SIMD_FORCE_INLINE btVector3 +operator*(const btVector3& v, const btScalar& s) +{ +#if defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + __m128 vs = _mm_load_ss(&s); // (S 0 0 0) + vs = bt_pshufd_ps(vs, 0x80); // (S S S 0.0) + return btVector3(_mm_mul_ps(v.mVec128, vs)); +#elif defined(BT_USE_NEON) + float32x4_t r = vmulq_n_f32(v.mVec128, s); + return btVector3((float32x4_t)vandq_s32((int32x4_t)r, btvFFF0Mask)); +#else + return btVector3(v.m_floats[0] * s, v.m_floats[1] * s, v.m_floats[2] * s); +#endif +} + +/**@brief Return the vector scaled by s */ +SIMD_FORCE_INLINE btVector3 +operator*(const btScalar& s, const btVector3& v) +{ + return v * s; +} + +/**@brief Return the vector inversely scaled by s */ +SIMD_FORCE_INLINE btVector3 +operator/(const btVector3& v, const btScalar& s) +{ + btFullAssert(s != btScalar(0.0)); +#if 0 //defined(BT_USE_SSE_IN_API) +// this code is not faster ! + __m128 vs = _mm_load_ss(&s); + vs = _mm_div_ss(v1110, vs); + vs = bt_pshufd_ps(vs, 0x00); // (S S S S) + + return btVector3(_mm_mul_ps(v.mVec128, vs)); +#else + return v * (btScalar(1.0) / s); +#endif +} + +/**@brief Return the vector inversely scaled by s */ +SIMD_FORCE_INLINE btVector3 +operator/(const btVector3& v1, const btVector3& v2) +{ +#if defined BT_USE_SIMD_VECTOR3 && (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) + __m128 vec = _mm_div_ps(v1.mVec128, v2.mVec128); + vec = _mm_and_ps(vec, btvFFF0fMask); + return btVector3(vec); +#elif defined(BT_USE_NEON) + float32x4_t x, y, v, m; + + x = v1.mVec128; + y = v2.mVec128; + + v = vrecpeq_f32(y); // v ~ 1/y + m = vrecpsq_f32(y, v); // m = (2-v*y) + v = vmulq_f32(v, m); // vv = v*m ~~ 1/y + m = vrecpsq_f32(y, v); // mm = (2-vv*y) + v = vmulq_f32(v, x); // x*vv + v = vmulq_f32(v, m); // (x*vv)*(2-vv*y) = x*(vv(2-vv*y)) ~~~ x/y + + return btVector3(v); +#else + return btVector3( + v1.m_floats[0] / v2.m_floats[0], + v1.m_floats[1] / v2.m_floats[1], + v1.m_floats[2] / v2.m_floats[2]); +#endif +} + +/**@brief Return the dot product between two vectors */ +SIMD_FORCE_INLINE btScalar +btDot(const btVector3& v1, const btVector3& v2) +{ + return v1.dot(v2); +} + +/**@brief Return the distance squared between two vectors */ +SIMD_FORCE_INLINE btScalar +btDistance2(const btVector3& v1, const btVector3& v2) +{ + return v1.distance2(v2); +} + +/**@brief Return the distance between two vectors */ +SIMD_FORCE_INLINE btScalar +btDistance(const btVector3& v1, const btVector3& v2) +{ + return v1.distance(v2); +} + +/**@brief Return the angle between two vectors */ +SIMD_FORCE_INLINE btScalar +btAngle(const btVector3& v1, const btVector3& v2) +{ + return v1.angle(v2); +} + +/**@brief Return the cross product of two vectors */ +SIMD_FORCE_INLINE btVector3 +btCross(const btVector3& v1, const btVector3& v2) +{ + return v1.cross(v2); +} + +SIMD_FORCE_INLINE btScalar +btTriple(const btVector3& v1, const btVector3& v2, const btVector3& v3) +{ + return v1.triple(v2, v3); +} + +/**@brief Return the linear interpolation between two vectors + * @param v1 One vector + * @param v2 The other vector + * @param t The ration of this to v (t = 0 => return v1, t=1 => return v2) */ +SIMD_FORCE_INLINE btVector3 +lerp(const btVector3& v1, const btVector3& v2, const btScalar& t) +{ + return v1.lerp(v2, t); +} + +SIMD_FORCE_INLINE btScalar btVector3::distance2(const btVector3& v) const +{ + return (v - *this).length2(); +} + +SIMD_FORCE_INLINE btScalar btVector3::distance(const btVector3& v) const +{ + return (v - *this).length(); +} + +SIMD_FORCE_INLINE btVector3 btVector3::normalized() const +{ + btVector3 nrm = *this; + + return nrm.normalize(); +} + +SIMD_FORCE_INLINE btVector3 btVector3::rotate(const btVector3& wAxis, const btScalar _angle) const +{ + // wAxis must be a unit lenght vector + +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + + __m128 O = _mm_mul_ps(wAxis.mVec128, mVec128); + btScalar ssin = btSin(_angle); + __m128 C = wAxis.cross(mVec128).mVec128; + O = _mm_and_ps(O, btvFFF0fMask); + btScalar scos = btCos(_angle); + + __m128 vsin = _mm_load_ss(&ssin); // (S 0 0 0) + __m128 vcos = _mm_load_ss(&scos); // (S 0 0 0) + + __m128 Y = bt_pshufd_ps(O, 0xC9); // (Y Z X 0) + __m128 Z = bt_pshufd_ps(O, 0xD2); // (Z X Y 0) + O = _mm_add_ps(O, Y); + vsin = bt_pshufd_ps(vsin, 0x80); // (S S S 0) + O = _mm_add_ps(O, Z); + vcos = bt_pshufd_ps(vcos, 0x80); // (S S S 0) + + vsin = vsin * C; + O = O * wAxis.mVec128; + __m128 X = mVec128 - O; + + O = O + vsin; + vcos = vcos * X; + O = O + vcos; + + return btVector3(O); +#else + btVector3 o = wAxis * wAxis.dot(*this); + btVector3 _x = *this - o; + btVector3 _y; + + _y = wAxis.cross(*this); + + return (o + _x * btCos(_angle) + _y * btSin(_angle)); +#endif +} + +SIMD_FORCE_INLINE long btVector3::maxDot(const btVector3* array, long array_count, btScalar& dotOut) const +{ +#if (defined BT_USE_SSE && defined BT_USE_SIMD_VECTOR3 && defined BT_USE_SSE_IN_API) || defined(BT_USE_NEON) +#if defined _WIN32 || defined(BT_USE_SSE) + const long scalar_cutoff = 10; + long _maxdot_large(const float* array, const float* vec, unsigned long array_count, float* dotOut); +#elif defined BT_USE_NEON + const long scalar_cutoff = 4; + extern long (*_maxdot_large)(const float* array, const float* vec, unsigned long array_count, float* dotOut); +#endif + if (array_count < scalar_cutoff) +#endif + { + btScalar maxDot1 = -SIMD_INFINITY; + int i = 0; + int ptIndex = -1; + for (i = 0; i < array_count; i++) + { + btScalar dot = array[i].dot(*this); + + if (dot > maxDot1) + { + maxDot1 = dot; + ptIndex = i; + } + } + + dotOut = maxDot1; + return ptIndex; + } +#if (defined BT_USE_SSE && defined BT_USE_SIMD_VECTOR3 && defined BT_USE_SSE_IN_API) || defined(BT_USE_NEON) + return _maxdot_large((float*)array, (float*)&m_floats[0], array_count, &dotOut); +#endif +} + +SIMD_FORCE_INLINE long btVector3::minDot(const btVector3* array, long array_count, btScalar& dotOut) const +{ +#if (defined BT_USE_SSE && defined BT_USE_SIMD_VECTOR3 && defined BT_USE_SSE_IN_API) || defined(BT_USE_NEON) +#if defined BT_USE_SSE + const long scalar_cutoff = 10; + long _mindot_large(const float* array, const float* vec, unsigned long array_count, float* dotOut); +#elif defined BT_USE_NEON + const long scalar_cutoff = 4; + extern long (*_mindot_large)(const float* array, const float* vec, unsigned long array_count, float* dotOut); +#else +#error unhandled arch! +#endif + + if (array_count < scalar_cutoff) +#endif + { + btScalar minDot = SIMD_INFINITY; + int i = 0; + int ptIndex = -1; + + for (i = 0; i < array_count; i++) + { + btScalar dot = array[i].dot(*this); + + if (dot < minDot) + { + minDot = dot; + ptIndex = i; + } + } + + dotOut = minDot; + + return ptIndex; + } +#if (defined BT_USE_SSE && defined BT_USE_SIMD_VECTOR3 && defined BT_USE_SSE_IN_API) || defined(BT_USE_NEON) + return _mindot_large((float*)array, (float*)&m_floats[0], array_count, &dotOut); +#endif //BT_USE_SIMD_VECTOR3 +} + +class btVector4 : public btVector3 +{ +public: + SIMD_FORCE_INLINE btVector4() {} + + SIMD_FORCE_INLINE btVector4(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w) + : btVector3(_x, _y, _z) + { + m_floats[3] = _w; + } + +#if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + SIMD_FORCE_INLINE btVector4(const btSimdFloat4 vec) + { + mVec128 = vec; + } + + SIMD_FORCE_INLINE btVector4(const btVector3& rhs) + { + mVec128 = rhs.mVec128; + } + + SIMD_FORCE_INLINE btVector4& + operator=(const btVector4& v) + { + mVec128 = v.mVec128; + return *this; + } +#endif // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON) + + SIMD_FORCE_INLINE btVector4 absolute4() const + { +#if defined BT_USE_SIMD_VECTOR3 && defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE) + return btVector4(_mm_and_ps(mVec128, btvAbsfMask)); +#elif defined(BT_USE_NEON) + return btVector4(vabsq_f32(mVec128)); +#else + return btVector4( + btFabs(m_floats[0]), + btFabs(m_floats[1]), + btFabs(m_floats[2]), + btFabs(m_floats[3])); +#endif + } + + btScalar getW() const { return m_floats[3]; } + + SIMD_FORCE_INLINE int maxAxis4() const + { + int maxIndex = -1; + btScalar maxVal = btScalar(-BT_LARGE_FLOAT); + if (m_floats[0] > maxVal) + { + maxIndex = 0; + maxVal = m_floats[0]; + } + if (m_floats[1] > maxVal) + { + maxIndex = 1; + maxVal = m_floats[1]; + } + if (m_floats[2] > maxVal) + { + maxIndex = 2; + maxVal = m_floats[2]; + } + if (m_floats[3] > maxVal) + { + maxIndex = 3; + } + + return maxIndex; + } + + SIMD_FORCE_INLINE int minAxis4() const + { + int minIndex = -1; + btScalar minVal = btScalar(BT_LARGE_FLOAT); + if (m_floats[0] < minVal) + { + minIndex = 0; + minVal = m_floats[0]; + } + if (m_floats[1] < minVal) + { + minIndex = 1; + minVal = m_floats[1]; + } + if (m_floats[2] < minVal) + { + minIndex = 2; + minVal = m_floats[2]; + } + if (m_floats[3] < minVal) + { + minIndex = 3; + } + + return minIndex; + } + + SIMD_FORCE_INLINE int closestAxis4() const + { + return absolute4().maxAxis4(); + } + + /**@brief Set x,y,z and zero w + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + + /* void getValue(btScalar *m) const + { + m[0] = m_floats[0]; + m[1] = m_floats[1]; + m[2] =m_floats[2]; + } +*/ + /**@brief Set the values + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + SIMD_FORCE_INLINE void setValue(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w) + { + m_floats[0] = _x; + m_floats[1] = _y; + m_floats[2] = _z; + m_floats[3] = _w; + } +}; + +///btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization +SIMD_FORCE_INLINE void btSwapScalarEndian(const btScalar& sourceVal, btScalar& destVal) +{ +#ifdef BT_USE_DOUBLE_PRECISION + unsigned char* dest = (unsigned char*)&destVal; + const unsigned char* src = (const unsigned char*)&sourceVal; + dest[0] = src[7]; + dest[1] = src[6]; + dest[2] = src[5]; + dest[3] = src[4]; + dest[4] = src[3]; + dest[5] = src[2]; + dest[6] = src[1]; + dest[7] = src[0]; +#else + unsigned char* dest = (unsigned char*)&destVal; + const unsigned char* src = (const unsigned char*)&sourceVal; + dest[0] = src[3]; + dest[1] = src[2]; + dest[2] = src[1]; + dest[3] = src[0]; +#endif //BT_USE_DOUBLE_PRECISION +} +///btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization +SIMD_FORCE_INLINE void btSwapVector3Endian(const btVector3& sourceVec, btVector3& destVec) +{ + for (int i = 0; i < 4; i++) + { + btSwapScalarEndian(sourceVec[i], destVec[i]); + } +} + +///btUnSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization +SIMD_FORCE_INLINE void btUnSwapVector3Endian(btVector3& vector) +{ + btVector3 swappedVec; + for (int i = 0; i < 4; i++) + { + btSwapScalarEndian(vector[i], swappedVec[i]); + } + vector = swappedVec; +} + +template +SIMD_FORCE_INLINE void btPlaneSpace1(const T& n, T& p, T& q) +{ + if (btFabs(n[2]) > SIMDSQRT12) + { + // choose p in y-z plane + btScalar a = n[1] * n[1] + n[2] * n[2]; + btScalar k = btRecipSqrt(a); + p[0] = 0; + p[1] = -n[2] * k; + p[2] = n[1] * k; + // set q = n x p + q[0] = a * k; + q[1] = -n[0] * p[2]; + q[2] = n[0] * p[1]; + } + else + { + // choose p in x-y plane + btScalar a = n[0] * n[0] + n[1] * n[1]; + btScalar k = btRecipSqrt(a); + p[0] = -n[1] * k; + p[1] = n[0] * k; + p[2] = 0; + // set q = n x p + q[0] = -n[2] * p[1]; + q[1] = n[2] * p[0]; + q[2] = a * k; + } +} + +struct btVector3FloatData +{ + float m_floats[4]; +}; + +struct btVector3DoubleData +{ + double m_floats[4]; +}; + +SIMD_FORCE_INLINE void btVector3::serializeFloat(struct btVector3FloatData& dataOut) const +{ + ///could also do a memcpy, check if it is worth it + for (int i = 0; i < 4; i++) + dataOut.m_floats[i] = float(m_floats[i]); +} + +SIMD_FORCE_INLINE void btVector3::deSerializeFloat(const struct btVector3FloatData& dataIn) +{ + for (int i = 0; i < 4; i++) + m_floats[i] = btScalar(dataIn.m_floats[i]); +} + +SIMD_FORCE_INLINE void btVector3::serializeDouble(struct btVector3DoubleData& dataOut) const +{ + ///could also do a memcpy, check if it is worth it + for (int i = 0; i < 4; i++) + dataOut.m_floats[i] = double(m_floats[i]); +} + +SIMD_FORCE_INLINE void btVector3::deSerializeDouble(const struct btVector3DoubleData& dataIn) +{ + for (int i = 0; i < 4; i++) + m_floats[i] = btScalar(dataIn.m_floats[i]); +} + +SIMD_FORCE_INLINE void btVector3::serialize(struct btVector3Data& dataOut) const +{ + ///could also do a memcpy, check if it is worth it + for (int i = 0; i < 4; i++) + dataOut.m_floats[i] = m_floats[i]; +} + +SIMD_FORCE_INLINE void btVector3::deSerialize(const struct btVector3FloatData& dataIn) +{ + for (int i = 0; i < 4; i++) + m_floats[i] = (btScalar)dataIn.m_floats[i]; +} + +SIMD_FORCE_INLINE void btVector3::deSerialize(const struct btVector3DoubleData& dataIn) +{ + for (int i = 0; i < 4; i++) + m_floats[i] = (btScalar)dataIn.m_floats[i]; +} + +#endif //BT_VECTOR3_H diff --git a/pkg/mphysics/mbt/LinearMath/btVector3.h.i b/pkg/mphysics/mbt/LinearMath/btVector3.h.i new file mode 100644 index 00000000..f56b615e --- /dev/null +++ b/pkg/mphysics/mbt/LinearMath/btVector3.h.i @@ -0,0 +1,7 @@ +////// LinearMath/btVector3.h ---------------- + +%include "LinearMath/btVector3.h" + +%{ +#include "LinearMath/btVector3.h" +%} diff --git a/pkg/mphysics/mbt/bullet.i b/pkg/mphysics/mbt/bullet.i new file mode 100644 index 00000000..cf1e1a9f --- /dev/null +++ b/pkg/mphysics/mbt/bullet.i @@ -0,0 +1,208 @@ +%module mbt + +////// included headers [LinearMath/btDefaultMotionState.h] ---------------------------------- +%include "LinearMath/btScalar.h.i" +%include "LinearMath/btMinMax.h.i" +%include "LinearMath/btAlignedAllocator.h.i" +%include "LinearMath/btAlignedAllocator.cpp.i" +%include "LinearMath/btVector3.h.i" +%include "LinearMath/btQuadWord.h.i" +%include "LinearMath/btQuaternion.h.i" +%include "LinearMath/btMatrix3x3.h.i" +%include "LinearMath/btTransform.h.i" +%include "LinearMath/btMotionState.h.i" +%include "LinearMath/btDefaultMotionState.h.i" + + +////// included headers [BulletCollision/CollisionShapes/btSphereShape.h] ---------------------------------- +%include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h.i" +%include "BulletCollision/CollisionShapes/btCollisionShape.h.i" +%include "BulletCollision/CollisionShapes/btCollisionShape.cpp.i" +%include "BulletCollision/CollisionShapes/btCollisionMargin.h.i" +%include "BulletCollision/CollisionShapes/btConvexShape.h.i" +%include "BulletCollision/CollisionShapes/btConvexShape.cpp.i" +%include "LinearMath/btAabbUtil2.h.i" +%include "BulletCollision/CollisionShapes/btConvexInternalShape.h.i" +%include "BulletCollision/CollisionShapes/btConvexInternalShape.cpp.i" +%include "BulletCollision/CollisionShapes/btSphereShape.h.i" +%include "BulletCollision/CollisionShapes/btSphereShape.cpp.i" + + +////// included headers [BulletCollision/CollisionShapes/btBoxShape.h] ---------------------------------- +%include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h.i" +%include "LinearMath/btAlignedObjectArray.h.i" +%include "BulletCollision/CollisionShapes/btConvexPolyhedron.h.i" +%include "BulletCollision/CollisionShapes/btConvexPolyhedron.cpp.i" +%include "LinearMath/btConvexHullComputer.h.i" +%include "LinearMath/btConvexHullComputer.cpp.i" +%include "LinearMath/btGeometryUtil.h.i" +%include "LinearMath/btGeometryUtil.cpp.i" +%include "LinearMath/btGrahamScan2dConvexHull.h.i" +%include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp.i" +%include "BulletCollision/CollisionShapes/btBoxShape.h.i" +%include "BulletCollision/CollisionShapes/btBoxShape.cpp.i" + + +// ////// included headers [BulletCollision/CollisionShapes/btCapsuleShape.h] ---------------------------------- +%include "BulletCollision/CollisionShapes/btCapsuleShape.h.i" +%include "BulletCollision/CollisionShapes/btCapsuleShape.cpp.i" + + +////// included headers [BulletDynamics/Dynamics/btRigidBody.h] ---------------------------------- +%include "BulletCollision/CollisionDispatch/btCollisionObject.h.i" +%include "BulletCollision/CollisionDispatch/btCollisionObject.cpp.i" +%include "BulletDynamics/Dynamics/btRigidBody.h.i" +%include "LinearMath/btTransformUtil.h.i" +%include "BulletDynamics/ConstraintSolver/btJacobianEntry.h.i" +%include "BulletDynamics/ConstraintSolver/btSolverBody.h.i" +%include "BulletDynamics/ConstraintSolver/btSolverConstraint.h.i" +%include "BulletDynamics/ConstraintSolver/btTypedConstraint.h.i" +%include "BulletDynamics/ConstraintSolver/btTypedConstraint.cpp.i" +%include "LinearMath/btHashMap.h.i" +%include "LinearMath/btSerializer.h.i" +%include "LinearMath/btSerializer.cpp.i" +%include "LinearMath/btSerializer64.cpp.i" +%include "BulletDynamics/Dynamics/btRigidBody.cpp.i" + + +////// included headers [BulletCollision/BroadphaseCollision/btDbvtBroadphase.h] ---------------------------------- +%include "BulletCollision/BroadphaseCollision/btDbvt.h.i" +%include "BulletCollision/BroadphaseCollision/btDbvt.cpp.i" +%include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h.i" +%include "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h.i" +%include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h.i" +%include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp.i" +%include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h.i" +%include "LinearMath/btThreads.h.i" +%include "LinearMath/btThreads.cpp.i" +%include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp.i" + + +////// included headers [BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h] ---------------------------------- +%include "BulletCollision/BroadphaseCollision/btDispatcher.h.i" +%include "BulletCollision/BroadphaseCollision/btDispatcher.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h.i" +%include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h.i" +%include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h.i" +%include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h.i" +%include "BulletCollision/CollisionDispatch/btManifoldResult.h.i" +%include "BulletCollision/CollisionDispatch/btManifoldResult.cpp.i" +%include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h.i" +%include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h.i" +%include "BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp.i" +%include "BulletCollision/CollisionDispatch/btCollisionWorld.h.i" +%include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h.i" +%include "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h.i" +%include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h.i" +%include "BulletCollision/CollisionShapes/btTriangleCallback.h.i" +%include "BulletCollision/CollisionShapes/btConcaveShape.h.i" +%include "BulletCollision/CollisionShapes/btStridingMeshInterface.h.i" +%include "BulletCollision/CollisionShapes/btTriangleMeshShape.h.i" +%include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h.i" +%include "BulletCollision/CollisionShapes/btOptimizedBvh.h.i" +%include "BulletCollision/CollisionShapes/btTriangleInfoMap.h.i" +%include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h.i" +%include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h.i" +%include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h.i" +%include "LinearMath/btIDebugDraw.h.i" +%include "BulletCollision/NarrowPhaseCollision/btConvexCast.h.i" +%include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h.i" +%include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h.i" +%include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h.i" +%include "BulletCollision/CollisionDispatch/btCollisionWorld.cpp.i" +%include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h.i" +%include "BulletDynamics/Dynamics/btDynamicsWorld.h.i" +%include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h.i" +%include "BulletCollision/CollisionDispatch/btUnionFind.h.i" +%include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h.i" +%include "BulletDynamics/ConstraintSolver/btConstraintSolver.h.i" +%include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h.i" +%include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp.i" +%include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h.i" +%include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h.i" +%include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp.i" +%include "BulletCollision/CollisionShapes/btTriangleCallback.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp.i" +%include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp.i" +%include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp.i" +%include "BulletCollision/CollisionDispatch/btUnionFind.cpp.i" +%include "BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btConvexCast.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h.i" +%include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp.i" +%include "BulletCollision/CollisionShapes/btConcaveShape.cpp.i" +%include "BulletCollision/CollisionShapes/btTriangleMeshShape.cpp.i" +%include "BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp.i" +%include "BulletCollision/CollisionShapes/btOptimizedBvh.cpp.i" +%include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp.i" +%include "BulletCollision/CollisionShapes/btStridingMeshInterface.cpp.i" +%include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h.i" +%include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp.i" + + +////// included headers [BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h] ---------------------------------- +%include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp.i" +%include "BulletCollision/CollisionDispatch/btCollisionConfiguration.h.i" +%include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h.i" +%include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h.i" +%include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp.i" +%include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h.i" +%include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp.i" +%include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp.i" +%include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp.i" +%include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp.i" +%include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp.i" +%include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.h.i" +%include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp.i" +%include "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp.i" +%include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp.i" +%include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp.i" +%include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp.i" +%include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp.i" +%include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h.i" +%include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp.i" +%include "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h.i" +%include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h.i" +%include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp.i" +%include "LinearMath/btPoolAllocator.h.i" +%include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp.i" +%include "BulletCollision/CollisionShapes/btMiniSDF.h.i" +%include "BulletCollision/CollisionShapes/btMiniSDF.cpp.i" +%include "BulletCollision/CollisionDispatch/btBoxBoxDetector.h.i" +%include "BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp.i" +%include "BulletCollision/CollisionShapes/btSdfCollisionShape.h.i" +%include "BulletCollision/CollisionShapes/btSdfCollisionShape.cpp.i" +%include "BulletCollision/CollisionDispatch/SphereTriangleDetector.h.i" +%include "BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp.i" + +////// included headers [BulletCollision/CollisionShapes/btStaticPlaneShape.h] ---------------------------------- +%include "BulletCollision/CollisionShapes/btStaticPlaneShape.h.i" +%include "BulletCollision/CollisionShapes/btStaticPlaneShape.cpp.i" + + +////// included headers [BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h] ---------------------------------- +%include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h.i" +%include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp.i" + +////// included headers [LinearMath/btIDebugDraw.h] ---------------------------------- +%include "LinearMath/btIDebugDraw.h.i" +%include "LinearMath/btMDebugDraw.h.i" +%include "LinearMath/btMDebugDraw.cpp.i" diff --git a/pkg/mphysics/mbt/mbt.cxx b/pkg/mphysics/mbt/mbt.cxx new file mode 100644 index 00000000..50ac4670 --- /dev/null +++ b/pkg/mphysics/mbt/mbt.cxx @@ -0,0 +1,74513 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.2.0 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +// source: C:\MMD\mlib_go\pkg\mbt\bullet.i + + +extern +#ifdef __cplusplus + "C" +#endif + void cgo_panic__mbt_e879218550ba2e2b(const char*); +static void _swig_gopanic(const char *p) { + cgo_panic__mbt_e879218550ba2e2b(p); +} + + + +#define SWIG_VERSION 0x040200 +#define SWIGGO +#define SWIGMODULE mbt +#define SWIG_DIRECTORS +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + +#if __cplusplus >=201103L +# define SWIG_NULLPTR nullptr +#else +# define SWIG_NULLPTR NULL +#endif + + +/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF + * if you're missing it. + */ +#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \ + (defined __cplusplus && __cplusplus >= 201103L) || \ + defined SWIG_HAVE_SNPRINTF) && \ + !defined SWIG_NO_SNPRINTF +# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A) +# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B) +#else +/* Fallback versions ignore the buffer size, but most of our uses either have a + * fixed maximum possible size or dynamically allocate a buffer that's large + * enough. + */ +# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A) +# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B) +#endif + + + +#include +#include +#include +#include +#include + + + +typedef ptrdiff_t intgo; +typedef size_t uintgo; + + +# if !defined(__clang__) && (defined(__i386__) || defined(__x86_64__)) +# define SWIGSTRUCTPACKED __attribute__((__packed__, __gcc_struct__)) +# else +# define SWIGSTRUCTPACKED __attribute__((__packed__)) +# endif + + + +typedef struct { char *p; intgo n; } _gostring_; +typedef struct { void* array; intgo len; intgo cap; } _goslice_; + + + +static _gostring_ Swig_AllocateString(const char *p, size_t l) { + _gostring_ ret; + ret.p = (char*)malloc(l); + memcpy(ret.p, p, l); + ret.n = l; + return ret; +} + +/* ----------------------------------------------------------------------------- + * director_common.swg + * + * This file contains support for director classes which is common between + * languages. + * ----------------------------------------------------------------------------- */ + +/* + Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the + 'Swig' namespace. This could be useful for multi-modules projects. +*/ +#ifdef SWIG_DIRECTOR_STATIC +/* Force anonymous (static) namespace */ +#define Swig +#endif +/* ----------------------------------------------------------------------------- + * director.swg + * + * This file contains support for director classes so that Go proxy + * methods can be called from C++. + * ----------------------------------------------------------------------------- */ + +#include +#include + +namespace Swig { + + class DirectorException : public std::exception { + }; +} + +/* Handle memory management for directors. */ + +namespace { + struct GCItem { + virtual ~GCItem() {} + }; + + struct GCItem_var { + GCItem_var(GCItem *item = 0) : _item(item) { + } + + GCItem_var& operator=(GCItem *item) { + GCItem *tmp = _item; + _item = item; + delete tmp; + return *this; + } + + ~GCItem_var() { + delete _item; + } + + GCItem* operator->() { + return _item; + } + + private: + GCItem *_item; + }; + + template + struct GCItem_T : GCItem { + GCItem_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCItem_T() { + delete _ptr; + } + + private: + Type *_ptr; + }; +} + +class Swig_memory { +public: + template + void swig_acquire_pointer(Type* vptr) { + if (vptr) { + swig_owner[vptr] = new GCItem_T(vptr); + } + } +private: + typedef std::map swig_ownership_map; + swig_ownership_map swig_owner; +}; + +template +static void swig_acquire_pointer(Swig_memory** pmem, Type* ptr) { + if (!pmem) { + *pmem = new Swig_memory; + } + (*pmem)->swig_acquire_pointer(ptr); +} + +#ifdef __cplusplus +#include +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigSmartPointer { + T *ptr; + SwigSmartPointer(T *p) : ptr(p) { } + ~SwigSmartPointer() { delete ptr; } + SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; } +#if __cplusplus >=201103L + SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; } + operator T&&() const { return std::move(*pointer.ptr); } +#else + operator T&() const { return *pointer.ptr; } +#endif + T *operator&() const { return pointer.ptr; } + static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); } +}; + +/* + * SwigValueInit() is a generic initialisation solution as the following approach: + * + * T c_result = T(); + * + * doesn't compile for all types for example: + * + * unsigned int c_result = unsigned int(); + */ +template T SwigValueInit() { + return T(); +} + +#if __cplusplus >=201103L +# define SWIG_STD_MOVE(OBJ) std::move(OBJ) +#else +# define SWIG_STD_MOVE(OBJ) OBJ +#endif + +#endif + + +static void Swig_free(void* p) { + free(p); +} + +static void* Swig_malloc(int c) { + return malloc(c); +} + + +#include "LinearMath/btScalar.h" + + +#include "LinearMath/btMinMax.h" + + +#include "LinearMath/btAlignedAllocator.h" + + +#include "LinearMath/btAlignedAllocator.cpp" + + +#include "LinearMath/btVector3.h" + + +#include "LinearMath/btQuadWord.h" + + +#include "LinearMath/btQuaternion.h" + + +#include "LinearMath/btMatrix3x3.h" + + +#include "LinearMath/btTransform.h" + + +#include "LinearMath/btMotionState.h" + + +#include "LinearMath/btDefaultMotionState.h" + + +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" + + +#include + + +#include "BulletCollision/CollisionShapes/btCollisionShape.h" + + +#include "BulletCollision/CollisionShapes/btCollisionShape.cpp" + + +#include "BulletCollision/CollisionShapes/btCollisionMargin.h" + + +#include "BulletCollision/CollisionShapes/btConvexShape.h" + + +#include "BulletCollision/CollisionShapes/btConvexShape.cpp" + + +#include "LinearMath/btAabbUtil2.h" + + +#include "BulletCollision/CollisionShapes/btConvexInternalShape.h" + + +#include "BulletCollision/CollisionShapes/btConvexInternalShape.cpp" + + +#include "BulletCollision/CollisionShapes/btSphereShape.h" + + +#include "BulletCollision/CollisionShapes/btSphereShape.cpp" + + +#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" + + +#include "LinearMath/btAlignedObjectArray.h" + + +#include "BulletCollision/CollisionShapes/btConvexPolyhedron.h" + + +#include "BulletCollision/CollisionShapes/btConvexPolyhedron.cpp" + + +#include "LinearMath/btConvexHullComputer.h" + + +#include "LinearMath/btConvexHullComputer.cpp" + + +#include "LinearMath/btGeometryUtil.h" + + +#include "LinearMath/btGeometryUtil.cpp" + + +#include "LinearMath/btGrahamScan2dConvexHull.h" + + +#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp" + + +#include "BulletCollision/CollisionShapes/btBoxShape.h" + + +#include "BulletCollision/CollisionShapes/btBoxShape.cpp" + + +#include "BulletCollision/CollisionShapes/btCapsuleShape.h" + + +#include "BulletCollision/CollisionShapes/btCapsuleShape.cpp" + + +#include "BulletCollision/CollisionDispatch/btCollisionObject.h" + + +#include "BulletCollision/CollisionDispatch/btCollisionObject.cpp" + + +#include "BulletDynamics/Dynamics/btRigidBody.h" + + +#include "LinearMath/btTransformUtil.h" + + +#include "BulletDynamics/ConstraintSolver/btJacobianEntry.h" + + +#include "BulletDynamics/ConstraintSolver/btSolverBody.h" + + +#include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" + + +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" + + +#include "BulletDynamics/ConstraintSolver/btTypedConstraint.cpp" + + +#include "LinearMath/btHashMap.h" + + +#include "LinearMath/btSerializer.h" + + +#include "LinearMath/btSerializer.cpp" + + +#include "LinearMath/btSerializer64.cpp" + + +#include "BulletDynamics/Dynamics/btRigidBody.cpp" + + +#include "BulletCollision/BroadphaseCollision/btDbvt.h" + + +#include "BulletCollision/BroadphaseCollision/btDbvt.cpp" + + +#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" + + +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h" + + +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" + + +#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp" + + +#include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h" + + +#include "LinearMath/btThreads.h" + + +#include "LinearMath/btThreads.cpp" + + +#include "BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp" + + +#include "BulletCollision/BroadphaseCollision/btDispatcher.h" + + +#include "BulletCollision/BroadphaseCollision/btDispatcher.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" + + +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" + + +#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" + + +#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" + + +#include "BulletCollision/CollisionDispatch/btManifoldResult.h" + + +#include "BulletCollision/CollisionDispatch/btManifoldResult.cpp" + + +#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" + + +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" + + +#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp" + + +#include "BulletCollision/CollisionDispatch/btCollisionWorld.h" + + +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" + + +#include "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h" + + +#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h" + + +#include "BulletCollision/CollisionShapes/btTriangleCallback.h" + + +#include "BulletCollision/CollisionShapes/btConcaveShape.h" + + +#include "BulletCollision/CollisionShapes/btStridingMeshInterface.h" + + +#include "BulletCollision/CollisionShapes/btTriangleMeshShape.h" + + +#include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" + + +#include "BulletCollision/CollisionShapes/btOptimizedBvh.h" + + +#include "BulletCollision/CollisionShapes/btTriangleInfoMap.h" + + +#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" + + +#include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h" + + +#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h" + + +#include "LinearMath/btIDebugDraw.h" + + +#include "BulletCollision/NarrowPhaseCollision/btConvexCast.h" + + +#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h" + + +#include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h" + + +#include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h" + + +#include "BulletCollision/CollisionDispatch/btCollisionWorld.cpp" + + +#include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" + + +#include "BulletDynamics/Dynamics/btDynamicsWorld.h" + + +#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" + + +#include "BulletCollision/CollisionDispatch/btUnionFind.h" + + +#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" + + +#include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" + + +#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h" + + +#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp" + + +#include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h" + + +#include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h" + + +#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp" + + +#include "BulletCollision/CollisionShapes/btTriangleCallback.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp" + + +#include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp" + + +#include "BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp" + + +#include "BulletCollision/CollisionDispatch/btUnionFind.cpp" + + +#include "BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btConvexCast.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" + + +#include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp" + + +#include "BulletCollision/CollisionShapes/btConcaveShape.cpp" + + +#include "BulletCollision/CollisionShapes/btTriangleMeshShape.cpp" + + +#include "BulletCollision/BroadphaseCollision/btQuantizedBvh.cpp" + + +#include "BulletCollision/CollisionShapes/btOptimizedBvh.cpp" + + +#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.cpp" + + +#include "BulletCollision/CollisionShapes/btStridingMeshInterface.cpp" + + +#include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h" + + +#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.cpp" + + +#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp" + + +#include "BulletCollision/CollisionDispatch/btCollisionConfiguration.h" + + +#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h" + + +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" + + +#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp" + + +#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h" + + +#include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp" + + +#include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp" + + +#include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp" + + +#include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp" + + +#include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp" + + +#include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.h" + + +#include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.cpp" + + +#include "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp" + + +#include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp" + + +#include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp" + + +#include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp" + + +#include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp" + + +#include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h" + + +#include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp" + + +#include "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h" + + +#include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h" + + +#include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp" + + +#include "LinearMath/btPoolAllocator.h" + + +#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp" + + +#include "BulletCollision/CollisionShapes/btMiniSDF.h" + + +#include "BulletCollision/CollisionShapes/btMiniSDF.cpp" + + +#include "BulletCollision/CollisionDispatch/btBoxBoxDetector.h" + + +#include "BulletCollision/CollisionDispatch/btBoxBoxDetector.cpp" + + +#include "BulletCollision/CollisionShapes/btSdfCollisionShape.h" + + +#include "BulletCollision/CollisionShapes/btSdfCollisionShape.cpp" + + +#include "BulletCollision/CollisionDispatch/SphereTriangleDetector.h" + + +#include "BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp" + + +#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h" + + +#include "BulletCollision/CollisionShapes/btStaticPlaneShape.cpp" + + +#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h" + + +#include "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp" + + +#include "LinearMath/btMDebugDraw.h" + + +#include "LinearMath/btMDebugDraw.cpp" + + +// C++ director class methods. +#include "mbt.h" + +SwigDirector_btMDebugDrawLiner::SwigDirector_btMDebugDrawLiner(int swig_p) + : btMDebugDrawLiner(), + go_val(swig_p), swig_mem(0) +{ } + +extern "C" void Swiggo_DeleteDirector_btMDebugDrawLiner_mbt_e879218550ba2e2b(intgo); +SwigDirector_btMDebugDrawLiner::~SwigDirector_btMDebugDrawLiner() +{ + Swiggo_DeleteDirector_btMDebugDrawLiner_mbt_e879218550ba2e2b(go_val); + delete swig_mem; +} + +extern "C" void Swig_DirectorBtMDebugDrawLiner_callback_drawLine_mbt_e879218550ba2e2b(int, btVector3 *from, btVector3 *to, btVector3 *color); +void SwigDirector_btMDebugDrawLiner::drawLine(btVector3 const &from,btVector3 const &to,btVector3 const &color) { + btVector3 *swig_from; + btVector3 *swig_to; + btVector3 *swig_color; + + swig_from = (btVector3 *)&from; + swig_to = (btVector3 *)&to; + swig_color = (btVector3 *)&color; + Swig_DirectorBtMDebugDrawLiner_callback_drawLine_mbt_e879218550ba2e2b(go_val, swig_from, swig_to, swig_color); +} + +#ifdef __cplusplus +extern "C" { +#endif + +void _wrap_Swig_free_mbt_e879218550ba2e2b(void *_swig_go_0) { + void *arg1 = (void *) 0 ; + + arg1 = *(void **)&_swig_go_0; + + Swig_free(arg1); + +} + + +void *_wrap_Swig_malloc_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (void *)Swig_malloc(arg1); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +intgo _wrap_btGetVersion_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)btGetVersion(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btIsDoublePrecision_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)btIsDoublePrecision(); + _swig_go_result = result; + return _swig_go_result; +} + + +btInfMaskConverter *_wrap_new_btInfMaskConverter__SWIG_0_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + btInfMaskConverter *result = 0 ; + btInfMaskConverter *_swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (btInfMaskConverter *)new btInfMaskConverter(arg1); + *(btInfMaskConverter **)&_swig_go_result = (btInfMaskConverter *)result; + return _swig_go_result; +} + + +btInfMaskConverter *_wrap_new_btInfMaskConverter__SWIG_1_mbt_e879218550ba2e2b() { + btInfMaskConverter *result = 0 ; + btInfMaskConverter *_swig_go_result; + + + result = (btInfMaskConverter *)new btInfMaskConverter(); + *(btInfMaskConverter **)&_swig_go_result = (btInfMaskConverter *)result; + return _swig_go_result; +} + + +void _wrap_delete_btInfMaskConverter_mbt_e879218550ba2e2b(btInfMaskConverter *_swig_go_0) { + btInfMaskConverter *arg1 = (btInfMaskConverter *) 0 ; + + arg1 = *(btInfMaskConverter **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btInfinityMask_set_mbt_e879218550ba2e2b(btInfMaskConverter *_swig_go_0) { + btInfMaskConverter *arg1 = (btInfMaskConverter *) 0 ; + + arg1 = *(btInfMaskConverter **)&_swig_go_0; + + btInfinityMask = *arg1; + +} + + +btInfMaskConverter *_wrap_btInfinityMask_get_mbt_e879218550ba2e2b() { + btInfMaskConverter *result = 0 ; + btInfMaskConverter *_swig_go_result; + + + result = (btInfMaskConverter *)&btInfinityMask; + *(btInfMaskConverter **)&_swig_go_result = (btInfMaskConverter *)result; + return _swig_go_result; +} + + +intgo _wrap_btGetInfinityMask_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)btGetInfinityMask(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btSqrt_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btSqrt(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btFabs_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btFabs(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCos_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btCos(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btSin_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btSin(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btTan_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btTan(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAcos_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btAcos(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAsin_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btAsin(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAtan_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btAtan(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAtan2_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1) { + btScalar arg1 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (btScalar)btAtan2(arg1,arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btExp_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btExp(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btLog_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btLog(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btPow_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1) { + btScalar arg1 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (btScalar)btPow(arg1,arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btFmod_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1) { + btScalar arg1 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (btScalar)btFmod(arg1,arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAtan2Fast_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1) { + btScalar arg1 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (btScalar)btAtan2Fast(arg1,arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btFuzzyZero_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (bool)btFuzzyZero(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btEqual_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1) { + btScalar arg1 ; + btScalar arg2 ; + bool result; + bool _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (bool)btEqual(arg1,arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btGreaterEqual_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1) { + btScalar arg1 ; + btScalar arg2 ; + bool result; + bool _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (bool)btGreaterEqual(arg1,arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btIsNegative_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + int result; + intgo _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (int)btIsNegative(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btRadians_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btRadians(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btDegrees_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btDegrees(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btFsel_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1, float _swig_go_2) { + btScalar arg1 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = (btScalar)btFsel(arg1,arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btMachineIsLittleEndian_mbt_e879218550ba2e2b() { + bool result; + bool _swig_go_result; + + + result = (bool)btMachineIsLittleEndian(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSelect__SWIG_0_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + unsigned int arg1 ; + unsigned int arg2 ; + unsigned int arg3 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = (unsigned int)_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + arg3 = (unsigned int)_swig_go_2; + + result = (unsigned int)btSelect(arg1,arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSelect__SWIG_1_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + unsigned int arg1 ; + int arg2 ; + int arg3 ; + int result; + intgo _swig_go_result; + + arg1 = (unsigned int)_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (int)btSelect(arg1,arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btSelect__SWIG_2_mbt_e879218550ba2e2b(intgo _swig_go_0, float _swig_go_1, float _swig_go_2) { + unsigned int arg1 ; + float arg2 ; + float arg3 ; + float result; + float _swig_go_result; + + arg1 = (unsigned int)_swig_go_0; + arg2 = (float)_swig_go_1; + arg3 = (float)_swig_go_2; + + result = (float)btSelect(arg1,arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSwapEndian__SWIG_0_mbt_e879218550ba2e2b(intgo _swig_go_0) { + unsigned int arg1 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = (unsigned int)_swig_go_0; + + result = (unsigned int)btSwapEndian(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +short _wrap_btSwapEndian__SWIG_1_mbt_e879218550ba2e2b(short _swig_go_0) { + unsigned short arg1 ; + unsigned short result; + short _swig_go_result; + + arg1 = (unsigned short)_swig_go_0; + + result = (unsigned short)btSwapEndian(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSwapEndian__SWIG_2_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (unsigned int)btSwapEndian(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +short _wrap_btSwapEndian__SWIG_3_mbt_e879218550ba2e2b(short _swig_go_0) { + short arg1 ; + unsigned short result; + short _swig_go_result; + + arg1 = (short)_swig_go_0; + + result = (unsigned short)btSwapEndian(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSwapEndianFloat_mbt_e879218550ba2e2b(float _swig_go_0) { + float arg1 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = (float)_swig_go_0; + + result = (unsigned int)btSwapEndianFloat(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btUnswapEndianFloat_mbt_e879218550ba2e2b(intgo _swig_go_0) { + unsigned int arg1 ; + float result; + float _swig_go_result; + + arg1 = (unsigned int)_swig_go_0; + + result = (float)btUnswapEndianFloat(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSwapEndianDouble_mbt_e879218550ba2e2b(double _swig_go_0, char *_swig_go_1) { + double arg1 ; + unsigned char *arg2 = (unsigned char *) 0 ; + + arg1 = (double)_swig_go_0; + arg2 = *(unsigned char **)&_swig_go_1; + + btSwapEndianDouble(arg1,arg2); + +} + + +double _wrap_btUnswapEndianDouble_mbt_e879218550ba2e2b(char *_swig_go_0) { + unsigned char *arg1 = (unsigned char *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(unsigned char **)&_swig_go_0; + + result = (double)btUnswapEndianDouble((unsigned char const *)arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btLargeDot_mbt_e879218550ba2e2b(float *_swig_go_0, float *_swig_go_1, intgo _swig_go_2) { + btScalar *arg1 = (btScalar *) 0 ; + btScalar *arg2 = (btScalar *) 0 ; + int arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btScalar **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btScalar)btLargeDot((float const *)arg1,(float const *)arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btNormalizeAngle_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btScalar)btNormalizeAngle(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +btTypedObject *_wrap_new_btTypedObject_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + btTypedObject *result = 0 ; + btTypedObject *_swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (btTypedObject *)new btTypedObject(arg1); + *(btTypedObject **)&_swig_go_result = (btTypedObject *)result; + return _swig_go_result; +} + + +void _wrap_btTypedObject_m_objectType_set_mbt_e879218550ba2e2b(btTypedObject *_swig_go_0, intgo _swig_go_1) { + btTypedObject *arg1 = (btTypedObject *) 0 ; + int arg2 ; + + arg1 = *(btTypedObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_objectType = arg2; + +} + + +intgo _wrap_btTypedObject_m_objectType_get_mbt_e879218550ba2e2b(btTypedObject *_swig_go_0) { + btTypedObject *arg1 = (btTypedObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedObject **)&_swig_go_0; + + result = (int) ((arg1)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btTypedObject_getObjectType_mbt_e879218550ba2e2b(btTypedObject *_swig_go_0) { + btTypedObject *arg1 = (btTypedObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedObject **)&_swig_go_0; + + result = (int)((btTypedObject const *)arg1)->getObjectType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btTypedObject_mbt_e879218550ba2e2b(btTypedObject *_swig_go_0) { + btTypedObject *arg1 = (btTypedObject *) 0 ; + + arg1 = *(btTypedObject **)&_swig_go_0; + + delete arg1; + +} + + +void *_wrap_btAlignedAllocInternal_mbt_e879218550ba2e2b(long long _swig_go_0, intgo _swig_go_1) { + size_t arg1 ; + int arg2 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = (size_t)_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (void *)btAlignedAllocInternal(SWIG_STD_MOVE(arg1),arg2); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btAlignedFreeInternal_mbt_e879218550ba2e2b(void *_swig_go_0) { + void *arg1 = (void *) 0 ; + + arg1 = *(void **)&_swig_go_0; + + btAlignedFreeInternal(arg1); + +} + + +void _wrap_btAlignedAllocSetCustom_mbt_e879218550ba2e2b(void* _swig_go_0, void* _swig_go_1) { + btAllocFunc *arg1 = (btAllocFunc *) 0 ; + btFreeFunc *arg2 = (btFreeFunc *) 0 ; + + arg1 = *(btAllocFunc **)&_swig_go_0; + arg2 = *(btFreeFunc **)&_swig_go_1; + + btAlignedAllocSetCustom(arg1,arg2); + +} + + +void _wrap_btAlignedAllocSetCustomAligned_mbt_e879218550ba2e2b(void* _swig_go_0, void* _swig_go_1) { + btAlignedAllocFunc *arg1 = (btAlignedAllocFunc *) 0 ; + btAlignedFreeFunc *arg2 = (btAlignedFreeFunc *) 0 ; + + arg1 = *(btAlignedAllocFunc **)&_swig_go_0; + arg2 = *(btAlignedFreeFunc **)&_swig_go_1; + + btAlignedAllocSetCustomAligned(arg1,arg2); + +} + + +void *_wrap_btAllocDefault_mbt_e879218550ba2e2b(long long _swig_go_0) { + size_t arg1 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = (size_t)_swig_go_0; + + result = (void *)btAllocDefault(SWIG_STD_MOVE(arg1)); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btFreeDefault_mbt_e879218550ba2e2b(void *_swig_go_0) { + void *arg1 = (void *) 0 ; + + arg1 = *(void **)&_swig_go_0; + + btFreeDefault(arg1); + +} + + +void _wrap_sAllocFunc_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + btAllocFunc *arg1 = (btAllocFunc *) 0 ; + + arg1 = *(btAllocFunc **)&_swig_go_0; + + sAllocFunc = arg1; + +} + + +void* _wrap_sAllocFunc_get_mbt_e879218550ba2e2b() { + btAllocFunc *result = 0 ; + void* _swig_go_result; + + + result = (btAllocFunc *)sAllocFunc; + *(btAllocFunc **)&_swig_go_result = (btAllocFunc *)result; + return _swig_go_result; +} + + +void _wrap_sFreeFunc_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + btFreeFunc *arg1 = (btFreeFunc *) 0 ; + + arg1 = *(btFreeFunc **)&_swig_go_0; + + sFreeFunc = arg1; + +} + + +void* _wrap_sFreeFunc_get_mbt_e879218550ba2e2b() { + btFreeFunc *result = 0 ; + void* _swig_go_result; + + + result = (btFreeFunc *)sFreeFunc; + *(btFreeFunc **)&_swig_go_result = (btFreeFunc *)result; + return _swig_go_result; +} + + +void *_wrap_btAlignedAllocDefault_mbt_e879218550ba2e2b(long long _swig_go_0, intgo _swig_go_1) { + size_t arg1 ; + int arg2 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = (size_t)_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (void *)btAlignedAllocDefault(SWIG_STD_MOVE(arg1),arg2); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btAlignedFreeDefault_mbt_e879218550ba2e2b(void *_swig_go_0) { + void *arg1 = (void *) 0 ; + + arg1 = *(void **)&_swig_go_0; + + btAlignedFreeDefault(arg1); + +} + + +void _wrap_sAlignedAllocFunc_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + btAlignedAllocFunc *arg1 = (btAlignedAllocFunc *) 0 ; + + arg1 = *(btAlignedAllocFunc **)&_swig_go_0; + + sAlignedAllocFunc = arg1; + +} + + +void* _wrap_sAlignedAllocFunc_get_mbt_e879218550ba2e2b() { + btAlignedAllocFunc *result = 0 ; + void* _swig_go_result; + + + result = (btAlignedAllocFunc *)sAlignedAllocFunc; + *(btAlignedAllocFunc **)&_swig_go_result = (btAlignedAllocFunc *)result; + return _swig_go_result; +} + + +void _wrap_sAlignedFreeFunc_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + btAlignedFreeFunc *arg1 = (btAlignedFreeFunc *) 0 ; + + arg1 = *(btAlignedFreeFunc **)&_swig_go_0; + + sAlignedFreeFunc = arg1; + +} + + +void* _wrap_sAlignedFreeFunc_get_mbt_e879218550ba2e2b() { + btAlignedFreeFunc *result = 0 ; + void* _swig_go_result; + + + result = (btAlignedFreeFunc *)sAlignedFreeFunc; + *(btAlignedFreeFunc **)&_swig_go_result = (btAlignedFreeFunc *)result; + return _swig_go_result; +} + + +void _wrap_btVector3_m_floats_set_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar *arg2 = (btScalar *) (btScalar *)0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + { + size_t ii; + btScalar *b = (btScalar *) arg1->m_floats; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btScalar *) arg2 + ii); + } + +} + + +float *_wrap_btVector3_m_floats_get_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar *result = 0 ; + float *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar *)(btScalar *) ((arg1)->m_floats); + *(btScalar **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_new_btVector3__SWIG_0_mbt_e879218550ba2e2b() { + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + + result = (btVector3 *)new btVector3(); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +btVector3 *_wrap_new_btVector3__SWIG_1_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1, float _swig_go_2) { + btScalar *arg1 = 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = (btScalar *)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + + result = (btVector3 *)new btVector3((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +float _wrap_btVector3_dot_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)((btVector3 const *)arg1)->dot((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector3_length2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar)((btVector3 const *)arg1)->length2(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector3_length_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar)((btVector3 const *)arg1)->length(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector3_norm_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar)((btVector3 const *)arg1)->norm(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector3_safeNorm_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar)((btVector3 const *)arg1)->safeNorm(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector3_distance2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)((btVector3 const *)arg1)->distance2((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector3_distance_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)((btVector3 const *)arg1)->distance((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btVector3_safeNormalize_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btVector3 *) &(arg1)->safeNormalize(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btVector3_normalize_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btVector3 *) &(arg1)->normalize(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btVector3_normalized_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = ((btVector3 const *)arg1)->normalized(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btVector3_rotate_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = ((btVector3 const *)arg1)->rotate((btVector3 const &)*arg2,arg3); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btVector3_angle_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)((btVector3 const *)arg1)->angle((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btVector3_absolute_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = ((btVector3 const *)arg1)->absolute(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btVector3_cross_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btVector3 const *)arg1)->cross((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btVector3_triple_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (btScalar)((btVector3 const *)arg1)->triple((btVector3 const &)*arg2,(btVector3 const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector3_minAxis_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (int)((btVector3 const *)arg1)->minAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector3_maxAxis_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (int)((btVector3 const *)arg1)->maxAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector3_furthestAxis_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (int)((btVector3 const *)arg1)->furthestAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector3_closestAxis_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (int)((btVector3 const *)arg1)->closestAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVector3_setInterpolate3_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->setInterpolate3((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +btVector3 *_wrap_btVector3_lerp_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + + result = ((btVector3 const *)arg1)->lerp((btVector3 const &)*arg2,(btScalar const &)*arg3); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btVector3_getX_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar *) &((btVector3 const *)arg1)->getX(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btVector3_getY_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar *) &((btVector3 const *)arg1)->getY(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btVector3_getZ_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar *) &((btVector3 const *)arg1)->getZ(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_btVector3_setX_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float _swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar arg2 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setX(arg2); + +} + + +void _wrap_btVector3_setY_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float _swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar arg2 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setY(arg2); + +} + + +void _wrap_btVector3_setZ_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float _swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar arg2 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setZ(arg2); + +} + + +void _wrap_btVector3_setW_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float _swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar arg2 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setW(arg2); + +} + + +float _wrap_btVector3_x_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar *) &((btVector3 const *)arg1)->x(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btVector3_y_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar *) &((btVector3 const *)arg1)->y(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btVector3_z_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar *) &((btVector3 const *)arg1)->z(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btVector3_w_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btScalar *) &((btVector3 const *)arg1)->w(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_btVector3_setMax_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setMax((btVector3 const &)*arg2); + +} + + +void _wrap_btVector3_setMin_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setMin((btVector3 const &)*arg2); + +} + + +void _wrap_btVector3_setValue_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btVector3 *arg1 = (btVector3 *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + + (arg1)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); + +} + + +void _wrap_btVector3_getSkewSymmetricMatrix_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + btVector3 *arg4 = (btVector3 *) 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btVector3 const *)arg1)->getSkewSymmetricMatrix(arg2,arg3,arg4); + +} + + +void _wrap_btVector3_setZero_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + + (arg1)->setZero(); + +} + + +bool _wrap_btVector3_isZero_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (bool)((btVector3 const *)arg1)->isZero(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btVector3_fuzzyZero_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (bool)((btVector3 const *)arg1)->fuzzyZero(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVector3_serialize_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3FloatData *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + ((btVector3 const *)arg1)->serialize(*arg2); + +} + + +void _wrap_btVector3_deSerialize__SWIG_0_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3DoubleData *arg2 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + (arg1)->deSerialize((btVector3DoubleData const &)*arg2); + +} + + +void _wrap_btVector3_deSerialize__SWIG_1_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3FloatData *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + (arg1)->deSerialize((btVector3FloatData const &)*arg2); + +} + + +void _wrap_btVector3_serializeFloat_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3FloatData *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + ((btVector3 const *)arg1)->serializeFloat(*arg2); + +} + + +void _wrap_btVector3_deSerializeFloat_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3FloatData *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + (arg1)->deSerializeFloat((btVector3FloatData const &)*arg2); + +} + + +void _wrap_btVector3_serializeDouble_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3DoubleData *arg2 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + ((btVector3 const *)arg1)->serializeDouble(*arg2); + +} + + +void _wrap_btVector3_deSerializeDouble_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3DoubleData *arg2 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + (arg1)->deSerializeDouble((btVector3DoubleData const &)*arg2); + +} + + +long long _wrap_btVector3_maxDot_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, long long _swig_go_2, float *_swig_go_3) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + long arg3 ; + btScalar *arg4 = 0 ; + long result; + long long _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (long)_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + result = (long)((btVector3 const *)arg1)->maxDot((btVector3 const *)arg2,arg3,*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +long long _wrap_btVector3_minDot_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, long long _swig_go_2, float *_swig_go_3) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + long arg3 ; + btScalar *arg4 = 0 ; + long result; + long long _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (long)_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + result = (long)((btVector3 const *)arg1)->minDot((btVector3 const *)arg2,arg3,*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btVector3_dot3_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = ((btVector3 const *)arg1)->dot3((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_delete_btVector3_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = (btVector3 *) 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + + delete arg1; + +} + + +float _wrap_btDot_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)btDot((btVector3 const &)*arg1,(btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btDistance2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)btDistance2((btVector3 const &)*arg1,(btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btDistance_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)btDistance((btVector3 const &)*arg1,(btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAngle__SWIG_0_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)btAngle((btVector3 const &)*arg1,(btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btCross_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = btCross((btVector3 const &)*arg1,(btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btTriple_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (btScalar)btTriple((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_lerp_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + + result = lerp((btVector3 const &)*arg1,(btVector3 const &)*arg2,(float const &)*arg3); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector4 *_wrap_new_btVector4__SWIG_0_mbt_e879218550ba2e2b() { + btVector4 *result = 0 ; + btVector4 *_swig_go_result; + + + result = (btVector4 *)new btVector4(); + *(btVector4 **)&_swig_go_result = (btVector4 *)result; + return _swig_go_result; +} + + +btVector4 *_wrap_new_btVector4__SWIG_1_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btScalar *arg1 = 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + btVector4 *result = 0 ; + btVector4 *_swig_go_result; + + arg1 = (btScalar *)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + + result = (btVector4 *)new btVector4((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); + *(btVector4 **)&_swig_go_result = (btVector4 *)result; + return _swig_go_result; +} + + +btVector4 *_wrap_btVector4_absolute4_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector4 result; + btVector4 *_swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + result = ((btVector4 const *)arg1)->absolute4(); + *(btVector4 **)&_swig_go_result = new btVector4(result); + return _swig_go_result; +} + + +float _wrap_btVector4_getW_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + result = (btScalar)((btVector4 const *)arg1)->getW(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector4_maxAxis4_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + result = (int)((btVector4 const *)arg1)->maxAxis4(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector4_minAxis4_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + result = (int)((btVector4 const *)arg1)->minAxis4(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector4_closestAxis4_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + result = (int)((btVector4 const *)arg1)->closestAxis4(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVector4_setValue_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + arg5 = (btScalar *)&_swig_go_4; + + (arg1)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4,(btScalar const &)*arg5); + +} + + +void _wrap_delete_btVector4_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_SetbtVector4_M_floats_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, float *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar *arg2 = (btScalar *) (btScalar *)0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + ; + +} + + +float *_wrap_GetbtVector4_M_floats_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar *result = 0 ; + float *_swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *)(btScalar *) ((swig_b0)->m_floats); + *(btScalar **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector4_dot_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->dot((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector4_length2_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->length2(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector4_length_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->length(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector4_norm_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->norm(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector4_safeNorm_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->safeNorm(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector4_distance2_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->distance2((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVector4_distance_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->distance((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btVector4_safeNormalize_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btVector3 *) &(swig_b0)->safeNormalize(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btVector4_normalize_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btVector3 *) &(swig_b0)->normalize(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btVector4_normalized_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->normalized(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btVector4_rotate_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->rotate((btVector3 const &)*arg2,arg3); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btVector4_angle_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->angle((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btVector4_absolute_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->absolute(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btVector4_cross_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->cross((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btVector4_triple_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->triple((btVector3 const &)*arg2,(btVector3 const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector4_minAxis_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (int)((btVector3 const *)swig_b0)->minAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector4_maxAxis_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (int)((btVector3 const *)swig_b0)->maxAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector4_furthestAxis_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (int)((btVector3 const *)swig_b0)->furthestAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVector4_closestAxis_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (int)((btVector3 const *)swig_b0)->closestAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVector4_setInterpolate3_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setInterpolate3((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +btVector3 *_wrap_btVector4_lerp_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->lerp((btVector3 const &)*arg2,(btScalar const &)*arg3); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btVector4_getX_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->getX(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btVector4_getY_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->getY(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btVector4_getZ_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->getZ(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_btVector4_setX_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, float _swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar arg2 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setX(arg2); + +} + + +void _wrap_btVector4_setY_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, float _swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar arg2 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setY(arg2); + +} + + +void _wrap_btVector4_setZ_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, float _swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar arg2 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setZ(arg2); + +} + + +void _wrap_btVector4_setW_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, float _swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar arg2 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setW(arg2); + +} + + +float _wrap_btVector4_x_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->x(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btVector4_y_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->y(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btVector4_z_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->z(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btVector4_w_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->w(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_btVector4_setMax_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setMax((btVector3 const &)*arg2); + +} + + +void _wrap_btVector4_setMin_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setMin((btVector3 const &)*arg2); + +} + + +void _wrap_btVector4_getSkewSymmetricMatrix_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + btVector3 *arg4 = (btVector3 *) 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + ((btVector3 const *)swig_b0)->getSkewSymmetricMatrix(arg2,arg3,arg4); + +} + + +void _wrap_btVector4_setZero_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setZero(); + +} + + +bool _wrap_btVector4_isZero_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (bool)((btVector3 const *)swig_b0)->isZero(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btVector4_fuzzyZero_mbt_e879218550ba2e2b(btVector4 *_swig_go_0) { + btVector4 *arg1 = (btVector4 *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (bool)((btVector3 const *)swig_b0)->fuzzyZero(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVector4_serialize_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3FloatData *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + ((btVector3 const *)swig_b0)->serialize(*arg2); + +} + + +void _wrap_btVector4_deSerialize__SWIG_0_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3DoubleData *arg2 = 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->deSerialize((btVector3DoubleData const &)*arg2); + +} + + +void _wrap_btVector4_deSerialize__SWIG_1_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3FloatData *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->deSerialize((btVector3FloatData const &)*arg2); + +} + + +void _wrap_btVector4_serializeFloat_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3FloatData *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + ((btVector3 const *)swig_b0)->serializeFloat(*arg2); + +} + + +void _wrap_btVector4_deSerializeFloat_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3FloatData *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->deSerializeFloat((btVector3FloatData const &)*arg2); + +} + + +void _wrap_btVector4_serializeDouble_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3DoubleData *arg2 = 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + ((btVector3 const *)swig_b0)->serializeDouble(*arg2); + +} + + +void _wrap_btVector4_deSerializeDouble_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3DoubleData *arg2 = 0 ; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->deSerializeDouble((btVector3DoubleData const &)*arg2); + +} + + +long long _wrap_btVector4_maxDot_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1, long long _swig_go_2, float *_swig_go_3) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + long arg3 ; + btScalar *arg4 = 0 ; + long result; + long long _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (long)_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (long)((btVector3 const *)swig_b0)->maxDot((btVector3 const *)arg2,arg3,*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +long long _wrap_btVector4_minDot_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1, long long _swig_go_2, float *_swig_go_3) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + long arg3 ; + btScalar *arg4 = 0 ; + long result; + long long _swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (long)_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (long)((btVector3 const *)swig_b0)->minDot((btVector3 const *)arg2,arg3,*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btVector4_dot3_mbt_e879218550ba2e2b(btVector4 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btVector4 *arg1 = (btVector4 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector4 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->dot3((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btSwapScalarEndian_mbt_e879218550ba2e2b(float _swig_go_0, float *_swig_go_1) { + btScalar *arg1 = 0 ; + btScalar *arg2 = 0 ; + + arg1 = (btScalar *)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + btSwapScalarEndian((float const &)*arg1,*arg2); + +} + + +void _wrap_btSwapVector3Endian_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btSwapVector3Endian((btVector3 const &)*arg1,*arg2); + +} + + +void _wrap_btUnSwapVector3Endian_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + + btUnSwapVector3Endian(*arg1); + +} + + +void _wrap_btVector3FloatData_m_floats_set_mbt_e879218550ba2e2b(btVector3FloatData *_swig_go_0, float *_swig_go_1) { + btVector3FloatData *arg1 = (btVector3FloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btVector3FloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_floats; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btVector3FloatData_m_floats_get_mbt_e879218550ba2e2b(btVector3FloatData *_swig_go_0) { + btVector3FloatData *arg1 = (btVector3FloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btVector3FloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_floats); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3FloatData *_wrap_new_btVector3FloatData_mbt_e879218550ba2e2b() { + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + + result = (btVector3FloatData *)new btVector3FloatData(); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btVector3FloatData_mbt_e879218550ba2e2b(btVector3FloatData *_swig_go_0) { + btVector3FloatData *arg1 = (btVector3FloatData *) 0 ; + + arg1 = *(btVector3FloatData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btVector3DoubleData_m_floats_set_mbt_e879218550ba2e2b(btVector3DoubleData *_swig_go_0, double *_swig_go_1) { + btVector3DoubleData *arg1 = (btVector3DoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btVector3DoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_floats; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btVector3DoubleData_m_floats_get_mbt_e879218550ba2e2b(btVector3DoubleData *_swig_go_0) { + btVector3DoubleData *arg1 = (btVector3DoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btVector3DoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_floats); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3DoubleData *_wrap_new_btVector3DoubleData_mbt_e879218550ba2e2b() { + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + + result = (btVector3DoubleData *)new btVector3DoubleData(); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btVector3DoubleData_mbt_e879218550ba2e2b(btVector3DoubleData *_swig_go_0) { + btVector3DoubleData *arg1 = (btVector3DoubleData *) 0 ; + + arg1 = *(btVector3DoubleData **)&_swig_go_0; + + delete arg1; + +} + + +float _wrap_btQuadWord_getX_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuadWord **)&_swig_go_0; + + result = (btScalar *) &((btQuadWord const *)arg1)->getX(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btQuadWord_getY_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuadWord **)&_swig_go_0; + + result = (btScalar *) &((btQuadWord const *)arg1)->getY(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btQuadWord_getZ_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuadWord **)&_swig_go_0; + + result = (btScalar *) &((btQuadWord const *)arg1)->getZ(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_btQuadWord_setX_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0, float _swig_go_1) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar arg2 ; + + arg1 = *(btQuadWord **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setX(arg2); + +} + + +void _wrap_btQuadWord_setY_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0, float _swig_go_1) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar arg2 ; + + arg1 = *(btQuadWord **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setY(arg2); + +} + + +void _wrap_btQuadWord_setZ_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0, float _swig_go_1) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar arg2 ; + + arg1 = *(btQuadWord **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setZ(arg2); + +} + + +void _wrap_btQuadWord_setW_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0, float _swig_go_1) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar arg2 ; + + arg1 = *(btQuadWord **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setW(arg2); + +} + + +float _wrap_btQuadWord_x_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuadWord **)&_swig_go_0; + + result = (btScalar *) &((btQuadWord const *)arg1)->x(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btQuadWord_y_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuadWord **)&_swig_go_0; + + result = (btScalar *) &((btQuadWord const *)arg1)->y(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btQuadWord_z_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuadWord **)&_swig_go_0; + + result = (btScalar *) &((btQuadWord const *)arg1)->z(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btQuadWord_w_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuadWord **)&_swig_go_0; + + result = (btScalar *) &((btQuadWord const *)arg1)->w(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_btQuadWord_setValue__SWIG_0_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btQuadWord **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + + (arg1)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); + +} + + +void _wrap_btQuadWord_setValue__SWIG_1_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + + arg1 = *(btQuadWord **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + arg5 = (btScalar *)&_swig_go_4; + + (arg1)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4,(btScalar const &)*arg5); + +} + + +btQuadWord *_wrap_new_btQuadWord__SWIG_0_mbt_e879218550ba2e2b() { + btQuadWord *result = 0 ; + btQuadWord *_swig_go_result; + + + result = (btQuadWord *)new btQuadWord(); + *(btQuadWord **)&_swig_go_result = (btQuadWord *)result; + return _swig_go_result; +} + + +btQuadWord *_wrap_new_btQuadWord__SWIG_1_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1, float _swig_go_2) { + btScalar *arg1 = 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btQuadWord *result = 0 ; + btQuadWord *_swig_go_result; + + arg1 = (btScalar *)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + + result = (btQuadWord *)new btQuadWord((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3); + *(btQuadWord **)&_swig_go_result = (btQuadWord *)result; + return _swig_go_result; +} + + +btQuadWord *_wrap_new_btQuadWord__SWIG_2_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btScalar *arg1 = 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + btQuadWord *result = 0 ; + btQuadWord *_swig_go_result; + + arg1 = (btScalar *)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + + result = (btQuadWord *)new btQuadWord((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); + *(btQuadWord **)&_swig_go_result = (btQuadWord *)result; + return _swig_go_result; +} + + +void _wrap_btQuadWord_setMax_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0, btQuadWord *_swig_go_1) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btQuadWord *arg2 = 0 ; + + arg1 = *(btQuadWord **)&_swig_go_0; + arg2 = *(btQuadWord **)&_swig_go_1; + + (arg1)->setMax((btQuadWord const &)*arg2); + +} + + +void _wrap_btQuadWord_setMin_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0, btQuadWord *_swig_go_1) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + btQuadWord *arg2 = 0 ; + + arg1 = *(btQuadWord **)&_swig_go_0; + arg2 = *(btQuadWord **)&_swig_go_1; + + (arg1)->setMin((btQuadWord const &)*arg2); + +} + + +void _wrap_delete_btQuadWord_mbt_e879218550ba2e2b(btQuadWord *_swig_go_0) { + btQuadWord *arg1 = (btQuadWord *) 0 ; + + arg1 = *(btQuadWord **)&_swig_go_0; + + delete arg1; + +} + + +btQuaternion *_wrap_new_btQuaternion__SWIG_0_mbt_e879218550ba2e2b() { + btQuaternion *result = 0 ; + btQuaternion *_swig_go_result; + + + result = (btQuaternion *)new btQuaternion(); + *(btQuaternion **)&_swig_go_result = (btQuaternion *)result; + return _swig_go_result; +} + + +btQuaternion *_wrap_new_btQuaternion__SWIG_1_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btScalar *arg1 = 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + btQuaternion *result = 0 ; + btQuaternion *_swig_go_result; + + arg1 = (btScalar *)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + + result = (btQuaternion *)new btQuaternion((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); + *(btQuaternion **)&_swig_go_result = (btQuaternion *)result; + return _swig_go_result; +} + + +btQuaternion *_wrap_new_btQuaternion__SWIG_2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float _swig_go_1) { + btVector3 *arg1 = 0 ; + btScalar *arg2 = 0 ; + btQuaternion *result = 0 ; + btQuaternion *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + + result = (btQuaternion *)new btQuaternion((btVector3 const &)*arg1,(btScalar const &)*arg2); + *(btQuaternion **)&_swig_go_result = (btQuaternion *)result; + return _swig_go_result; +} + + +btQuaternion *_wrap_new_btQuaternion__SWIG_3_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1, float _swig_go_2) { + btScalar *arg1 = 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btQuaternion *result = 0 ; + btQuaternion *_swig_go_result; + + arg1 = (btScalar *)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + + result = (btQuaternion *)new btQuaternion((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3); + *(btQuaternion **)&_swig_go_result = (btQuaternion *)result; + return _swig_go_result; +} + + +void _wrap_btQuaternion_setRotation_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + + (arg1)->setRotation((btVector3 const &)*arg2,(btScalar const &)*arg3); + +} + + +void _wrap_btQuaternion_setEuler_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + + (arg1)->setEuler((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); + +} + + +void _wrap_btQuaternion_setEulerZYX_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + + (arg1)->setEulerZYX((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); + +} + + +void _wrap_btQuaternion_getEulerZYX_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, float *_swig_go_1, float *_swig_go_2, float *_swig_go_3) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + ((btQuaternion const *)arg1)->getEulerZYX(*arg2,*arg3,*arg4); + +} + + +float _wrap_btQuaternion_dot_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternion *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternion *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + result = (btScalar)((btQuaternion const *)arg1)->dot((btQuaternion const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_length2_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = (btScalar)((btQuaternion const *)arg1)->length2(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_length_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = (btScalar)((btQuaternion const *)arg1)->length(); + _swig_go_result = result; + return _swig_go_result; +} + + +btQuaternion *_wrap_btQuaternion_safeNormalize_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternion *result = 0 ; + btQuaternion *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = (btQuaternion *) &(arg1)->safeNormalize(); + *(btQuaternion **)&_swig_go_result = result; + return _swig_go_result; +} + + +btQuaternion *_wrap_btQuaternion_normalize_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternion *result = 0 ; + btQuaternion *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = (btQuaternion *) &(arg1)->normalize(); + *(btQuaternion **)&_swig_go_result = result; + return _swig_go_result; +} + + +btQuaternion *_wrap_btQuaternion_normalized_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = ((btQuaternion const *)arg1)->normalized(); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +float _wrap_btQuaternion_angle_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternion *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternion *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + result = (btScalar)((btQuaternion const *)arg1)->angle((btQuaternion const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_angleShortestPath_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternion *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternion *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + result = (btScalar)((btQuaternion const *)arg1)->angleShortestPath((btQuaternion const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_getAngle_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = (btScalar)((btQuaternion const *)arg1)->getAngle(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_getAngleShortestPath_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = (btScalar)((btQuaternion const *)arg1)->getAngleShortestPath(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btQuaternion_getAxis_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = ((btQuaternion const *)arg1)->getAxis(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btQuaternion *_wrap_btQuaternion_inverse_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = ((btQuaternion const *)arg1)->inverse(); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +btQuaternion *_wrap_btQuaternion_farthest_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternion *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternion *arg2 = 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + result = ((btQuaternion const *)arg1)->farthest((btQuaternion const &)*arg2); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +btQuaternion *_wrap_btQuaternion_nearest_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternion *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternion *arg2 = 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + result = ((btQuaternion const *)arg1)->nearest((btQuaternion const &)*arg2); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +btQuaternion *_wrap_btQuaternion_slerp_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternion *_swig_go_1, float _swig_go_2) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternion *arg2 = 0 ; + btScalar *arg3 = 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + + result = ((btQuaternion const *)arg1)->slerp((btQuaternion const &)*arg2,(btScalar const &)*arg3); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +btQuaternion *_wrap_btQuaternion_getIdentity_mbt_e879218550ba2e2b() { + btQuaternion *result = 0 ; + btQuaternion *_swig_go_result; + + + result = (btQuaternion *) &btQuaternion::getIdentity(); + *(btQuaternion **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_getW_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = (btScalar *) &((btQuaternion const *)arg1)->getW(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_btQuaternion_serialize_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternionFloatData *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternionFloatData *arg2 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternionFloatData **)&_swig_go_1; + + ((btQuaternion const *)arg1)->serialize(*arg2); + +} + + +void _wrap_btQuaternion_deSerialize__SWIG_0_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternionFloatData *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternionFloatData *arg2 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternionFloatData **)&_swig_go_1; + + (arg1)->deSerialize((btQuaternionFloatData const &)*arg2); + +} + + +void _wrap_btQuaternion_deSerialize__SWIG_1_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternionDoubleData *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternionDoubleData *arg2 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternionDoubleData **)&_swig_go_1; + + (arg1)->deSerialize((btQuaternionDoubleData const &)*arg2); + +} + + +void _wrap_btQuaternion_serializeFloat_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternionFloatData *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternionFloatData *arg2 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternionFloatData **)&_swig_go_1; + + ((btQuaternion const *)arg1)->serializeFloat(*arg2); + +} + + +void _wrap_btQuaternion_deSerializeFloat_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternionFloatData *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternionFloatData *arg2 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternionFloatData **)&_swig_go_1; + + (arg1)->deSerializeFloat((btQuaternionFloatData const &)*arg2); + +} + + +void _wrap_btQuaternion_serializeDouble_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternionDoubleData *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternionDoubleData *arg2 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternionDoubleData **)&_swig_go_1; + + ((btQuaternion const *)arg1)->serializeDouble(*arg2); + +} + + +void _wrap_btQuaternion_deSerializeDouble_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternionDoubleData *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuaternionDoubleData *arg2 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternionDoubleData **)&_swig_go_1; + + (arg1)->deSerializeDouble((btQuaternionDoubleData const &)*arg2); + +} + + +void _wrap_delete_btQuaternion_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + + delete arg1; + +} + + +float _wrap_btQuaternion_getX_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + result = (btScalar *) &((btQuadWord const *)swig_b0)->getX(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_getY_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + result = (btScalar *) &((btQuadWord const *)swig_b0)->getY(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_getZ_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + result = (btScalar *) &((btQuadWord const *)swig_b0)->getZ(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_btQuaternion_setX_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, float _swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar arg2 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + (swig_b0)->setX(arg2); + +} + + +void _wrap_btQuaternion_setY_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, float _swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar arg2 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + (swig_b0)->setY(arg2); + +} + + +void _wrap_btQuaternion_setZ_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, float _swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar arg2 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + (swig_b0)->setZ(arg2); + +} + + +void _wrap_btQuaternion_setW_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, float _swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar arg2 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + (swig_b0)->setW(arg2); + +} + + +float _wrap_btQuaternion_x_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + result = (btScalar *) &((btQuadWord const *)swig_b0)->x(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_y_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + result = (btScalar *) &((btQuadWord const *)swig_b0)->y(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_z_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + result = (btScalar *) &((btQuadWord const *)swig_b0)->z(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_btQuaternion_w_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + result = (btScalar *) &((btQuadWord const *)swig_b0)->w(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_btQuaternion_setValue__SWIG_0_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + (swig_b0)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); + +} + + +void _wrap_btQuaternion_setValue__SWIG_1_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + arg5 = (btScalar *)&_swig_go_4; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + (swig_b0)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4,(btScalar const &)*arg5); + +} + + +void _wrap_btQuaternion_setMax_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuadWord *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuadWord *arg2 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuadWord **)&_swig_go_1; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + (swig_b0)->setMax((btQuadWord const &)*arg2); + +} + + +void _wrap_btQuaternion_setMin_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuadWord *_swig_go_1) { + btQuaternion *arg1 = (btQuaternion *) 0 ; + btQuadWord *arg2 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuadWord **)&_swig_go_1; + + btQuadWord *swig_b0 = (btQuadWord *)arg1; + (swig_b0)->setMin((btQuadWord const &)*arg2); + +} + + +float _wrap_dot_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternion *_swig_go_1) { + btQuaternion *arg1 = 0 ; + btQuaternion *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + result = (btScalar)dot((btQuaternion const &)*arg1,(btQuaternion const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_length_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = (btScalar)length((btQuaternion const &)*arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAngle__SWIG_1_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternion *_swig_go_1) { + btQuaternion *arg1 = 0 ; + btQuaternion *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + result = (btScalar)btAngle((btQuaternion const &)*arg1,(btQuaternion const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btQuaternion *_wrap_inverse_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = inverse((btQuaternion const &)*arg1); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +btQuaternion *_wrap_slerp_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternion *_swig_go_1, float _swig_go_2) { + btQuaternion *arg1 = 0 ; + btQuaternion *arg2 = 0 ; + btScalar *arg3 = 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + + result = slerp((btQuaternion const &)*arg1,(btQuaternion const &)*arg2,(float const &)*arg3); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +btVector3 *_wrap_quatRotate_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btVector3 *_swig_go_1) { + btQuaternion *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = quatRotate((btQuaternion const &)*arg1,(btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btQuaternion *_wrap_shortestArcQuat_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = shortestArcQuat((btVector3 const &)*arg1,(btVector3 const &)*arg2); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +btQuaternion *_wrap_shortestArcQuatNormalize2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = shortestArcQuatNormalize2(*arg1,*arg2); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +void _wrap_btQuaternionFloatData_m_floats_set_mbt_e879218550ba2e2b(btQuaternionFloatData *_swig_go_0, float *_swig_go_1) { + btQuaternionFloatData *arg1 = (btQuaternionFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btQuaternionFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_floats; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btQuaternionFloatData_m_floats_get_mbt_e879218550ba2e2b(btQuaternionFloatData *_swig_go_0) { + btQuaternionFloatData *arg1 = (btQuaternionFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btQuaternionFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_floats); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +btQuaternionFloatData *_wrap_new_btQuaternionFloatData_mbt_e879218550ba2e2b() { + btQuaternionFloatData *result = 0 ; + btQuaternionFloatData *_swig_go_result; + + + result = (btQuaternionFloatData *)new btQuaternionFloatData(); + *(btQuaternionFloatData **)&_swig_go_result = (btQuaternionFloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btQuaternionFloatData_mbt_e879218550ba2e2b(btQuaternionFloatData *_swig_go_0) { + btQuaternionFloatData *arg1 = (btQuaternionFloatData *) 0 ; + + arg1 = *(btQuaternionFloatData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btQuaternionDoubleData_m_floats_set_mbt_e879218550ba2e2b(btQuaternionDoubleData *_swig_go_0, double *_swig_go_1) { + btQuaternionDoubleData *arg1 = (btQuaternionDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btQuaternionDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_floats; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btQuaternionDoubleData_m_floats_get_mbt_e879218550ba2e2b(btQuaternionDoubleData *_swig_go_0) { + btQuaternionDoubleData *arg1 = (btQuaternionDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btQuaternionDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_floats); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +btQuaternionDoubleData *_wrap_new_btQuaternionDoubleData_mbt_e879218550ba2e2b() { + btQuaternionDoubleData *result = 0 ; + btQuaternionDoubleData *_swig_go_result; + + + result = (btQuaternionDoubleData *)new btQuaternionDoubleData(); + *(btQuaternionDoubleData **)&_swig_go_result = (btQuaternionDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btQuaternionDoubleData_mbt_e879218550ba2e2b(btQuaternionDoubleData *_swig_go_0) { + btQuaternionDoubleData *arg1 = (btQuaternionDoubleData *) 0 ; + + arg1 = *(btQuaternionDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +btMatrix3x3 *_wrap_new_btMatrix3x3__SWIG_0_mbt_e879218550ba2e2b() { + btMatrix3x3 *result = 0 ; + btMatrix3x3 *_swig_go_result; + + + result = (btMatrix3x3 *)new btMatrix3x3(); + *(btMatrix3x3 **)&_swig_go_result = (btMatrix3x3 *)result; + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_new_btMatrix3x3__SWIG_1_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = 0 ; + btMatrix3x3 *result = 0 ; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = (btMatrix3x3 *)new btMatrix3x3((btQuaternion const &)*arg1); + *(btMatrix3x3 **)&_swig_go_result = (btMatrix3x3 *)result; + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_new_btMatrix3x3__SWIG_2_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, float _swig_go_8) { + btScalar *arg1 = 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btScalar *arg6 = 0 ; + btScalar *arg7 = 0 ; + btScalar *arg8 = 0 ; + btScalar *arg9 = 0 ; + btMatrix3x3 *result = 0 ; + btMatrix3x3 *_swig_go_result; + + arg1 = (btScalar *)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + arg5 = (btScalar *)&_swig_go_4; + arg6 = (btScalar *)&_swig_go_5; + arg7 = (btScalar *)&_swig_go_6; + arg8 = (btScalar *)&_swig_go_7; + arg9 = (btScalar *)&_swig_go_8; + + result = (btMatrix3x3 *)new btMatrix3x3((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4,(btScalar const &)*arg5,(btScalar const &)*arg6,(btScalar const &)*arg7,(btScalar const &)*arg8,(btScalar const &)*arg9); + *(btMatrix3x3 **)&_swig_go_result = (btMatrix3x3 *)result; + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_new_btMatrix3x3__SWIG_3_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0) { + btMatrix3x3 *arg1 = 0 ; + btMatrix3x3 *result = 0 ; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + + result = (btMatrix3x3 *)new btMatrix3x3((btMatrix3x3 const &)*arg1); + *(btMatrix3x3 **)&_swig_go_result = (btMatrix3x3 *)result; + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_new_btMatrix3x3__SWIG_4_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btMatrix3x3 *result = 0 ; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (btMatrix3x3 *)new btMatrix3x3((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); + *(btMatrix3x3 **)&_swig_go_result = (btMatrix3x3 *)result; + return _swig_go_result; +} + + +btVector3 *_wrap_btMatrix3x3_getColumn_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, intgo _swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + int arg2 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = ((btMatrix3x3 const *)arg1)->getColumn(arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btMatrix3x3_getRow_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, intgo _swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + int arg2 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btVector3 *) &((btMatrix3x3 const *)arg1)->getRow(arg2); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btMatrix3x3_setFromOpenGLSubMatrix_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, float *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btScalar *arg2 = (btScalar *) 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + (arg1)->setFromOpenGLSubMatrix((btScalar const *)arg2); + +} + + +void _wrap_btMatrix3x3_setValue_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, float _swig_go_8, float _swig_go_9) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btScalar *arg6 = 0 ; + btScalar *arg7 = 0 ; + btScalar *arg8 = 0 ; + btScalar *arg9 = 0 ; + btScalar *arg10 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + arg5 = (btScalar *)&_swig_go_4; + arg6 = (btScalar *)&_swig_go_5; + arg7 = (btScalar *)&_swig_go_6; + arg8 = (btScalar *)&_swig_go_7; + arg9 = (btScalar *)&_swig_go_8; + arg10 = (btScalar *)&_swig_go_9; + + (arg1)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4,(btScalar const &)*arg5,(btScalar const &)*arg6,(btScalar const &)*arg7,(btScalar const &)*arg8,(btScalar const &)*arg9,(btScalar const &)*arg10); + +} + + +void _wrap_btMatrix3x3_setRotation_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btQuaternion *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btQuaternion *arg2 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + (arg1)->setRotation((btQuaternion const &)*arg2); + +} + + +void _wrap_btMatrix3x3_setEulerYPR_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + + (arg1)->setEulerYPR((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); + +} + + +void _wrap_btMatrix3x3_setEulerZYX_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar arg4 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->setEulerZYX(arg2,arg3,arg4); + +} + + +void _wrap_btMatrix3x3_setIdentity_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + + (arg1)->setIdentity(); + +} + + +void _wrap_btMatrix3x3_setZero_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + + (arg1)->setZero(); + +} + + +btMatrix3x3 *_wrap_btMatrix3x3_getIdentity_mbt_e879218550ba2e2b() { + btMatrix3x3 *result = 0 ; + btMatrix3x3 *_swig_go_result; + + + result = (btMatrix3x3 *) &btMatrix3x3::getIdentity(); + *(btMatrix3x3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btMatrix3x3_getOpenGLSubMatrix_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, float *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btScalar *arg2 = (btScalar *) 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + ((btMatrix3x3 const *)arg1)->getOpenGLSubMatrix(arg2); + +} + + +void _wrap_btMatrix3x3_getRotation_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btQuaternion *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btQuaternion *arg2 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + ((btMatrix3x3 const *)arg1)->getRotation(*arg2); + +} + + +void _wrap_btMatrix3x3_getEulerYPR_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, float *_swig_go_1, float *_swig_go_2, float *_swig_go_3) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + ((btMatrix3x3 const *)arg1)->getEulerYPR(*arg2,*arg3,*arg4); + +} + + +void _wrap_btMatrix3x3_getEulerZYX__SWIG_0_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, float *_swig_go_1, float *_swig_go_2, float *_swig_go_3, intgo _swig_go_4) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + unsigned int arg5 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = (unsigned int)_swig_go_4; + + ((btMatrix3x3 const *)arg1)->getEulerZYX(*arg2,*arg3,*arg4,arg5); + +} + + +void _wrap_btMatrix3x3_getEulerZYX__SWIG_1_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, float *_swig_go_1, float *_swig_go_2, float *_swig_go_3) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + ((btMatrix3x3 const *)arg1)->getEulerZYX(*arg2,*arg3,*arg4); + +} + + +btMatrix3x3 *_wrap_btMatrix3x3_scaled_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btVector3 *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btVector3 *arg2 = 0 ; + btMatrix3x3 result; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btMatrix3x3 const *)arg1)->scaled((btVector3 const &)*arg2); + *(btMatrix3x3 **)&_swig_go_result = new btMatrix3x3(result); + return _swig_go_result; +} + + +float _wrap_btMatrix3x3_determinant_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + + result = (btScalar)((btMatrix3x3 const *)arg1)->determinant(); + _swig_go_result = result; + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_btMatrix3x3_adjoint_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3 result; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + + result = ((btMatrix3x3 const *)arg1)->adjoint(); + *(btMatrix3x3 **)&_swig_go_result = new btMatrix3x3(result); + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_btMatrix3x3_absolute_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3 result; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + + result = ((btMatrix3x3 const *)arg1)->absolute(); + *(btMatrix3x3 **)&_swig_go_result = new btMatrix3x3(result); + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_btMatrix3x3_transpose_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3 result; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + + result = ((btMatrix3x3 const *)arg1)->transpose(); + *(btMatrix3x3 **)&_swig_go_result = new btMatrix3x3(result); + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_btMatrix3x3_inverse_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3 result; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + + result = ((btMatrix3x3 const *)arg1)->inverse(); + *(btMatrix3x3 **)&_swig_go_result = new btMatrix3x3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btMatrix3x3_solve33_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btVector3 *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btMatrix3x3 const *)arg1)->solve33((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_btMatrix3x3_transposeTimes_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btMatrix3x3 *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3 *arg2 = 0 ; + btMatrix3x3 result; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btMatrix3x3 **)&_swig_go_1; + + result = ((btMatrix3x3 const *)arg1)->transposeTimes((btMatrix3x3 const &)*arg2); + *(btMatrix3x3 **)&_swig_go_result = new btMatrix3x3(result); + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_btMatrix3x3_timesTranspose_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btMatrix3x3 *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3 *arg2 = 0 ; + btMatrix3x3 result; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btMatrix3x3 **)&_swig_go_1; + + result = ((btMatrix3x3 const *)arg1)->timesTranspose((btMatrix3x3 const &)*arg2); + *(btMatrix3x3 **)&_swig_go_result = new btMatrix3x3(result); + return _swig_go_result; +} + + +float _wrap_btMatrix3x3_tdotx_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btVector3 *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)((btMatrix3x3 const *)arg1)->tdotx((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btMatrix3x3_tdoty_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btVector3 *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)((btMatrix3x3 const *)arg1)->tdoty((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btMatrix3x3_tdotz_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btVector3 *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)((btMatrix3x3 const *)arg1)->tdotz((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btMatrix3x3_extractRotation__SWIG_0_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btQuaternion *_swig_go_1, float _swig_go_2, intgo _swig_go_3) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btQuaternion *arg2 = 0 ; + btScalar arg3 ; + int arg4 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->extractRotation(*arg2,arg3,arg4); + +} + + +void _wrap_btMatrix3x3_extractRotation__SWIG_1_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btQuaternion *_swig_go_1, float _swig_go_2) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btQuaternion *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->extractRotation(*arg2,arg3); + +} + + +void _wrap_btMatrix3x3_extractRotation__SWIG_2_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btQuaternion *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btQuaternion *arg2 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + (arg1)->extractRotation(*arg2); + +} + + +void _wrap_btMatrix3x3_diagonalize_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btMatrix3x3 *_swig_go_1, float _swig_go_2, intgo _swig_go_3) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3 *arg2 = 0 ; + btScalar arg3 ; + int arg4 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btMatrix3x3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->diagonalize(*arg2,arg3,arg4); + +} + + +float _wrap_btMatrix3x3_cofac_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2, intgo _swig_go_3, intgo _swig_go_4) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + int arg5 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (int)_swig_go_4; + + result = (btScalar)((btMatrix3x3 const *)arg1)->cofac(arg2,arg3,arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btMatrix3x3_serialize_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btMatrix3x3FloatData *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3FloatData *arg2 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btMatrix3x3FloatData **)&_swig_go_1; + + ((btMatrix3x3 const *)arg1)->serialize(*arg2); + +} + + +void _wrap_btMatrix3x3_serializeFloat_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btMatrix3x3FloatData *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3FloatData *arg2 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btMatrix3x3FloatData **)&_swig_go_1; + + ((btMatrix3x3 const *)arg1)->serializeFloat(*arg2); + +} + + +void _wrap_btMatrix3x3_deSerialize_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btMatrix3x3FloatData *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3FloatData *arg2 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btMatrix3x3FloatData **)&_swig_go_1; + + (arg1)->deSerialize((btMatrix3x3FloatData const &)*arg2); + +} + + +void _wrap_btMatrix3x3_deSerializeFloat_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btMatrix3x3FloatData *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3FloatData *arg2 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btMatrix3x3FloatData **)&_swig_go_1; + + (arg1)->deSerializeFloat((btMatrix3x3FloatData const &)*arg2); + +} + + +void _wrap_btMatrix3x3_deSerializeDouble_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btMatrix3x3DoubleData *_swig_go_1) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + btMatrix3x3DoubleData *arg2 = 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btMatrix3x3DoubleData **)&_swig_go_1; + + (arg1)->deSerializeDouble((btMatrix3x3DoubleData const &)*arg2); + +} + + +void _wrap_delete_btMatrix3x3_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0) { + btMatrix3x3 *arg1 = (btMatrix3x3 *) 0 ; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btMatrix3x3FloatData_m_el_set_mbt_e879218550ba2e2b(btMatrix3x3FloatData *_swig_go_0, btVector3FloatData (*_swig_go_1)[3]) { + btMatrix3x3FloatData *arg1 = (btMatrix3x3FloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) (btVector3FloatData *)0 ; + + arg1 = *(btMatrix3x3FloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + { + size_t ii; + btVector3FloatData *b = (btVector3FloatData *) arg1->m_el; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((btVector3FloatData *) arg2 + ii); + } + +} + + +btVector3FloatData (*_wrap_btMatrix3x3FloatData_m_el_get_mbt_e879218550ba2e2b(btMatrix3x3FloatData *_swig_go_0))[3] { + btMatrix3x3FloatData *arg1 = (btMatrix3x3FloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData (*_swig_go_result)[3]; + + arg1 = *(btMatrix3x3FloatData **)&_swig_go_0; + + result = (btVector3FloatData *)(btVector3FloatData *) ((arg1)->m_el); + *(btVector3FloatData **)&_swig_go_result = result; + return _swig_go_result; +} + + +btMatrix3x3FloatData *_wrap_new_btMatrix3x3FloatData_mbt_e879218550ba2e2b() { + btMatrix3x3FloatData *result = 0 ; + btMatrix3x3FloatData *_swig_go_result; + + + result = (btMatrix3x3FloatData *)new btMatrix3x3FloatData(); + *(btMatrix3x3FloatData **)&_swig_go_result = (btMatrix3x3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btMatrix3x3FloatData_mbt_e879218550ba2e2b(btMatrix3x3FloatData *_swig_go_0) { + btMatrix3x3FloatData *arg1 = (btMatrix3x3FloatData *) 0 ; + + arg1 = *(btMatrix3x3FloatData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btMatrix3x3DoubleData_m_el_set_mbt_e879218550ba2e2b(btMatrix3x3DoubleData *_swig_go_0, btVector3DoubleData (*_swig_go_1)[3]) { + btMatrix3x3DoubleData *arg1 = (btMatrix3x3DoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) (btVector3DoubleData *)0 ; + + arg1 = *(btMatrix3x3DoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + { + size_t ii; + btVector3DoubleData *b = (btVector3DoubleData *) arg1->m_el; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((btVector3DoubleData *) arg2 + ii); + } + +} + + +btVector3DoubleData (*_wrap_btMatrix3x3DoubleData_m_el_get_mbt_e879218550ba2e2b(btMatrix3x3DoubleData *_swig_go_0))[3] { + btMatrix3x3DoubleData *arg1 = (btMatrix3x3DoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData (*_swig_go_result)[3]; + + arg1 = *(btMatrix3x3DoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)(btVector3DoubleData *) ((arg1)->m_el); + *(btVector3DoubleData **)&_swig_go_result = result; + return _swig_go_result; +} + + +btMatrix3x3DoubleData *_wrap_new_btMatrix3x3DoubleData_mbt_e879218550ba2e2b() { + btMatrix3x3DoubleData *result = 0 ; + btMatrix3x3DoubleData *_swig_go_result; + + + result = (btMatrix3x3DoubleData *)new btMatrix3x3DoubleData(); + *(btMatrix3x3DoubleData **)&_swig_go_result = (btMatrix3x3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btMatrix3x3DoubleData_mbt_e879218550ba2e2b(btMatrix3x3DoubleData *_swig_go_0) { + btMatrix3x3DoubleData *arg1 = (btMatrix3x3DoubleData *) 0 ; + + arg1 = *(btMatrix3x3DoubleData **)&_swig_go_0; + + delete arg1; + +} + + +btTransform *_wrap_new_btTransform__SWIG_0_mbt_e879218550ba2e2b() { + btTransform *result = 0 ; + btTransform *_swig_go_result; + + + result = (btTransform *)new btTransform(); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +btTransform *_wrap_new_btTransform__SWIG_1_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btVector3 *_swig_go_1) { + btQuaternion *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btTransform *)new btTransform((btQuaternion const &)*arg1,(btVector3 const &)*arg2); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +btTransform *_wrap_new_btTransform__SWIG_2_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0) { + btQuaternion *arg1 = 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btQuaternion **)&_swig_go_0; + + result = (btTransform *)new btTransform((btQuaternion const &)*arg1); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +btTransform *_wrap_new_btTransform__SWIG_3_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btVector3 *_swig_go_1) { + btMatrix3x3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btTransform *)new btTransform((btMatrix3x3 const &)*arg1,(btVector3 const &)*arg2); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +btTransform *_wrap_new_btTransform__SWIG_4_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0) { + btMatrix3x3 *arg1 = 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + + result = (btTransform *)new btTransform((btMatrix3x3 const &)*arg1); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +btTransform *_wrap_new_btTransform__SWIG_5_mbt_e879218550ba2e2b(btTransform *_swig_go_0) { + btTransform *arg1 = 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + + result = (btTransform *)new btTransform((btTransform const &)*arg1); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btTransform_mult_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2) { + btTransform *arg1 = (btTransform *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + + (arg1)->mult((btTransform const &)*arg2,(btTransform const &)*arg3); + +} + + +btMatrix3x3 *_wrap_btTransform_getBasis__SWIG_0_mbt_e879218550ba2e2b(btTransform *_swig_go_0) { + btTransform *arg1 = (btTransform *) 0 ; + btMatrix3x3 *result = 0 ; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + + result = (btMatrix3x3 *) &(arg1)->getBasis(); + *(btMatrix3x3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_btTransform_getBasis__SWIG_1_mbt_e879218550ba2e2b(btTransform *_swig_go_0) { + btTransform *arg1 = (btTransform *) 0 ; + btMatrix3x3 *result = 0 ; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + + result = (btMatrix3x3 *) &((btTransform const *)arg1)->getBasis(); + *(btMatrix3x3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btTransform_getOrigin__SWIG_0_mbt_e879218550ba2e2b(btTransform *_swig_go_0) { + btTransform *arg1 = (btTransform *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + + result = (btVector3 *) &(arg1)->getOrigin(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btTransform_getOrigin__SWIG_1_mbt_e879218550ba2e2b(btTransform *_swig_go_0) { + btTransform *arg1 = (btTransform *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + + result = (btVector3 *) &((btTransform const *)arg1)->getOrigin(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btQuaternion *_wrap_btTransform_getRotation_mbt_e879218550ba2e2b(btTransform *_swig_go_0) { + btTransform *arg1 = (btTransform *) 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + + result = ((btTransform const *)arg1)->getRotation(); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +void _wrap_btTransform_setFromOpenGLMatrix_mbt_e879218550ba2e2b(btTransform *_swig_go_0, float *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btScalar *arg2 = (btScalar *) 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + (arg1)->setFromOpenGLMatrix((btScalar const *)arg2); + +} + + +void _wrap_btTransform_getOpenGLMatrix_mbt_e879218550ba2e2b(btTransform *_swig_go_0, float *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btScalar *arg2 = (btScalar *) 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + ((btTransform const *)arg1)->getOpenGLMatrix(arg2); + +} + + +void _wrap_btTransform_setOrigin_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btVector3 *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setOrigin((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btTransform_invXform_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btVector3 *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btTransform const *)arg1)->invXform((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btTransform_setBasis_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btMatrix3x3 *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btMatrix3x3 *arg2 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btMatrix3x3 **)&_swig_go_1; + + (arg1)->setBasis((btMatrix3x3 const &)*arg2); + +} + + +void _wrap_btTransform_setRotation_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btQuaternion *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btQuaternion *arg2 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + (arg1)->setRotation((btQuaternion const &)*arg2); + +} + + +void _wrap_btTransform_setIdentity_mbt_e879218550ba2e2b(btTransform *_swig_go_0) { + btTransform *arg1 = (btTransform *) 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + + (arg1)->setIdentity(); + +} + + +btTransform *_wrap_btTransform_inverse_mbt_e879218550ba2e2b(btTransform *_swig_go_0) { + btTransform *arg1 = (btTransform *) 0 ; + btTransform result; + btTransform *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + + result = ((btTransform const *)arg1)->inverse(); + *(btTransform **)&_swig_go_result = new btTransform(result); + return _swig_go_result; +} + + +btTransform *_wrap_btTransform_inverseTimes_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btTransform *arg2 = 0 ; + btTransform result; + btTransform *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + result = ((btTransform const *)arg1)->inverseTimes((btTransform const &)*arg2); + *(btTransform **)&_swig_go_result = new btTransform(result); + return _swig_go_result; +} + + +btTransform *_wrap_btTransform_getIdentity_mbt_e879218550ba2e2b() { + btTransform *result = 0 ; + btTransform *_swig_go_result; + + + result = (btTransform *) &btTransform::getIdentity(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTransform_serialize_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransformFloatData *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btTransformFloatData *arg2 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransformFloatData **)&_swig_go_1; + + ((btTransform const *)arg1)->serialize(*arg2); + +} + + +void _wrap_btTransform_serializeFloat_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransformFloatData *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btTransformFloatData *arg2 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransformFloatData **)&_swig_go_1; + + ((btTransform const *)arg1)->serializeFloat(*arg2); + +} + + +void _wrap_btTransform_deSerialize_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransformFloatData *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btTransformFloatData *arg2 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransformFloatData **)&_swig_go_1; + + (arg1)->deSerialize((btTransformFloatData const &)*arg2); + +} + + +void _wrap_btTransform_deSerializeDouble_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransformDoubleData *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btTransformDoubleData *arg2 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransformDoubleData **)&_swig_go_1; + + (arg1)->deSerializeDouble((btTransformDoubleData const &)*arg2); + +} + + +void _wrap_btTransform_deSerializeFloat_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransformFloatData *_swig_go_1) { + btTransform *arg1 = (btTransform *) 0 ; + btTransformFloatData *arg2 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransformFloatData **)&_swig_go_1; + + (arg1)->deSerializeFloat((btTransformFloatData const &)*arg2); + +} + + +void _wrap_delete_btTransform_mbt_e879218550ba2e2b(btTransform *_swig_go_0) { + btTransform *arg1 = (btTransform *) 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btTransformFloatData_m_basis_set_mbt_e879218550ba2e2b(btTransformFloatData *_swig_go_0, btMatrix3x3FloatData *_swig_go_1) { + btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; + btMatrix3x3FloatData *arg2 = (btMatrix3x3FloatData *) 0 ; + + arg1 = *(btTransformFloatData **)&_swig_go_0; + arg2 = *(btMatrix3x3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_basis = *arg2; + +} + + +btMatrix3x3FloatData *_wrap_btTransformFloatData_m_basis_get_mbt_e879218550ba2e2b(btTransformFloatData *_swig_go_0) { + btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; + btMatrix3x3FloatData *result = 0 ; + btMatrix3x3FloatData *_swig_go_result; + + arg1 = *(btTransformFloatData **)&_swig_go_0; + + result = (btMatrix3x3FloatData *)& ((arg1)->m_basis); + *(btMatrix3x3FloatData **)&_swig_go_result = (btMatrix3x3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btTransformFloatData_m_origin_set_mbt_e879218550ba2e2b(btTransformFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btTransformFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_origin = *arg2; + +} + + +btVector3FloatData *_wrap_btTransformFloatData_m_origin_get_mbt_e879218550ba2e2b(btTransformFloatData *_swig_go_0) { + btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btTransformFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_origin); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +btTransformFloatData *_wrap_new_btTransformFloatData_mbt_e879218550ba2e2b() { + btTransformFloatData *result = 0 ; + btTransformFloatData *_swig_go_result; + + + result = (btTransformFloatData *)new btTransformFloatData(); + *(btTransformFloatData **)&_swig_go_result = (btTransformFloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btTransformFloatData_mbt_e879218550ba2e2b(btTransformFloatData *_swig_go_0) { + btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; + + arg1 = *(btTransformFloatData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btTransformDoubleData_m_basis_set_mbt_e879218550ba2e2b(btTransformDoubleData *_swig_go_0, btMatrix3x3DoubleData *_swig_go_1) { + btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; + btMatrix3x3DoubleData *arg2 = (btMatrix3x3DoubleData *) 0 ; + + arg1 = *(btTransformDoubleData **)&_swig_go_0; + arg2 = *(btMatrix3x3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_basis = *arg2; + +} + + +btMatrix3x3DoubleData *_wrap_btTransformDoubleData_m_basis_get_mbt_e879218550ba2e2b(btTransformDoubleData *_swig_go_0) { + btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; + btMatrix3x3DoubleData *result = 0 ; + btMatrix3x3DoubleData *_swig_go_result; + + arg1 = *(btTransformDoubleData **)&_swig_go_0; + + result = (btMatrix3x3DoubleData *)& ((arg1)->m_basis); + *(btMatrix3x3DoubleData **)&_swig_go_result = (btMatrix3x3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btTransformDoubleData_m_origin_set_mbt_e879218550ba2e2b(btTransformDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btTransformDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_origin = *arg2; + +} + + +btVector3DoubleData *_wrap_btTransformDoubleData_m_origin_get_mbt_e879218550ba2e2b(btTransformDoubleData *_swig_go_0) { + btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btTransformDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_origin); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +btTransformDoubleData *_wrap_new_btTransformDoubleData_mbt_e879218550ba2e2b() { + btTransformDoubleData *result = 0 ; + btTransformDoubleData *_swig_go_result; + + + result = (btTransformDoubleData *)new btTransformDoubleData(); + *(btTransformDoubleData **)&_swig_go_result = (btTransformDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btTransformDoubleData_mbt_e879218550ba2e2b(btTransformDoubleData *_swig_go_0) { + btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; + + arg1 = *(btTransformDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_delete_btMotionState_mbt_e879218550ba2e2b(btMotionState *_swig_go_0) { + btMotionState *arg1 = (btMotionState *) 0 ; + + arg1 = *(btMotionState **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btMotionState_getWorldTransform_mbt_e879218550ba2e2b(btMotionState *_swig_go_0, btTransform *_swig_go_1) { + btMotionState *arg1 = (btMotionState *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btMotionState **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + ((btMotionState const *)arg1)->getWorldTransform(*arg2); + +} + + +void _wrap_btMotionState_setWorldTransform_mbt_e879218550ba2e2b(btMotionState *_swig_go_0, btTransform *_swig_go_1) { + btMotionState *arg1 = (btMotionState *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btMotionState **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + (arg1)->setWorldTransform((btTransform const &)*arg2); + +} + + +void _wrap_btDefaultMotionState_m_graphicsWorldTrans_set_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0, btTransform *_swig_go_1) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_graphicsWorldTrans = *arg2; + +} + + +btTransform *_wrap_btDefaultMotionState_m_graphicsWorldTrans_get_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_graphicsWorldTrans); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btDefaultMotionState_m_centerOfMassOffset_set_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0, btTransform *_swig_go_1) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_centerOfMassOffset = *arg2; + +} + + +btTransform *_wrap_btDefaultMotionState_m_centerOfMassOffset_get_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_centerOfMassOffset); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btDefaultMotionState_m_startWorldTrans_set_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0, btTransform *_swig_go_1) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_startWorldTrans = *arg2; + +} + + +btTransform *_wrap_btDefaultMotionState_m_startWorldTrans_get_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_startWorldTrans); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btDefaultMotionState_m_userPointer_set_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0, void *_swig_go_1) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + if (arg1) (arg1)->m_userPointer = arg2; + +} + + +void *_wrap_btDefaultMotionState_m_userPointer_get_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + + result = (void *) ((arg1)->m_userPointer); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +btDefaultMotionState *_wrap_new_btDefaultMotionState__SWIG_0_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1) { + btTransform *arg1 = 0 ; + btTransform *arg2 = 0 ; + btDefaultMotionState *result = 0 ; + btDefaultMotionState *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + result = (btDefaultMotionState *)new btDefaultMotionState((btTransform const &)*arg1,(btTransform const &)*arg2); + *(btDefaultMotionState **)&_swig_go_result = (btDefaultMotionState *)result; + return _swig_go_result; +} + + +btDefaultMotionState *_wrap_new_btDefaultMotionState__SWIG_1_mbt_e879218550ba2e2b(btTransform *_swig_go_0) { + btTransform *arg1 = 0 ; + btDefaultMotionState *result = 0 ; + btDefaultMotionState *_swig_go_result; + + arg1 = *(btTransform **)&_swig_go_0; + + result = (btDefaultMotionState *)new btDefaultMotionState((btTransform const &)*arg1); + *(btDefaultMotionState **)&_swig_go_result = (btDefaultMotionState *)result; + return _swig_go_result; +} + + +btDefaultMotionState *_wrap_new_btDefaultMotionState__SWIG_2_mbt_e879218550ba2e2b() { + btDefaultMotionState *result = 0 ; + btDefaultMotionState *_swig_go_result; + + + result = (btDefaultMotionState *)new btDefaultMotionState(); + *(btDefaultMotionState **)&_swig_go_result = (btDefaultMotionState *)result; + return _swig_go_result; +} + + +void _wrap_btDefaultMotionState_getWorldTransform_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0, btTransform *_swig_go_1) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + ((btDefaultMotionState const *)arg1)->getWorldTransform(*arg2); + +} + + +void _wrap_btDefaultMotionState_setWorldTransform_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0, btTransform *_swig_go_1) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + (arg1)->setWorldTransform((btTransform const &)*arg2); + +} + + +void _wrap_delete_btDefaultMotionState_mbt_e879218550ba2e2b(btDefaultMotionState *_swig_go_0) { + btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; + + arg1 = *(btDefaultMotionState **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_BOX_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = BOX_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_TRIANGLE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = TRIANGLE_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_TETRAHEDRAL_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = TETRAHEDRAL_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CONVEX_HULL_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CONVEX_HULL_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CUSTOM_POLYHEDRAL_SHAPE_TYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CUSTOM_POLYHEDRAL_SHAPE_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_IMPLICIT_CONVEX_SHAPES_START_HERE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = IMPLICIT_CONVEX_SHAPES_START_HERE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SPHERE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = SPHERE_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_MULTI_SPHERE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = MULTI_SPHERE_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CAPSULE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CAPSULE_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CONE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CONE_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CONVEX_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CONVEX_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CYLINDER_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CYLINDER_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_UNIFORM_SCALING_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = UNIFORM_SCALING_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_MINKOWSKI_SUM_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = MINKOWSKI_SUM_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BOX_2D_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = BOX_2D_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CONVEX_2D_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CONVEX_2D_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CUSTOM_CONVEX_SHAPE_TYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CUSTOM_CONVEX_SHAPE_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CONCAVE_SHAPES_START_HERE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CONCAVE_SHAPES_START_HERE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_TRIANGLE_MESH_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = TRIANGLE_MESH_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_FAST_CONCAVE_MESH_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = FAST_CONCAVE_MESH_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_TERRAIN_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = TERRAIN_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_GIMPACT_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = GIMPACT_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_EMPTY_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = EMPTY_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_STATIC_PLANE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = STATIC_PLANE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CUSTOM_CONCAVE_SHAPE_TYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CUSTOM_CONCAVE_SHAPE_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SDF_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = SDF_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CONCAVE_SHAPES_END_HERE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = CONCAVE_SHAPES_END_HERE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_COMPOUND_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = COMPOUND_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOFTBODY_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = SOFTBODY_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_HFFLUID_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = HFFLUID_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_INVALID_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = INVALID_SHAPE_PROXYTYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_MAX_BROADPHASE_COLLISION_TYPES_mbt_e879218550ba2e2b() { + BroadphaseNativeTypes result; + intgo _swig_go_result; + + + result = MAX_BROADPHASE_COLLISION_TYPES; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DefaultFilter_btBroadphaseProxy_mbt_e879218550ba2e2b() { + btBroadphaseProxy::CollisionFilterGroups result; + intgo _swig_go_result; + + + result = btBroadphaseProxy::DefaultFilter; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_StaticFilter_btBroadphaseProxy_mbt_e879218550ba2e2b() { + btBroadphaseProxy::CollisionFilterGroups result; + intgo _swig_go_result; + + + result = btBroadphaseProxy::StaticFilter; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_KinematicFilter_btBroadphaseProxy_mbt_e879218550ba2e2b() { + btBroadphaseProxy::CollisionFilterGroups result; + intgo _swig_go_result; + + + result = btBroadphaseProxy::KinematicFilter; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DebrisFilter_btBroadphaseProxy_mbt_e879218550ba2e2b() { + btBroadphaseProxy::CollisionFilterGroups result; + intgo _swig_go_result; + + + result = btBroadphaseProxy::DebrisFilter; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SensorTrigger_btBroadphaseProxy_mbt_e879218550ba2e2b() { + btBroadphaseProxy::CollisionFilterGroups result; + intgo _swig_go_result; + + + result = btBroadphaseProxy::SensorTrigger; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CharacterFilter_btBroadphaseProxy_mbt_e879218550ba2e2b() { + btBroadphaseProxy::CollisionFilterGroups result; + intgo _swig_go_result; + + + result = btBroadphaseProxy::CharacterFilter; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_AllFilter_btBroadphaseProxy_mbt_e879218550ba2e2b() { + btBroadphaseProxy::CollisionFilterGroups result; + intgo _swig_go_result; + + + result = btBroadphaseProxy::AllFilter; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseProxy_m_clientObject_set_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0, void *_swig_go_1) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + if (arg1) (arg1)->m_clientObject = arg2; + +} + + +void *_wrap_btBroadphaseProxy_m_clientObject_get_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + + result = (void *) ((arg1)->m_clientObject); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseProxy_m_collisionFilterGroup_set_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0, intgo _swig_go_1) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + int arg2 ; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_collisionFilterGroup = arg2; + +} + + +intgo _wrap_btBroadphaseProxy_m_collisionFilterGroup_get_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + + result = (int) ((arg1)->m_collisionFilterGroup); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseProxy_m_collisionFilterMask_set_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0, intgo _swig_go_1) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + int arg2 ; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_collisionFilterMask = arg2; + +} + + +intgo _wrap_btBroadphaseProxy_m_collisionFilterMask_get_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + + result = (int) ((arg1)->m_collisionFilterMask); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseProxy_m_uniqueId_set_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0, intgo _swig_go_1) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + int arg2 ; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_uniqueId = arg2; + +} + + +intgo _wrap_btBroadphaseProxy_m_uniqueId_get_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + + result = (int) ((arg1)->m_uniqueId); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseProxy_m_aabbMin_set_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0, btVector3 *_swig_go_1) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_aabbMin = *arg2; + +} + + +btVector3 *_wrap_btBroadphaseProxy_m_aabbMin_get_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_aabbMin); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseProxy_m_aabbMax_set_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0, btVector3 *_swig_go_1) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_aabbMax = *arg2; + +} + + +btVector3 *_wrap_btBroadphaseProxy_m_aabbMax_get_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_aabbMax); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +intgo _wrap_btBroadphaseProxy_getUid_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + + result = (int)((btBroadphaseProxy const *)arg1)->getUid(); + _swig_go_result = result; + return _swig_go_result; +} + + +btBroadphaseProxy *_wrap_new_btBroadphaseProxy__SWIG_0_mbt_e879218550ba2e2b() { + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + + result = (btBroadphaseProxy *)new btBroadphaseProxy(); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +btBroadphaseProxy *_wrap_new_btBroadphaseProxy__SWIG_1_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, void *_swig_go_2, intgo _swig_go_3, intgo _swig_go_4) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + void *arg3 = (void *) 0 ; + int arg4 ; + int arg5 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(void **)&_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (int)_swig_go_4; + + result = (btBroadphaseProxy *)new btBroadphaseProxy((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +bool _wrap_btBroadphaseProxy_isPolyhedral_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isPolyhedral(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBroadphaseProxy_isConvex_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isConvex(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBroadphaseProxy_isNonMoving_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isNonMoving(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBroadphaseProxy_isConcave_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isConcave(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBroadphaseProxy_isCompound_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isCompound(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBroadphaseProxy_isSoftBody_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isSoftBody(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBroadphaseProxy_isInfinite_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isInfinite(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBroadphaseProxy_isConvex2d_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isConvex2d(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btBroadphaseProxy_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0) { + btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + + delete arg1; + +} + + +btBroadphasePair *_wrap_new_btBroadphasePair__SWIG_0_mbt_e879218550ba2e2b() { + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + + result = (btBroadphasePair *)new btBroadphasePair(); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +btBroadphasePair *_wrap_new_btBroadphasePair__SWIG_1_mbt_e879218550ba2e2b(btBroadphaseProxy *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btBroadphaseProxy *arg1 = 0 ; + btBroadphaseProxy *arg2 = 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btBroadphaseProxy **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + result = (btBroadphasePair *)new btBroadphasePair(*arg1,*arg2); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +void _wrap_btBroadphasePair_m_pProxy0_set_mbt_e879218550ba2e2b(btBroadphasePair *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + + arg1 = *(btBroadphasePair **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + if (arg1) (arg1)->m_pProxy0 = arg2; + +} + + +btBroadphaseProxy *_wrap_btBroadphasePair_m_pProxy0_get_mbt_e879218550ba2e2b(btBroadphasePair *_swig_go_0) { + btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btBroadphasePair **)&_swig_go_0; + + result = (btBroadphaseProxy *) ((arg1)->m_pProxy0); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +void _wrap_btBroadphasePair_m_pProxy1_set_mbt_e879218550ba2e2b(btBroadphasePair *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + + arg1 = *(btBroadphasePair **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + if (arg1) (arg1)->m_pProxy1 = arg2; + +} + + +btBroadphaseProxy *_wrap_btBroadphasePair_m_pProxy1_get_mbt_e879218550ba2e2b(btBroadphasePair *_swig_go_0) { + btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btBroadphasePair **)&_swig_go_0; + + result = (btBroadphaseProxy *) ((arg1)->m_pProxy1); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +void _wrap_btBroadphasePair_m_algorithm_set_mbt_e879218550ba2e2b(btBroadphasePair *_swig_go_0, btCollisionAlgorithm *_swig_go_1) { + btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; + btCollisionAlgorithm *arg2 = (btCollisionAlgorithm *) 0 ; + + arg1 = *(btBroadphasePair **)&_swig_go_0; + arg2 = *(btCollisionAlgorithm **)&_swig_go_1; + + if (arg1) (arg1)->m_algorithm = arg2; + +} + + +btCollisionAlgorithm *_wrap_btBroadphasePair_m_algorithm_get_mbt_e879218550ba2e2b(btBroadphasePair *_swig_go_0) { + btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; + btCollisionAlgorithm *result = 0 ; + btCollisionAlgorithm *_swig_go_result; + + arg1 = *(btBroadphasePair **)&_swig_go_0; + + result = (btCollisionAlgorithm *) ((arg1)->m_algorithm); + *(btCollisionAlgorithm **)&_swig_go_result = (btCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_delete_btBroadphasePair_mbt_e879218550ba2e2b(btBroadphasePair *_swig_go_0) { + btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; + + arg1 = *(btBroadphasePair **)&_swig_go_0; + + delete arg1; + +} + + +btBroadphasePairSortPredicate *_wrap_new_btBroadphasePairSortPredicate_mbt_e879218550ba2e2b() { + btBroadphasePairSortPredicate *result = 0 ; + btBroadphasePairSortPredicate *_swig_go_result; + + + result = (btBroadphasePairSortPredicate *)new btBroadphasePairSortPredicate(); + *(btBroadphasePairSortPredicate **)&_swig_go_result = (btBroadphasePairSortPredicate *)result; + return _swig_go_result; +} + + +void _wrap_delete_btBroadphasePairSortPredicate_mbt_e879218550ba2e2b(btBroadphasePairSortPredicate *_swig_go_0) { + btBroadphasePairSortPredicate *arg1 = (btBroadphasePairSortPredicate *) 0 ; + + arg1 = *(btBroadphasePairSortPredicate **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_delete_btCollisionShape_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btCollisionShape_getAabb_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btCollisionShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btCollisionShape_getBoundingSphere_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + ((btCollisionShape const *)arg1)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btCollisionShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (btScalar)((btCollisionShape const *)arg1)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCollisionShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, float _swig_go_1) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (btScalar)((btCollisionShape const *)arg1)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + ((btCollisionShape const *)arg1)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btCollisionShape_isPolyhedral_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (bool)((btCollisionShape const *)arg1)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionShape_isConvex2d_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (bool)((btCollisionShape const *)arg1)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionShape_isConvex_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (bool)((btCollisionShape const *)arg1)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionShape_isNonMoving_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (bool)((btCollisionShape const *)arg1)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionShape_isConcave_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (bool)((btCollisionShape const *)arg1)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionShape_isCompound_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (bool)((btCollisionShape const *)arg1)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionShape_isSoftBody_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (bool)((btCollisionShape const *)arg1)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionShape_isInfinite_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (bool)((btCollisionShape const *)arg1)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionShape_setLocalScaling_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, btVector3 *_swig_go_1) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btCollisionShape_getLocalScaling_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (btVector3 *) &((btCollisionShape const *)arg1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionShape_calculateLocalInertia_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btCollisionShape const *)arg1)->calculateLocalInertia(arg2,*arg3); + +} + + +_gostring_ _wrap_btCollisionShape_getName_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (char *)((btCollisionShape const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btCollisionShape_getShapeType_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (int)((btCollisionShape const *)arg1)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btCollisionShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = ((btCollisionShape const *)arg1)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btCollisionShape_setMargin_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, float _swig_go_1) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setMargin(arg2); + +} + + +float _wrap_btCollisionShape_getMargin_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (btScalar)((btCollisionShape const *)arg1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionShape_setUserPointer_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, void *_swig_go_1) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + (arg1)->setUserPointer(arg2); + +} + + +void *_wrap_btCollisionShape_getUserPointer_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (void *)((btCollisionShape const *)arg1)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionShape_setUserIndex_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, intgo _swig_go_1) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + int arg2 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setUserIndex(arg2); + +} + + +intgo _wrap_btCollisionShape_getUserIndex_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (int)((btCollisionShape const *)arg1)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionShape_setUserIndex2_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, intgo _swig_go_1) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + int arg2 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setUserIndex2(arg2); + +} + + +intgo _wrap_btCollisionShape_getUserIndex2_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (int)((btCollisionShape const *)arg1)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCollisionShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + + result = (int)((btCollisionShape const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btCollisionShape_serialize_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btCollisionShape const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btCollisionShape_serializeSingleShape_mbt_e879218550ba2e2b(btCollisionShape *_swig_go_0, btSerializer *_swig_go_1) { + btCollisionShape *arg1 = (btCollisionShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btCollisionShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + ((btCollisionShape const *)arg1)->serializeSingleShape(arg2); + +} + + +void _wrap_btCollisionShapeData_m_name_set_mbt_e879218550ba2e2b(btCollisionShapeData *_swig_go_0, _gostring_ _swig_go_1) { + btCollisionShapeData *arg1 = (btCollisionShapeData *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = *(btCollisionShapeData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + delete [] arg1->m_name; + if (arg2) { + arg1->m_name = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->m_name, (const char *)arg2); + } else { + arg1->m_name = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btCollisionShapeData_m_name_get_mbt_e879218550ba2e2b(btCollisionShapeData *_swig_go_0) { + btCollisionShapeData *arg1 = (btCollisionShapeData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCollisionShapeData **)&_swig_go_0; + + result = (char *) ((arg1)->m_name); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btCollisionShapeData_m_shapeType_set_mbt_e879218550ba2e2b(btCollisionShapeData *_swig_go_0, intgo _swig_go_1) { + btCollisionShapeData *arg1 = (btCollisionShapeData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionShapeData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_shapeType = arg2; + +} + + +intgo _wrap_btCollisionShapeData_m_shapeType_get_mbt_e879218550ba2e2b(btCollisionShapeData *_swig_go_0) { + btCollisionShapeData *arg1 = (btCollisionShapeData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionShapeData **)&_swig_go_0; + + result = (int) ((arg1)->m_shapeType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionShapeData_m_padding_set_mbt_e879218550ba2e2b(btCollisionShapeData *_swig_go_0, _gostring_ _swig_go_1) { + btCollisionShapeData *arg1 = (btCollisionShapeData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btCollisionShapeData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_padding, (const char *)arg2, 4-1); + arg1->m_padding[4-1] = 0; + } else { + arg1->m_padding[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btCollisionShapeData_m_padding_get_mbt_e879218550ba2e2b(btCollisionShapeData *_swig_go_0) { + btCollisionShapeData *arg1 = (btCollisionShapeData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCollisionShapeData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_padding); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btCollisionShapeData *_wrap_new_btCollisionShapeData_mbt_e879218550ba2e2b() { + btCollisionShapeData *result = 0 ; + btCollisionShapeData *_swig_go_result; + + + result = (btCollisionShapeData *)new btCollisionShapeData(); + *(btCollisionShapeData **)&_swig_go_result = (btCollisionShapeData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCollisionShapeData_mbt_e879218550ba2e2b(btCollisionShapeData *_swig_go_0) { + btCollisionShapeData *arg1 = (btCollisionShapeData *) 0 ; + + arg1 = *(btCollisionShapeData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btBulletCollisionProbe_mbt_e879218550ba2e2b() { + btBulletCollisionProbe(); + +} + + +void _wrap_delete_btConvexShape_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + + delete arg1; + +} + + +btVector3 *_wrap_btConvexShape_localGetSupportingVertex_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btConvexShape const *)arg1)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btConvexShape const *)arg1)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btConvexShape const *)arg1)->localGetSupportVertexWithoutMarginNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btConvexShape const *)arg1)->localGetSupportVertexNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btConvexShape_getMarginNonVirtual_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + result = (btScalar)((btConvexShape const *)arg1)->getMarginNonVirtual(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexShape_getAabbNonVirtual_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btConvexShape const *)arg1)->getAabbNonVirtual((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btConvexShape_project_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + ((btConvexShape const *)arg1)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +void _wrap_btConvexShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + int arg4 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + ((btConvexShape const *)arg1)->batchedUnitVectorGetSupportingVertexWithoutMargin((btVector3 const *)arg2,arg3,arg4); + +} + + +void _wrap_btConvexShape_getAabb_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btConvexShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btConvexShape_getAabbSlow_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btConvexShape const *)arg1)->getAabbSlow((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btConvexShape_setLocalScaling_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btConvexShape_getLocalScaling_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + result = (btVector3 *) &((btConvexShape const *)arg1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexShape_setMargin_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, float _swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setMargin(arg2); + +} + + +float _wrap_btConvexShape_getMargin_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + result = (btScalar)((btConvexShape const *)arg1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConvexShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + result = (int)((btConvexShape const *)arg1)->getNumPreferredPenetrationDirections(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btConvexShape const *)arg1)->getPreferredPenetrationDirection(arg2,*arg3); + +} + + +void _wrap_btConvexShape_getBoundingSphere_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + ((btCollisionShape const *)swig_b0)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btConvexShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (btScalar)((btCollisionShape const *)swig_b0)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConvexShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, float _swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (btScalar)((btCollisionShape const *)swig_b0)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + ((btCollisionShape const *)swig_b0)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btConvexShape_isPolyhedral_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexShape_isConvex2d_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexShape_isConvex_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexShape_isNonMoving_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexShape_isConcave_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexShape_isCompound_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexShape_isSoftBody_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexShape_isInfinite_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexShape_calculateLocalInertia_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + ((btCollisionShape const *)swig_b0)->calculateLocalInertia(arg2,*arg3); + +} + + +_gostring_ _wrap_btConvexShape_getName_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (char *)((btCollisionShape const *)swig_b0)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btConvexShape_getShapeType_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (int)((btCollisionShape const *)swig_b0)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = ((btCollisionShape const *)swig_b0)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btConvexShape_setUserPointer_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, void *_swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + (swig_b0)->setUserPointer(arg2); + +} + + +void *_wrap_btConvexShape_getUserPointer_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (void *)((btCollisionShape const *)swig_b0)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btConvexShape_setUserIndex_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, intgo _swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + int arg2 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + (swig_b0)->setUserIndex(arg2); + +} + + +intgo _wrap_btConvexShape_getUserIndex_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (int)((btCollisionShape const *)swig_b0)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexShape_setUserIndex2_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, intgo _swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + int arg2 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + (swig_b0)->setUserIndex2(arg2); + +} + + +intgo _wrap_btConvexShape_getUserIndex2_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (int)((btCollisionShape const *)swig_b0)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConvexShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (int)((btCollisionShape const *)swig_b0)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btConvexShape_serialize_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (char *)((btCollisionShape const *)swig_b0)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btConvexShape_serializeSingleShape_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btSerializer *_swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + ((btCollisionShape const *)swig_b0)->serializeSingleShape(arg2); + +} + + +btVector3 *_wrap_convexHullSupport_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2, btVector3 *_swig_go_3) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + int arg3 ; + btVector3 *arg4 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = convexHullSupport((btVector3 const &)*arg1,(btVector3 const *)arg2,arg3,(btVector3 const &)*arg4); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_AabbExpand_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + AabbExpand(*arg1,*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +bool _wrap_TestPointAgainstAabb2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (bool)TestPointAgainstAabb2((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_TestAabbAgainstAabb2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = (bool)TestAabbAgainstAabb2((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_TestTriangleAgainstAabb2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btVector3 *arg1 = (btVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (bool)TestTriangleAgainstAabb2((btVector3 const *)arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btOutcode_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (int)btOutcode((btVector3 const &)*arg1,(btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btRayAabb2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, intgo *_swig_go_2, btVector3 (*_swig_go_3)[2], float *_swig_go_4, float _swig_go_5, float _swig_go_6) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + unsigned int *arg3 = (unsigned int *) (unsigned int *)0 ; + btVector3 *arg4 = (btVector3 *) (btVector3 *)0 ; + btScalar *arg5 = 0 ; + btScalar arg6 ; + btScalar arg7 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(unsigned int **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + + result = (bool)btRayAabb2((btVector3 const &)*arg1,(btVector3 const &)*arg2,(unsigned int const (*))arg3,(btVector3 const (*))arg4,*arg5,arg6,arg7); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btRayAabb_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + result = (bool)btRayAabb((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,*arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTransformAabb__SWIG_0_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float _swig_go_1, btTransform *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4) { + btVector3 *arg1 = 0 ; + btScalar arg2 ; + btTransform *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + btTransformAabb((btVector3 const &)*arg1,arg2,(btTransform const &)*arg3,*arg4,*arg5); + +} + + +void _wrap_btTransformAabb__SWIG_1_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + btTransformAabb((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,*arg5,*arg6); + +} + + +intgo _wrap_testQuantizedAabbAgainstQuantizedAabb_mbt_e879218550ba2e2b(short *_swig_go_0, short *_swig_go_1, short *_swig_go_2, short *_swig_go_3) { + unsigned short *arg1 = (unsigned short *) 0 ; + unsigned short *arg2 = (unsigned short *) 0 ; + unsigned short *arg3 = (unsigned short *) 0 ; + unsigned short *arg4 = (unsigned short *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(unsigned short **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + arg3 = *(unsigned short **)&_swig_go_2; + arg4 = *(unsigned short **)&_swig_go_3; + + result = (unsigned int)testQuantizedAabbAgainstQuantizedAabb((unsigned short const *)arg1,(unsigned short const *)arg2,(unsigned short const *)arg3,(unsigned short const *)arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btConvexInternalShape_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + delete arg1; + +} + + +btVector3 *_wrap_btConvexInternalShape_localGetSupportingVertex_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btConvexInternalShape const *)arg1)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + result = (btVector3 *) &((btConvexInternalShape const *)arg1)->getImplicitShapeDimensions(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setImplicitShapeDimensions((btVector3 const &)*arg2); + +} + + +void _wrap_btConvexInternalShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setSafeMargin(arg2,arg3); + +} + + +void _wrap_btConvexInternalShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, float _swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setSafeMargin(arg2); + +} + + +void _wrap_btConvexInternalShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setSafeMargin((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btConvexInternalShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setSafeMargin((btVector3 const &)*arg2); + +} + + +void _wrap_btConvexInternalShape_getAabb_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btConvexInternalShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btConvexInternalShape_getAabbSlow_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btConvexInternalShape const *)arg1)->getAabbSlow((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btConvexInternalShape_setLocalScaling_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btConvexInternalShape_getLocalScaling_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + result = (btVector3 *) &((btConvexInternalShape const *)arg1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalShape_getLocalScalingNV_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + result = (btVector3 *) &((btConvexInternalShape const *)arg1)->getLocalScalingNV(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShape_setMargin_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, float _swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setMargin(arg2); + +} + + +float _wrap_btConvexInternalShape_getMargin_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + result = (btScalar)((btConvexInternalShape const *)arg1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConvexInternalShape_getMarginNV_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + result = (btScalar)((btConvexInternalShape const *)arg1)->getMarginNV(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConvexInternalShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + result = (int)((btConvexInternalShape const *)arg1)->getNumPreferredPenetrationDirections(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btConvexInternalShape const *)arg1)->getPreferredPenetrationDirection(arg2,*arg3); + +} + + +intgo _wrap_btConvexInternalShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + result = (int)((btConvexInternalShape const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btConvexInternalShape_serialize_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btConvexInternalShape const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + result = ((btConvexShape const *)swig_b0)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + result = ((btConvexShape const *)swig_b0)->localGetSupportVertexWithoutMarginNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + result = ((btConvexShape const *)swig_b0)->localGetSupportVertexNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btConvexInternalShape_getMarginNonVirtual_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + result = (btScalar)((btConvexShape const *)swig_b0)->getMarginNonVirtual(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShape_getAabbNonVirtual_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + ((btConvexShape const *)swig_b0)->getAabbNonVirtual((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btConvexInternalShape_project_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + ((btConvexShape const *)swig_b0)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +void _wrap_btConvexInternalShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + int arg4 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + ((btConvexShape const *)swig_b0)->batchedUnitVectorGetSupportingVertexWithoutMargin((btVector3 const *)arg2,arg3,arg4); + +} + + +void _wrap_btConvexInternalShape_getBoundingSphere_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btConvexInternalShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (btScalar)((btCollisionShape const *)swig_b1)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConvexInternalShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, float _swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (btScalar)((btCollisionShape const *)swig_b1)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btConvexInternalShape_isPolyhedral_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalShape_isConvex2d_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalShape_isConvex_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalShape_isNonMoving_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalShape_isConcave_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalShape_isCompound_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalShape_isSoftBody_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalShape_isInfinite_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShape_calculateLocalInertia_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->calculateLocalInertia(arg2,*arg3); + +} + + +_gostring_ _wrap_btConvexInternalShape_getName_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (char *)((btCollisionShape const *)swig_b1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btConvexInternalShape_getShapeType_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = ((btCollisionShape const *)swig_b1)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btConvexInternalShape_setUserPointer_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, void *_swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserPointer(arg2); + +} + + +void *_wrap_btConvexInternalShape_getUserPointer_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (void *)((btCollisionShape const *)swig_b1)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShape_setUserIndex_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, intgo _swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + int arg2 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserIndex(arg2); + +} + + +intgo _wrap_btConvexInternalShape_getUserIndex_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShape_setUserIndex2_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, intgo _swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + int arg2 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserIndex2(arg2); + +} + + +intgo _wrap_btConvexInternalShape_getUserIndex2_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShape_serializeSingleShape_mbt_e879218550ba2e2b(btConvexInternalShape *_swig_go_0, btSerializer *_swig_go_1) { + btConvexInternalShape *arg1 = (btConvexInternalShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btConvexInternalShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btConvexShape *swig_b0 = (btConvexShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->serializeSingleShape(arg2); + +} + + +void _wrap_btConvexInternalShapeData_m_collisionShapeData_set_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0, btCollisionShapeData *_swig_go_1) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + btCollisionShapeData *arg2 = (btCollisionShapeData *) 0 ; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + arg2 = *(btCollisionShapeData **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionShapeData = *arg2; + +} + + +btCollisionShapeData *_wrap_btConvexInternalShapeData_m_collisionShapeData_get_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + btCollisionShapeData *result = 0 ; + btCollisionShapeData *_swig_go_result; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + + result = (btCollisionShapeData *)& ((arg1)->m_collisionShapeData); + *(btCollisionShapeData **)&_swig_go_result = (btCollisionShapeData *)result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShapeData_m_localScaling_set_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_localScaling = *arg2; + +} + + +btVector3FloatData *_wrap_btConvexInternalShapeData_m_localScaling_get_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_localScaling); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShapeData_m_implicitShapeDimensions_set_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_implicitShapeDimensions = *arg2; + +} + + +btVector3FloatData *_wrap_btConvexInternalShapeData_m_implicitShapeDimensions_get_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_implicitShapeDimensions); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShapeData_m_collisionMargin_set_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0, float _swig_go_1) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + float arg2 ; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_collisionMargin = arg2; + +} + + +float _wrap_btConvexInternalShapeData_m_collisionMargin_get_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + + result = (float) ((arg1)->m_collisionMargin); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalShapeData_m_padding_set_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0, intgo _swig_go_1) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + int arg2 ; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_padding = arg2; + +} + + +intgo _wrap_btConvexInternalShapeData_m_padding_get_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + + result = (int) ((arg1)->m_padding); + _swig_go_result = result; + return _swig_go_result; +} + + +btConvexInternalShapeData *_wrap_new_btConvexInternalShapeData_mbt_e879218550ba2e2b() { + btConvexInternalShapeData *result = 0 ; + btConvexInternalShapeData *_swig_go_result; + + + result = (btConvexInternalShapeData *)new btConvexInternalShapeData(); + *(btConvexInternalShapeData **)&_swig_go_result = (btConvexInternalShapeData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btConvexInternalShapeData_mbt_e879218550ba2e2b(btConvexInternalShapeData *_swig_go_0) { + btConvexInternalShapeData *arg1 = (btConvexInternalShapeData *) 0 ; + + arg1 = *(btConvexInternalShapeData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConvexInternalAabbCachingShape_setLocalScaling_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +void _wrap_btConvexInternalAabbCachingShape_getAabb_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btConvexInternalAabbCachingShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btConvexInternalAabbCachingShape_recalcLocalAabb_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + (arg1)->recalcLocalAabb(); + +} + + +void _wrap_delete_btConvexInternalAabbCachingShape_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + delete arg1; + +} + + +btVector3 *_wrap_btConvexInternalAabbCachingShape_localGetSupportingVertex_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = ((btConvexInternalShape const *)swig_b0)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalAabbCachingShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getImplicitShapeDimensions(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalAabbCachingShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setImplicitShapeDimensions((btVector3 const &)*arg2); + +} + + +void _wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin(arg2,arg3); + +} + + +void _wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, float _swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin(arg2); + +} + + +void _wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin((btVector3 const &)*arg2); + +} + + +void _wrap_btConvexInternalAabbCachingShape_getAabbSlow_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + ((btConvexInternalShape const *)swig_b0)->getAabbSlow((btTransform const &)*arg2,*arg3,*arg4); + +} + + +btVector3 *_wrap_btConvexInternalAabbCachingShape_getLocalScaling_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalAabbCachingShape_getLocalScalingNV_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getLocalScalingNV(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalAabbCachingShape_setMargin_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, float _swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setMargin(arg2); + +} + + +float _wrap_btConvexInternalAabbCachingShape_getMargin_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btScalar)((btConvexInternalShape const *)swig_b0)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConvexInternalAabbCachingShape_getMarginNV_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btScalar)((btConvexInternalShape const *)swig_b0)->getMarginNV(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConvexInternalAabbCachingShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (int)((btConvexInternalShape const *)swig_b0)->getNumPreferredPenetrationDirections(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalAabbCachingShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + ((btConvexInternalShape const *)swig_b0)->getPreferredPenetrationDirection(arg2,*arg3); + +} + + +intgo _wrap_btConvexInternalAabbCachingShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (int)((btConvexInternalShape const *)swig_b0)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btConvexInternalAabbCachingShape_serialize_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (char *)((btConvexInternalShape const *)swig_b0)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalAabbCachingShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = ((btConvexShape const *)swig_b1)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalAabbCachingShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = ((btConvexShape const *)swig_b1)->localGetSupportVertexWithoutMarginNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalAabbCachingShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = ((btConvexShape const *)swig_b1)->localGetSupportVertexNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btConvexInternalAabbCachingShape_getMarginNonVirtual_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = (btScalar)((btConvexShape const *)swig_b1)->getMarginNonVirtual(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalAabbCachingShape_getAabbNonVirtual_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + ((btConvexShape const *)swig_b1)->getAabbNonVirtual((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btConvexInternalAabbCachingShape_project_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + ((btConvexShape const *)swig_b1)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +void _wrap_btConvexInternalAabbCachingShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + int arg4 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + ((btConvexShape const *)swig_b1)->batchedUnitVectorGetSupportingVertexWithoutMargin((btVector3 const *)arg2,arg3,arg4); + +} + + +void _wrap_btConvexInternalAabbCachingShape_getBoundingSphere_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btConvexInternalAabbCachingShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (btScalar)((btCollisionShape const *)swig_b2)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConvexInternalAabbCachingShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, float _swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (btScalar)((btCollisionShape const *)swig_b2)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalAabbCachingShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btConvexInternalAabbCachingShape_isPolyhedral_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalAabbCachingShape_isConvex2d_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalAabbCachingShape_isConvex_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalAabbCachingShape_isNonMoving_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalAabbCachingShape_isConcave_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalAabbCachingShape_isCompound_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalAabbCachingShape_isSoftBody_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConvexInternalAabbCachingShape_isInfinite_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalAabbCachingShape_calculateLocalInertia_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->calculateLocalInertia(arg2,*arg3); + +} + + +_gostring_ _wrap_btConvexInternalAabbCachingShape_getName_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (char *)((btCollisionShape const *)swig_b2)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btConvexInternalAabbCachingShape_getShapeType_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexInternalAabbCachingShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = ((btCollisionShape const *)swig_b2)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btConvexInternalAabbCachingShape_setUserPointer_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, void *_swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserPointer(arg2); + +} + + +void *_wrap_btConvexInternalAabbCachingShape_getUserPointer_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (void *)((btCollisionShape const *)swig_b2)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalAabbCachingShape_setUserIndex_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, intgo _swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + int arg2 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserIndex(arg2); + +} + + +intgo _wrap_btConvexInternalAabbCachingShape_getUserIndex_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalAabbCachingShape_setUserIndex2_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, intgo _swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + int arg2 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserIndex2(arg2); + +} + + +intgo _wrap_btConvexInternalAabbCachingShape_getUserIndex2_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexInternalAabbCachingShape_serializeSingleShape_mbt_e879218550ba2e2b(btConvexInternalAabbCachingShape *_swig_go_0, btSerializer *_swig_go_1) { + btConvexInternalAabbCachingShape *arg1 = (btConvexInternalAabbCachingShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btConvexInternalAabbCachingShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->serializeSingleShape(arg2); + +} + + +btSphereShape *_wrap_new_btSphereShape_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + btSphereShape *result = 0 ; + btSphereShape *_swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (btSphereShape *)new btSphereShape(arg1); + *(btSphereShape **)&_swig_go_result = (btSphereShape *)result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSphereShape_localGetSupportingVertex_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btVector3 *_swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btSphereShape const *)arg1)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btSphereShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btVector3 *_swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btSphereShape const *)arg1)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btSphereShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + int arg4 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + ((btSphereShape const *)arg1)->batchedUnitVectorGetSupportingVertexWithoutMargin((btVector3 const *)arg2,arg3,arg4); + +} + + +void _wrap_btSphereShape_calculateLocalInertia_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btSphereShape const *)arg1)->calculateLocalInertia(arg2,*arg3); + +} + + +void _wrap_btSphereShape_getAabb_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btSphereShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +float _wrap_btSphereShape_getRadius_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + result = (btScalar)((btSphereShape const *)arg1)->getRadius(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSphereShape_setUnscaledRadius_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, float _swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setUnscaledRadius(arg2); + +} + + +_gostring_ _wrap_btSphereShape_getName_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + result = (char *)((btSphereShape const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btSphereShape_setMargin_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, float _swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setMargin(arg2); + +} + + +float _wrap_btSphereShape_getMargin_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + result = (btScalar)((btSphereShape const *)arg1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btSphereShape_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + + delete arg1; + +} + + +btVector3 *_wrap_btSphereShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getImplicitShapeDimensions(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSphereShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btVector3 *_swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setImplicitShapeDimensions((btVector3 const &)*arg2); + +} + + +void _wrap_btSphereShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin(arg2,arg3); + +} + + +void _wrap_btSphereShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, float _swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin(arg2); + +} + + +void _wrap_btSphereShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btSphereShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btVector3 *_swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin((btVector3 const &)*arg2); + +} + + +void _wrap_btSphereShape_getAabbSlow_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + ((btConvexInternalShape const *)swig_b0)->getAabbSlow((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btSphereShape_setLocalScaling_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btVector3 *_swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btSphereShape_getLocalScaling_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSphereShape_getLocalScalingNV_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getLocalScalingNV(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btSphereShape_getMarginNV_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btScalar)((btConvexInternalShape const *)swig_b0)->getMarginNV(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSphereShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (int)((btConvexInternalShape const *)swig_b0)->getNumPreferredPenetrationDirections(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSphereShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + ((btConvexInternalShape const *)swig_b0)->getPreferredPenetrationDirection(arg2,*arg3); + +} + + +intgo _wrap_btSphereShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (int)((btConvexInternalShape const *)swig_b0)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btSphereShape_serialize_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (char *)((btConvexInternalShape const *)swig_b0)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btVector3 *_wrap_btSphereShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btVector3 *_swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = ((btConvexShape const *)swig_b1)->localGetSupportVertexWithoutMarginNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btSphereShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btVector3 *_swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = ((btConvexShape const *)swig_b1)->localGetSupportVertexNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btSphereShape_getMarginNonVirtual_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = (btScalar)((btConvexShape const *)swig_b1)->getMarginNonVirtual(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSphereShape_getAabbNonVirtual_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + ((btConvexShape const *)swig_b1)->getAabbNonVirtual((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btSphereShape_project_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + ((btConvexShape const *)swig_b1)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +void _wrap_btSphereShape_getBoundingSphere_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btSphereShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (btScalar)((btCollisionShape const *)swig_b2)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btSphereShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, float _swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (btScalar)((btCollisionShape const *)swig_b2)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSphereShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btSphereShape_isPolyhedral_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSphereShape_isConvex2d_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSphereShape_isConvex_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSphereShape_isNonMoving_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSphereShape_isConcave_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSphereShape_isCompound_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSphereShape_isSoftBody_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSphereShape_isInfinite_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSphereShape_getShapeType_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSphereShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = ((btCollisionShape const *)swig_b2)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btSphereShape_setUserPointer_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, void *_swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserPointer(arg2); + +} + + +void *_wrap_btSphereShape_getUserPointer_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (void *)((btCollisionShape const *)swig_b2)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btSphereShape_setUserIndex_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, intgo _swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + int arg2 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserIndex(arg2); + +} + + +intgo _wrap_btSphereShape_getUserIndex_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSphereShape_setUserIndex2_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, intgo _swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + int arg2 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserIndex2(arg2); + +} + + +intgo _wrap_btSphereShape_getUserIndex2_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSphereShape_serializeSingleShape_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btSerializer *_swig_go_1) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->serializeSingleShape(arg2); + +} + + +void _wrap_delete_btPolyhedralConvexShape_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btPolyhedralConvexShape_initializePolyhedralFeatures__SWIG_0_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, intgo _swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (bool)(arg1)->initializePolyhedralFeatures(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexShape_initializePolyhedralFeatures__SWIG_1_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + result = (bool)(arg1)->initializePolyhedralFeatures(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_setPolyhedralFeatures_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btConvexPolyhedron *_swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btConvexPolyhedron *arg2 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btConvexPolyhedron **)&_swig_go_1; + + (arg1)->setPolyhedralFeatures(*arg2); + +} + + +btConvexPolyhedron *_wrap_btPolyhedralConvexShape_getConvexPolyhedron_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btConvexPolyhedron *result = 0 ; + btConvexPolyhedron *_swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + result = (btConvexPolyhedron *)((btPolyhedralConvexShape const *)arg1)->getConvexPolyhedron(); + *(btConvexPolyhedron **)&_swig_go_result = (btConvexPolyhedron *)result; + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btPolyhedralConvexShape const *)arg1)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + int arg4 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + ((btPolyhedralConvexShape const *)arg1)->batchedUnitVectorGetSupportingVertexWithoutMargin((btVector3 const *)arg2,arg3,arg4); + +} + + +void _wrap_btPolyhedralConvexShape_calculateLocalInertia_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btPolyhedralConvexShape const *)arg1)->calculateLocalInertia(arg2,*arg3); + +} + + +intgo _wrap_btPolyhedralConvexShape_getNumVertices_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + result = (int)((btPolyhedralConvexShape const *)arg1)->getNumVertices(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btPolyhedralConvexShape_getNumEdges_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + result = (int)((btPolyhedralConvexShape const *)arg1)->getNumEdges(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_getEdge_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btPolyhedralConvexShape const *)arg1)->getEdge(arg2,*arg3,*arg4); + +} + + +void _wrap_btPolyhedralConvexShape_getVertex_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btPolyhedralConvexShape const *)arg1)->getVertex(arg2,*arg3); + +} + + +intgo _wrap_btPolyhedralConvexShape_getNumPlanes_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + result = (int)((btPolyhedralConvexShape const *)arg1)->getNumPlanes(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_getPlane_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + int arg4 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + ((btPolyhedralConvexShape const *)arg1)->getPlane(*arg2,*arg3,arg4); + +} + + +bool _wrap_btPolyhedralConvexShape_isInside_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = (bool)((btPolyhedralConvexShape const *)arg1)->isInside((btVector3 const &)*arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexShape_localGetSupportingVertex_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = ((btConvexInternalShape const *)swig_b0)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getImplicitShapeDimensions(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setImplicitShapeDimensions((btVector3 const &)*arg2); + +} + + +void _wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin(arg2,arg3); + +} + + +void _wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, float _swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin(arg2); + +} + + +void _wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin((btVector3 const &)*arg2); + +} + + +void _wrap_btPolyhedralConvexShape_getAabb_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + ((btConvexInternalShape const *)swig_b0)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btPolyhedralConvexShape_getAabbSlow_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + ((btConvexInternalShape const *)swig_b0)->getAabbSlow((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btPolyhedralConvexShape_setLocalScaling_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btPolyhedralConvexShape_getLocalScaling_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexShape_getLocalScalingNV_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getLocalScalingNV(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_setMargin_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, float _swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setMargin(arg2); + +} + + +float _wrap_btPolyhedralConvexShape_getMargin_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btScalar)((btConvexInternalShape const *)swig_b0)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btPolyhedralConvexShape_getMarginNV_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btScalar)((btConvexInternalShape const *)swig_b0)->getMarginNV(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btPolyhedralConvexShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (int)((btConvexInternalShape const *)swig_b0)->getNumPreferredPenetrationDirections(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + ((btConvexInternalShape const *)swig_b0)->getPreferredPenetrationDirection(arg2,*arg3); + +} + + +intgo _wrap_btPolyhedralConvexShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (int)((btConvexInternalShape const *)swig_b0)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btPolyhedralConvexShape_serialize_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (char *)((btConvexInternalShape const *)swig_b0)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = ((btConvexShape const *)swig_b1)->localGetSupportVertexWithoutMarginNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = ((btConvexShape const *)swig_b1)->localGetSupportVertexNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btPolyhedralConvexShape_getMarginNonVirtual_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = (btScalar)((btConvexShape const *)swig_b1)->getMarginNonVirtual(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_getAabbNonVirtual_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + ((btConvexShape const *)swig_b1)->getAabbNonVirtual((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btPolyhedralConvexShape_project_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + ((btConvexShape const *)swig_b1)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +void _wrap_btPolyhedralConvexShape_getBoundingSphere_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btPolyhedralConvexShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (btScalar)((btCollisionShape const *)swig_b2)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btPolyhedralConvexShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, float _swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (btScalar)((btCollisionShape const *)swig_b2)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btPolyhedralConvexShape_isPolyhedral_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexShape_isConvex2d_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexShape_isConvex_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexShape_isNonMoving_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexShape_isConcave_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexShape_isCompound_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexShape_isSoftBody_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexShape_isInfinite_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btPolyhedralConvexShape_getName_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (char *)((btCollisionShape const *)swig_b2)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btPolyhedralConvexShape_getShapeType_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = ((btCollisionShape const *)swig_b2)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_setUserPointer_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, void *_swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserPointer(arg2); + +} + + +void *_wrap_btPolyhedralConvexShape_getUserPointer_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (void *)((btCollisionShape const *)swig_b2)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_setUserIndex_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, intgo _swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int arg2 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserIndex(arg2); + +} + + +intgo _wrap_btPolyhedralConvexShape_getUserIndex_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_setUserIndex2_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, intgo _swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int arg2 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserIndex2(arg2); + +} + + +intgo _wrap_btPolyhedralConvexShape_getUserIndex2_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexShape_serializeSingleShape_mbt_e879218550ba2e2b(btPolyhedralConvexShape *_swig_go_0, btSerializer *_swig_go_1) { + btPolyhedralConvexShape *arg1 = (btPolyhedralConvexShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btPolyhedralConvexShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->serializeSingleShape(arg2); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_getNonvirtualAabb_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + + ((btPolyhedralConvexAabbCachingShape const *)arg1)->getNonvirtualAabb((btTransform const &)*arg2,*arg3,*arg4,arg5); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setLocalScaling_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_getAabb_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btPolyhedralConvexAabbCachingShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_recalcLocalAabb_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + (arg1)->recalcLocalAabb(); + +} + + +void _wrap_delete_btPolyhedralConvexAabbCachingShape_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_initializePolyhedralFeatures__SWIG_0_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, intgo _swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = (bool)(swig_b0)->initializePolyhedralFeatures(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_initializePolyhedralFeatures__SWIG_1_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = (bool)(swig_b0)->initializePolyhedralFeatures(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setPolyhedralFeatures_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btConvexPolyhedron *_swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btConvexPolyhedron *arg2 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btConvexPolyhedron **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + (swig_b0)->setPolyhedralFeatures(*arg2); + +} + + +btConvexPolyhedron *_wrap_btPolyhedralConvexAabbCachingShape_getConvexPolyhedron_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btConvexPolyhedron *result = 0 ; + btConvexPolyhedron *_swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = (btConvexPolyhedron *)((btPolyhedralConvexShape const *)swig_b0)->getConvexPolyhedron(); + *(btConvexPolyhedron **)&_swig_go_result = (btConvexPolyhedron *)result; + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexAabbCachingShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = ((btPolyhedralConvexShape const *)swig_b0)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + int arg4 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + ((btPolyhedralConvexShape const *)swig_b0)->batchedUnitVectorGetSupportingVertexWithoutMargin((btVector3 const *)arg2,arg3,arg4); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_calculateLocalInertia_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + ((btPolyhedralConvexShape const *)swig_b0)->calculateLocalInertia(arg2,*arg3); + +} + + +intgo _wrap_btPolyhedralConvexAabbCachingShape_getNumVertices_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = (int)((btPolyhedralConvexShape const *)swig_b0)->getNumVertices(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btPolyhedralConvexAabbCachingShape_getNumEdges_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = (int)((btPolyhedralConvexShape const *)swig_b0)->getNumEdges(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_getEdge_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + ((btPolyhedralConvexShape const *)swig_b0)->getEdge(arg2,*arg3,*arg4); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_getVertex_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + ((btPolyhedralConvexShape const *)swig_b0)->getVertex(arg2,*arg3); + +} + + +intgo _wrap_btPolyhedralConvexAabbCachingShape_getNumPlanes_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = (int)((btPolyhedralConvexShape const *)swig_b0)->getNumPlanes(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_getPlane_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + int arg4 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + ((btPolyhedralConvexShape const *)swig_b0)->getPlane(*arg2,*arg3,arg4); + +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_isInside_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = (bool)((btPolyhedralConvexShape const *)swig_b0)->isInside((btVector3 const &)*arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexAabbCachingShape_localGetSupportingVertex_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = ((btConvexInternalShape const *)swig_b1)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexAabbCachingShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getImplicitShapeDimensions(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setImplicitShapeDimensions((btVector3 const &)*arg2); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin(arg2,arg3); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, float _swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin(arg2); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin((btVector3 const &)*arg2); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_getAabbSlow_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + ((btConvexInternalShape const *)swig_b1)->getAabbSlow((btTransform const &)*arg2,*arg3,*arg4); + +} + + +btVector3 *_wrap_btPolyhedralConvexAabbCachingShape_getLocalScaling_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexAabbCachingShape_getLocalScalingNV_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getLocalScalingNV(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setMargin_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, float _swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setMargin(arg2); + +} + + +float _wrap_btPolyhedralConvexAabbCachingShape_getMargin_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btScalar)((btConvexInternalShape const *)swig_b1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btPolyhedralConvexAabbCachingShape_getMarginNV_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btScalar)((btConvexInternalShape const *)swig_b1)->getMarginNV(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btPolyhedralConvexAabbCachingShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (int)((btConvexInternalShape const *)swig_b1)->getNumPreferredPenetrationDirections(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + ((btConvexInternalShape const *)swig_b1)->getPreferredPenetrationDirection(arg2,*arg3); + +} + + +intgo _wrap_btPolyhedralConvexAabbCachingShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (int)((btConvexInternalShape const *)swig_b1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btPolyhedralConvexAabbCachingShape_serialize_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (char *)((btConvexInternalShape const *)swig_b1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexAabbCachingShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = ((btConvexShape const *)swig_b2)->localGetSupportVertexWithoutMarginNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexAabbCachingShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = ((btConvexShape const *)swig_b2)->localGetSupportVertexNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btPolyhedralConvexAabbCachingShape_getMarginNonVirtual_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = (btScalar)((btConvexShape const *)swig_b2)->getMarginNonVirtual(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_getAabbNonVirtual_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + ((btConvexShape const *)swig_b2)->getAabbNonVirtual((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_project_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + ((btConvexShape const *)swig_b2)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_getBoundingSphere_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btPolyhedralConvexAabbCachingShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (btScalar)((btCollisionShape const *)swig_b3)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btPolyhedralConvexAabbCachingShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, float _swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (btScalar)((btCollisionShape const *)swig_b3)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_isPolyhedral_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_isConvex2d_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_isConvex_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_isNonMoving_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_isConcave_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_isCompound_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_isSoftBody_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btPolyhedralConvexAabbCachingShape_isInfinite_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btPolyhedralConvexAabbCachingShape_getName_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (char *)((btCollisionShape const *)swig_b3)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btPolyhedralConvexAabbCachingShape_getShapeType_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btPolyhedralConvexAabbCachingShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = ((btCollisionShape const *)swig_b3)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setUserPointer_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, void *_swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserPointer(arg2); + +} + + +void *_wrap_btPolyhedralConvexAabbCachingShape_getUserPointer_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (void *)((btCollisionShape const *)swig_b3)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setUserIndex_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, intgo _swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int arg2 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserIndex(arg2); + +} + + +intgo _wrap_btPolyhedralConvexAabbCachingShape_getUserIndex_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_setUserIndex2_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, intgo _swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int arg2 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserIndex2(arg2); + +} + + +intgo _wrap_btPolyhedralConvexAabbCachingShape_getUserIndex2_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralConvexAabbCachingShape_serializeSingleShape_mbt_e879218550ba2e2b(btPolyhedralConvexAabbCachingShape *_swig_go_0, btSerializer *_swig_go_1) { + btPolyhedralConvexAabbCachingShape *arg1 = (btPolyhedralConvexAabbCachingShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btPolyhedralConvexAabbCachingShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->serializeSingleShape(arg2); + +} + + +void _wrap_btFace_m_indices_set_mbt_e879218550ba2e2b(btFace *_swig_go_0, btAlignedObjectArray< int > *_swig_go_1) { + btFace *arg1 = (btFace *) 0 ; + btAlignedObjectArray< int > *arg2 = (btAlignedObjectArray< int > *) 0 ; + + arg1 = *(btFace **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< int > **)&_swig_go_1; + + if (arg1) (arg1)->m_indices = *arg2; + +} + + +btAlignedObjectArray< int > *_wrap_btFace_m_indices_get_mbt_e879218550ba2e2b(btFace *_swig_go_0) { + btFace *arg1 = (btFace *) 0 ; + btAlignedObjectArray< int > *result = 0 ; + btAlignedObjectArray< int > *_swig_go_result; + + arg1 = *(btFace **)&_swig_go_0; + + result = (btAlignedObjectArray< int > *)& ((arg1)->m_indices); + *(btAlignedObjectArray< int > **)&_swig_go_result = (btAlignedObjectArray< int > *)result; + return _swig_go_result; +} + + +void _wrap_btFace_m_plane_set_mbt_e879218550ba2e2b(btFace *_swig_go_0, float *_swig_go_1) { + btFace *arg1 = (btFace *) 0 ; + btScalar *arg2 = (btScalar *) (btScalar *)0 ; + + arg1 = *(btFace **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + { + size_t ii; + btScalar *b = (btScalar *) arg1->m_plane; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btScalar *) arg2 + ii); + } + +} + + +float *_wrap_btFace_m_plane_get_mbt_e879218550ba2e2b(btFace *_swig_go_0) { + btFace *arg1 = (btFace *) 0 ; + btScalar *result = 0 ; + float *_swig_go_result; + + arg1 = *(btFace **)&_swig_go_0; + + result = (btScalar *)(btScalar *) ((arg1)->m_plane); + *(btScalar **)&_swig_go_result = result; + return _swig_go_result; +} + + +btFace *_wrap_new_btFace_mbt_e879218550ba2e2b() { + btFace *result = 0 ; + btFace *_swig_go_result; + + + result = (btFace *)new btFace(); + *(btFace **)&_swig_go_result = (btFace *)result; + return _swig_go_result; +} + + +void _wrap_delete_btFace_mbt_e879218550ba2e2b(btFace *_swig_go_0) { + btFace *arg1 = (btFace *) 0 ; + + arg1 = *(btFace **)&_swig_go_0; + + delete arg1; + +} + + +btConvexPolyhedron *_wrap_new_btConvexPolyhedron_mbt_e879218550ba2e2b() { + btConvexPolyhedron *result = 0 ; + btConvexPolyhedron *_swig_go_result; + + + result = (btConvexPolyhedron *)new btConvexPolyhedron(); + *(btConvexPolyhedron **)&_swig_go_result = (btConvexPolyhedron *)result; + return _swig_go_result; +} + + +void _wrap_delete_btConvexPolyhedron_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConvexPolyhedron_m_vertices_set_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0, btAlignedObjectArray< btVector3 > *_swig_go_1) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btAlignedObjectArray< btVector3 > *arg2 = (btAlignedObjectArray< btVector3 > *) 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btVector3 > **)&_swig_go_1; + + if (arg1) (arg1)->m_vertices = *arg2; + +} + + +btAlignedObjectArray< btVector3 > *_wrap_btConvexPolyhedron_m_vertices_get_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btAlignedObjectArray< btVector3 > *result = 0 ; + btAlignedObjectArray< btVector3 > *_swig_go_result; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + result = (btAlignedObjectArray< btVector3 > *)& ((arg1)->m_vertices); + *(btAlignedObjectArray< btVector3 > **)&_swig_go_result = (btAlignedObjectArray< btVector3 > *)result; + return _swig_go_result; +} + + +void _wrap_btConvexPolyhedron_m_faces_set_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0, btAlignedObjectArray< btFace > *_swig_go_1) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btAlignedObjectArray< btFace > *arg2 = (btAlignedObjectArray< btFace > *) 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btFace > **)&_swig_go_1; + + if (arg1) (arg1)->m_faces = *arg2; + +} + + +btAlignedObjectArray< btFace > *_wrap_btConvexPolyhedron_m_faces_get_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btAlignedObjectArray< btFace > *result = 0 ; + btAlignedObjectArray< btFace > *_swig_go_result; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + result = (btAlignedObjectArray< btFace > *)& ((arg1)->m_faces); + *(btAlignedObjectArray< btFace > **)&_swig_go_result = (btAlignedObjectArray< btFace > *)result; + return _swig_go_result; +} + + +void _wrap_btConvexPolyhedron_m_uniqueEdges_set_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0, btAlignedObjectArray< btVector3 > *_swig_go_1) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btAlignedObjectArray< btVector3 > *arg2 = (btAlignedObjectArray< btVector3 > *) 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btVector3 > **)&_swig_go_1; + + if (arg1) (arg1)->m_uniqueEdges = *arg2; + +} + + +btAlignedObjectArray< btVector3 > *_wrap_btConvexPolyhedron_m_uniqueEdges_get_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btAlignedObjectArray< btVector3 > *result = 0 ; + btAlignedObjectArray< btVector3 > *_swig_go_result; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + result = (btAlignedObjectArray< btVector3 > *)& ((arg1)->m_uniqueEdges); + *(btAlignedObjectArray< btVector3 > **)&_swig_go_result = (btAlignedObjectArray< btVector3 > *)result; + return _swig_go_result; +} + + +void _wrap_btConvexPolyhedron_m_localCenter_set_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0, btVector3 *_swig_go_1) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_localCenter = *arg2; + +} + + +btVector3 *_wrap_btConvexPolyhedron_m_localCenter_get_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_localCenter); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btConvexPolyhedron_m_extents_set_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0, btVector3 *_swig_go_1) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_extents = *arg2; + +} + + +btVector3 *_wrap_btConvexPolyhedron_m_extents_get_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_extents); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btConvexPolyhedron_m_radius_set_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0, float _swig_go_1) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btScalar arg2 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_radius = arg2; + +} + + +float _wrap_btConvexPolyhedron_m_radius_get_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_radius); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexPolyhedron_mC_set_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0, btVector3 *_swig_go_1) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->mC = *arg2; + +} + + +btVector3 *_wrap_btConvexPolyhedron_mC_get_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->mC); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btConvexPolyhedron_mE_set_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0, btVector3 *_swig_go_1) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->mE = *arg2; + +} + + +btVector3 *_wrap_btConvexPolyhedron_mE_get_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->mE); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btConvexPolyhedron_initialize_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + (arg1)->initialize(); + +} + + +void _wrap_btConvexPolyhedron_initialize2_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + (arg1)->initialize2(); + +} + + +bool _wrap_btConvexPolyhedron_testContainment_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + + result = (bool)((btConvexPolyhedron const *)arg1)->testContainment(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexPolyhedron_project_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btConvexPolyhedron *arg1 = (btConvexPolyhedron *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + ((btConvexPolyhedron const *)arg1)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +bool _wrap_IsAlmostZero1_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (bool)IsAlmostZero1((btVector3 const &)*arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +btInternalVertexPair *_wrap_new_btInternalVertexPair_mbt_e879218550ba2e2b(short _swig_go_0, short _swig_go_1) { + short arg1 ; + short arg2 ; + btInternalVertexPair *result = 0 ; + btInternalVertexPair *_swig_go_result; + + arg1 = (short)_swig_go_0; + arg2 = (short)_swig_go_1; + + result = (btInternalVertexPair *)new btInternalVertexPair(arg1,arg2); + *(btInternalVertexPair **)&_swig_go_result = (btInternalVertexPair *)result; + return _swig_go_result; +} + + +void _wrap_btInternalVertexPair_m_v0_set_mbt_e879218550ba2e2b(btInternalVertexPair *_swig_go_0, short _swig_go_1) { + btInternalVertexPair *arg1 = (btInternalVertexPair *) 0 ; + short arg2 ; + + arg1 = *(btInternalVertexPair **)&_swig_go_0; + arg2 = (short)_swig_go_1; + + if (arg1) (arg1)->m_v0 = arg2; + +} + + +short _wrap_btInternalVertexPair_m_v0_get_mbt_e879218550ba2e2b(btInternalVertexPair *_swig_go_0) { + btInternalVertexPair *arg1 = (btInternalVertexPair *) 0 ; + short result; + short _swig_go_result; + + arg1 = *(btInternalVertexPair **)&_swig_go_0; + + result = (short) ((arg1)->m_v0); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btInternalVertexPair_m_v1_set_mbt_e879218550ba2e2b(btInternalVertexPair *_swig_go_0, short _swig_go_1) { + btInternalVertexPair *arg1 = (btInternalVertexPair *) 0 ; + short arg2 ; + + arg1 = *(btInternalVertexPair **)&_swig_go_0; + arg2 = (short)_swig_go_1; + + if (arg1) (arg1)->m_v1 = arg2; + +} + + +short _wrap_btInternalVertexPair_m_v1_get_mbt_e879218550ba2e2b(btInternalVertexPair *_swig_go_0) { + btInternalVertexPair *arg1 = (btInternalVertexPair *) 0 ; + short result; + short _swig_go_result; + + arg1 = *(btInternalVertexPair **)&_swig_go_0; + + result = (short) ((arg1)->m_v1); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btInternalVertexPair_getHash_mbt_e879218550ba2e2b(btInternalVertexPair *_swig_go_0) { + btInternalVertexPair *arg1 = (btInternalVertexPair *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btInternalVertexPair **)&_swig_go_0; + + result = (int)((btInternalVertexPair const *)arg1)->getHash(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btInternalVertexPair_equals_mbt_e879218550ba2e2b(btInternalVertexPair *_swig_go_0, btInternalVertexPair *_swig_go_1) { + btInternalVertexPair *arg1 = (btInternalVertexPair *) 0 ; + btInternalVertexPair *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btInternalVertexPair **)&_swig_go_0; + arg2 = *(btInternalVertexPair **)&_swig_go_1; + + result = (bool)((btInternalVertexPair const *)arg1)->equals((btInternalVertexPair const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btInternalVertexPair_mbt_e879218550ba2e2b(btInternalVertexPair *_swig_go_0) { + btInternalVertexPair *arg1 = (btInternalVertexPair *) 0 ; + + arg1 = *(btInternalVertexPair **)&_swig_go_0; + + delete arg1; + +} + + +btInternalEdge *_wrap_new_btInternalEdge_mbt_e879218550ba2e2b() { + btInternalEdge *result = 0 ; + btInternalEdge *_swig_go_result; + + + result = (btInternalEdge *)new btInternalEdge(); + *(btInternalEdge **)&_swig_go_result = (btInternalEdge *)result; + return _swig_go_result; +} + + +void _wrap_btInternalEdge_m_face0_set_mbt_e879218550ba2e2b(btInternalEdge *_swig_go_0, short _swig_go_1) { + btInternalEdge *arg1 = (btInternalEdge *) 0 ; + short arg2 ; + + arg1 = *(btInternalEdge **)&_swig_go_0; + arg2 = (short)_swig_go_1; + + if (arg1) (arg1)->m_face0 = arg2; + +} + + +short _wrap_btInternalEdge_m_face0_get_mbt_e879218550ba2e2b(btInternalEdge *_swig_go_0) { + btInternalEdge *arg1 = (btInternalEdge *) 0 ; + short result; + short _swig_go_result; + + arg1 = *(btInternalEdge **)&_swig_go_0; + + result = (short) ((arg1)->m_face0); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btInternalEdge_m_face1_set_mbt_e879218550ba2e2b(btInternalEdge *_swig_go_0, short _swig_go_1) { + btInternalEdge *arg1 = (btInternalEdge *) 0 ; + short arg2 ; + + arg1 = *(btInternalEdge **)&_swig_go_0; + arg2 = (short)_swig_go_1; + + if (arg1) (arg1)->m_face1 = arg2; + +} + + +short _wrap_btInternalEdge_m_face1_get_mbt_e879218550ba2e2b(btInternalEdge *_swig_go_0) { + btInternalEdge *arg1 = (btInternalEdge *) 0 ; + short result; + short _swig_go_result; + + arg1 = *(btInternalEdge **)&_swig_go_0; + + result = (short) ((arg1)->m_face1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btInternalEdge_mbt_e879218550ba2e2b(btInternalEdge *_swig_go_0) { + btInternalEdge *arg1 = (btInternalEdge *) 0 ; + + arg1 = *(btInternalEdge **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConvexHullComputer_vertices_set_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0, btAlignedObjectArray< btVector3 > *_swig_go_1) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + btAlignedObjectArray< btVector3 > *arg2 = (btAlignedObjectArray< btVector3 > *) 0 ; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btVector3 > **)&_swig_go_1; + + if (arg1) (arg1)->vertices = *arg2; + +} + + +btAlignedObjectArray< btVector3 > *_wrap_btConvexHullComputer_vertices_get_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + btAlignedObjectArray< btVector3 > *result = 0 ; + btAlignedObjectArray< btVector3 > *_swig_go_result; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + + result = (btAlignedObjectArray< btVector3 > *)& ((arg1)->vertices); + *(btAlignedObjectArray< btVector3 > **)&_swig_go_result = (btAlignedObjectArray< btVector3 > *)result; + return _swig_go_result; +} + + +void _wrap_btConvexHullComputer_original_vertex_index_set_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0, btAlignedObjectArray< int > *_swig_go_1) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + btAlignedObjectArray< int > *arg2 = (btAlignedObjectArray< int > *) 0 ; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< int > **)&_swig_go_1; + + if (arg1) (arg1)->original_vertex_index = *arg2; + +} + + +btAlignedObjectArray< int > *_wrap_btConvexHullComputer_original_vertex_index_get_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + btAlignedObjectArray< int > *result = 0 ; + btAlignedObjectArray< int > *_swig_go_result; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + + result = (btAlignedObjectArray< int > *)& ((arg1)->original_vertex_index); + *(btAlignedObjectArray< int > **)&_swig_go_result = (btAlignedObjectArray< int > *)result; + return _swig_go_result; +} + + +void _wrap_btConvexHullComputer_edges_set_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0, btAlignedObjectArray< btConvexHullComputer::Edge > *_swig_go_1) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + btAlignedObjectArray< btConvexHullComputer::Edge > *arg2 = (btAlignedObjectArray< btConvexHullComputer::Edge > *) 0 ; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btConvexHullComputer::Edge > **)&_swig_go_1; + + if (arg1) (arg1)->edges = *arg2; + +} + + +btAlignedObjectArray< btConvexHullComputer::Edge > *_wrap_btConvexHullComputer_edges_get_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + btAlignedObjectArray< btConvexHullComputer::Edge > *result = 0 ; + btAlignedObjectArray< btConvexHullComputer::Edge > *_swig_go_result; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + + result = (btAlignedObjectArray< btConvexHullComputer::Edge > *)& ((arg1)->edges); + *(btAlignedObjectArray< btConvexHullComputer::Edge > **)&_swig_go_result = (btAlignedObjectArray< btConvexHullComputer::Edge > *)result; + return _swig_go_result; +} + + +void _wrap_btConvexHullComputer_faces_set_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0, btAlignedObjectArray< int > *_swig_go_1) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + btAlignedObjectArray< int > *arg2 = (btAlignedObjectArray< int > *) 0 ; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< int > **)&_swig_go_1; + + if (arg1) (arg1)->faces = *arg2; + +} + + +btAlignedObjectArray< int > *_wrap_btConvexHullComputer_faces_get_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + btAlignedObjectArray< int > *result = 0 ; + btAlignedObjectArray< int > *_swig_go_result; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + + result = (btAlignedObjectArray< int > *)& ((arg1)->faces); + *(btAlignedObjectArray< int > **)&_swig_go_result = (btAlignedObjectArray< int > *)result; + return _swig_go_result; +} + + +float _wrap_btConvexHullComputer_compute__SWIG_0_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0, float *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3, float _swig_go_4, float _swig_go_5) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + float *arg2 = (float *) 0 ; + int arg3 ; + int arg4 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + result = (btScalar)(arg1)->compute((float const *)arg2,arg3,arg4,arg5,arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConvexHullComputer_compute__SWIG_1_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0, double *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3, float _swig_go_4, float _swig_go_5) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + double *arg2 = (double *) 0 ; + int arg3 ; + int arg4 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + result = (btScalar)(arg1)->compute((double const *)arg2,arg3,arg4,arg5,arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +btConvexHullComputer *_wrap_new_btConvexHullComputer_mbt_e879218550ba2e2b() { + btConvexHullComputer *result = 0 ; + btConvexHullComputer *_swig_go_result; + + + result = (btConvexHullComputer *)new btConvexHullComputer(); + *(btConvexHullComputer **)&_swig_go_result = (btConvexHullComputer *)result; + return _swig_go_result; +} + + +void _wrap_delete_btConvexHullComputer_mbt_e879218550ba2e2b(btConvexHullComputer *_swig_go_0) { + btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; + + arg1 = *(btConvexHullComputer **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConvexHullInternal_vertexList_set_mbt_e879218550ba2e2b(btConvexHullInternal *_swig_go_0, btConvexHullInternal::Vertex *_swig_go_1) { + btConvexHullInternal *arg1 = (btConvexHullInternal *) 0 ; + btConvexHullInternal::Vertex *arg2 = (btConvexHullInternal::Vertex *) 0 ; + + arg1 = *(btConvexHullInternal **)&_swig_go_0; + arg2 = *(btConvexHullInternal::Vertex **)&_swig_go_1; + + if (arg1) (arg1)->vertexList = arg2; + +} + + +btConvexHullInternal::Vertex *_wrap_btConvexHullInternal_vertexList_get_mbt_e879218550ba2e2b(btConvexHullInternal *_swig_go_0) { + btConvexHullInternal *arg1 = (btConvexHullInternal *) 0 ; + btConvexHullInternal::Vertex *result = 0 ; + btConvexHullInternal::Vertex *_swig_go_result; + + arg1 = *(btConvexHullInternal **)&_swig_go_0; + + result = (btConvexHullInternal::Vertex *) ((arg1)->vertexList); + *(btConvexHullInternal::Vertex **)&_swig_go_result = (btConvexHullInternal::Vertex *)result; + return _swig_go_result; +} + + +void _wrap_btConvexHullInternal_compute_mbt_e879218550ba2e2b(btConvexHullInternal *_swig_go_0, void *_swig_go_1, bool _swig_go_2, intgo _swig_go_3, intgo _swig_go_4) { + btConvexHullInternal *arg1 = (btConvexHullInternal *) 0 ; + void *arg2 = (void *) 0 ; + bool arg3 ; + int arg4 ; + int arg5 ; + + arg1 = *(btConvexHullInternal **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = (bool)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (int)_swig_go_4; + + (arg1)->compute((void const *)arg2,arg3,arg4,arg5); + +} + + +btVector3 *_wrap_btConvexHullInternal_getCoordinates_mbt_e879218550ba2e2b(btConvexHullInternal *_swig_go_0, btConvexHullInternal::Vertex *_swig_go_1) { + btConvexHullInternal *arg1 = (btConvexHullInternal *) 0 ; + btConvexHullInternal::Vertex *arg2 = (btConvexHullInternal::Vertex *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConvexHullInternal **)&_swig_go_0; + arg2 = *(btConvexHullInternal::Vertex **)&_swig_go_1; + + result = (arg1)->getCoordinates((btConvexHullInternal::Vertex const *)arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btConvexHullInternal_shrink_mbt_e879218550ba2e2b(btConvexHullInternal *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btConvexHullInternal *arg1 = (btConvexHullInternal *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexHullInternal **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = (btScalar)(arg1)->shrink(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +btConvexHullInternal *_wrap_new_btConvexHullInternal_mbt_e879218550ba2e2b() { + btConvexHullInternal *result = 0 ; + btConvexHullInternal *_swig_go_result; + + + result = (btConvexHullInternal *)new btConvexHullInternal(); + *(btConvexHullInternal **)&_swig_go_result = (btConvexHullInternal *)result; + return _swig_go_result; +} + + +void _wrap_delete_btConvexHullInternal_mbt_e879218550ba2e2b(btConvexHullInternal *_swig_go_0) { + btConvexHullInternal *arg1 = (btConvexHullInternal *) 0 ; + + arg1 = *(btConvexHullInternal **)&_swig_go_0; + + delete arg1; + +} + + +pointCmp *_wrap_new_pointCmp_mbt_e879218550ba2e2b() { + pointCmp *result = 0 ; + pointCmp *_swig_go_result; + + + result = (pointCmp *)new pointCmp(); + *(pointCmp **)&_swig_go_result = (pointCmp *)result; + return _swig_go_result; +} + + +void _wrap_delete_pointCmp_mbt_e879218550ba2e2b(pointCmp *_swig_go_0) { + pointCmp *arg1 = (pointCmp *) 0 ; + + arg1 = *(pointCmp **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_getVertexCopy_mbt_e879218550ba2e2b(btConvexHullInternal::Vertex *_swig_go_0, btAlignedObjectArray< btConvexHullInternal::Vertex * > *_swig_go_1) { + btConvexHullInternal::Vertex *arg1 = (btConvexHullInternal::Vertex *) 0 ; + btAlignedObjectArray< btConvexHullInternal::Vertex * > *arg2 = 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexHullInternal::Vertex **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btConvexHullInternal::Vertex * > **)&_swig_go_1; + + result = (int)getVertexCopy(arg1,*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeometryUtil_getPlaneEquationsFromVertices_mbt_e879218550ba2e2b(btAlignedObjectArray< btVector3 > *_swig_go_0, btAlignedObjectArray< btVector3 > *_swig_go_1) { + btAlignedObjectArray< btVector3 > *arg1 = 0 ; + btAlignedObjectArray< btVector3 > *arg2 = 0 ; + + arg1 = *(btAlignedObjectArray< btVector3 > **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btVector3 > **)&_swig_go_1; + + btGeometryUtil::getPlaneEquationsFromVertices(*arg1,*arg2); + +} + + +void _wrap_btGeometryUtil_getVerticesFromPlaneEquations_mbt_e879218550ba2e2b(btAlignedObjectArray< btVector3 > *_swig_go_0, btAlignedObjectArray< btVector3 > *_swig_go_1) { + btAlignedObjectArray< btVector3 > *arg1 = 0 ; + btAlignedObjectArray< btVector3 > *arg2 = 0 ; + + arg1 = *(btAlignedObjectArray< btVector3 > **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btVector3 > **)&_swig_go_1; + + btGeometryUtil::getVerticesFromPlaneEquations((btAlignedObjectArray< btVector3 > const &)*arg1,*arg2); + +} + + +bool _wrap_btGeometryUtil_isPointInsidePlanes_mbt_e879218550ba2e2b(btAlignedObjectArray< btVector3 > *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btAlignedObjectArray< btVector3 > *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + bool result; + bool _swig_go_result; + + arg1 = *(btAlignedObjectArray< btVector3 > **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = (bool)btGeometryUtil::isPointInsidePlanes((btAlignedObjectArray< btVector3 > const &)*arg1,(btVector3 const &)*arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btGeometryUtil_areVerticesBehindPlane_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btAlignedObjectArray< btVector3 > *_swig_go_1, float _swig_go_2) { + btVector3 *arg1 = 0 ; + btAlignedObjectArray< btVector3 > *arg2 = 0 ; + btScalar arg3 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btVector3 > **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = (bool)btGeometryUtil::areVerticesBehindPlane((btVector3 const &)*arg1,(btAlignedObjectArray< btVector3 > const &)*arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +btGeometryUtil *_wrap_new_btGeometryUtil_mbt_e879218550ba2e2b() { + btGeometryUtil *result = 0 ; + btGeometryUtil *_swig_go_result; + + + result = (btGeometryUtil *)new btGeometryUtil(); + *(btGeometryUtil **)&_swig_go_result = (btGeometryUtil *)result; + return _swig_go_result; +} + + +void _wrap_delete_btGeometryUtil_mbt_e879218550ba2e2b(btGeometryUtil *_swig_go_0) { + btGeometryUtil *arg1 = (btGeometryUtil *) 0 ; + + arg1 = *(btGeometryUtil **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btBulletMathProbe_mbt_e879218550ba2e2b() { + btBulletMathProbe(); + +} + + +bool _wrap_notExist_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btAlignedObjectArray< btVector3 > *_swig_go_1) { + btVector3 *arg1 = 0 ; + btAlignedObjectArray< btVector3 > *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btVector3 > **)&_swig_go_1; + + result = (bool)notExist((btVector3 const &)*arg1,(btAlignedObjectArray< btVector3 > const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +GrahamVector3 *_wrap_new_GrahamVector3_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, intgo _swig_go_1) { + btVector3 *arg1 = 0 ; + int arg2 ; + GrahamVector3 *result = 0 ; + GrahamVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (GrahamVector3 *)new GrahamVector3((btVector3 const &)*arg1,arg2); + *(GrahamVector3 **)&_swig_go_result = (GrahamVector3 *)result; + return _swig_go_result; +} + + +void _wrap_GrahamVector3_m_angle_set_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, float _swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar arg2 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_angle = arg2; + +} + + +float _wrap_GrahamVector3_m_angle_get_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_angle); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GrahamVector3_m_orgIndex_set_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, intgo _swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + int arg2 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_orgIndex = arg2; + +} + + +intgo _wrap_GrahamVector3_m_orgIndex_get_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + result = (int) ((arg1)->m_orgIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_GrahamVector3_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_SetGrahamVector3_M_floats_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, float *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar *arg2 = (btScalar *) (btScalar *)0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + ; + +} + + +float *_wrap_GetGrahamVector3_M_floats_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar *result = 0 ; + float *_swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *)(btScalar *) ((swig_b0)->m_floats); + *(btScalar **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_dot_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->dot((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_length2_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->length2(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_length_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->length(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_norm_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->norm(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_safeNorm_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->safeNorm(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_distance2_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->distance2((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_distance_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->distance((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_GrahamVector3_safeNormalize_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btVector3 *) &(swig_b0)->safeNormalize(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_GrahamVector3_normalize_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btVector3 *) &(swig_b0)->normalize(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_GrahamVector3_normalized_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->normalized(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_GrahamVector3_rotate_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->rotate((btVector3 const &)*arg2,arg3); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_GrahamVector3_angle_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->angle((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_GrahamVector3_absolute_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->absolute(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_GrahamVector3_cross_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->cross((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_GrahamVector3_triple_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar)((btVector3 const *)swig_b0)->triple((btVector3 const &)*arg2,(btVector3 const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_GrahamVector3_minAxis_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (int)((btVector3 const *)swig_b0)->minAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_GrahamVector3_maxAxis_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (int)((btVector3 const *)swig_b0)->maxAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_GrahamVector3_furthestAxis_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (int)((btVector3 const *)swig_b0)->furthestAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_GrahamVector3_closestAxis_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (int)((btVector3 const *)swig_b0)->closestAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GrahamVector3_setInterpolate3_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setInterpolate3((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +btVector3 *_wrap_GrahamVector3_lerp_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->lerp((btVector3 const &)*arg2,(btScalar const &)*arg3); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_GrahamVector3_getX_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->getX(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_getY_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->getY(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_getZ_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->getZ(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_GrahamVector3_setX_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, float _swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar arg2 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setX(arg2); + +} + + +void _wrap_GrahamVector3_setY_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, float _swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar arg2 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setY(arg2); + +} + + +void _wrap_GrahamVector3_setZ_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, float _swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar arg2 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setZ(arg2); + +} + + +void _wrap_GrahamVector3_setW_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, float _swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar arg2 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setW(arg2); + +} + + +float _wrap_GrahamVector3_x_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->x(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_y_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->y(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_z_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->z(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +float _wrap_GrahamVector3_w_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (btScalar *) &((btVector3 const *)swig_b0)->w(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +void _wrap_GrahamVector3_setMax_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setMax((btVector3 const &)*arg2); + +} + + +void _wrap_GrahamVector3_setMin_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setMin((btVector3 const &)*arg2); + +} + + +void _wrap_GrahamVector3_setValue_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btScalar *arg2 = 0 ; + btScalar *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = (btScalar *)&_swig_go_1; + arg3 = (btScalar *)&_swig_go_2; + arg4 = (btScalar *)&_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); + +} + + +void _wrap_GrahamVector3_getSkewSymmetricMatrix_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + btVector3 *arg4 = (btVector3 *) 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + ((btVector3 const *)swig_b0)->getSkewSymmetricMatrix(arg2,arg3,arg4); + +} + + +void _wrap_GrahamVector3_setZero_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->setZero(); + +} + + +bool _wrap_GrahamVector3_isZero_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (bool)((btVector3 const *)swig_b0)->isZero(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_GrahamVector3_fuzzyZero_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (bool)((btVector3 const *)swig_b0)->fuzzyZero(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GrahamVector3_serialize_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3FloatData *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + ((btVector3 const *)swig_b0)->serialize(*arg2); + +} + + +void _wrap_GrahamVector3_deSerialize__SWIG_0_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3DoubleData *arg2 = 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->deSerialize((btVector3DoubleData const &)*arg2); + +} + + +void _wrap_GrahamVector3_deSerialize__SWIG_1_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3FloatData *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->deSerialize((btVector3FloatData const &)*arg2); + +} + + +void _wrap_GrahamVector3_serializeFloat_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3FloatData *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + ((btVector3 const *)swig_b0)->serializeFloat(*arg2); + +} + + +void _wrap_GrahamVector3_deSerializeFloat_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3FloatData *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3FloatData *arg2 = 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->deSerializeFloat((btVector3FloatData const &)*arg2); + +} + + +void _wrap_GrahamVector3_serializeDouble_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3DoubleData *arg2 = 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + ((btVector3 const *)swig_b0)->serializeDouble(*arg2); + +} + + +void _wrap_GrahamVector3_deSerializeDouble_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3DoubleData *arg2 = 0 ; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + btVector3 *swig_b0 = (btVector3 *)arg1; + (swig_b0)->deSerializeDouble((btVector3DoubleData const &)*arg2); + +} + + +long long _wrap_GrahamVector3_maxDot_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1, long long _swig_go_2, float *_swig_go_3) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + long arg3 ; + btScalar *arg4 = 0 ; + long result; + long long _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (long)_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (long)((btVector3 const *)swig_b0)->maxDot((btVector3 const *)arg2,arg3,*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +long long _wrap_GrahamVector3_minDot_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1, long long _swig_go_2, float *_swig_go_3) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + long arg3 ; + btScalar *arg4 = 0 ; + long result; + long long _swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (long)_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = (long)((btVector3 const *)swig_b0)->minDot((btVector3 const *)arg2,arg3,*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_GrahamVector3_dot3_mbt_e879218550ba2e2b(GrahamVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(GrahamVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btVector3 *swig_b0 = (btVector3 *)arg1; + result = ((btVector3 const *)swig_b0)->dot3((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btAngleCompareFunc_m_anchor_set_mbt_e879218550ba2e2b(btAngleCompareFunc *_swig_go_0, btVector3 *_swig_go_1) { + btAngleCompareFunc *arg1 = (btAngleCompareFunc *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btAngleCompareFunc **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_anchor = *arg2; + +} + + +btVector3 *_wrap_btAngleCompareFunc_m_anchor_get_mbt_e879218550ba2e2b(btAngleCompareFunc *_swig_go_0) { + btAngleCompareFunc *arg1 = (btAngleCompareFunc *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btAngleCompareFunc **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_anchor); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +btAngleCompareFunc *_wrap_new_btAngleCompareFunc_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = 0 ; + btAngleCompareFunc *result = 0 ; + btAngleCompareFunc *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btAngleCompareFunc *)new btAngleCompareFunc((btVector3 const &)*arg1); + *(btAngleCompareFunc **)&_swig_go_result = (btAngleCompareFunc *)result; + return _swig_go_result; +} + + +void _wrap_delete_btAngleCompareFunc_mbt_e879218550ba2e2b(btAngleCompareFunc *_swig_go_0) { + btAngleCompareFunc *arg1 = (btAngleCompareFunc *) 0 ; + + arg1 = *(btAngleCompareFunc **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_GrahamScanConvexHull2D_mbt_e879218550ba2e2b(btAlignedObjectArray< GrahamVector3 > *_swig_go_0, btAlignedObjectArray< GrahamVector3 > *_swig_go_1, btVector3 *_swig_go_2) { + btAlignedObjectArray< GrahamVector3 > *arg1 = 0 ; + btAlignedObjectArray< GrahamVector3 > *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btAlignedObjectArray< GrahamVector3 > **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< GrahamVector3 > **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + GrahamScanConvexHull2D(*arg1,*arg2,(btVector3 const &)*arg3); + +} + + +btVector3 *_wrap_btBoxShape_getHalfExtentsWithMargin_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + result = ((btBoxShape const *)arg1)->getHalfExtentsWithMargin(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btBoxShape_getHalfExtentsWithoutMargin_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + result = (btVector3 *) &((btBoxShape const *)arg1)->getHalfExtentsWithoutMargin(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btBoxShape_localGetSupportingVertex_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btBoxShape const *)arg1)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btBoxShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btBoxShape const *)arg1)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btBoxShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + int arg4 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + ((btBoxShape const *)arg1)->batchedUnitVectorGetSupportingVertexWithoutMargin((btVector3 const *)arg2,arg3,arg4); + +} + + +btBoxShape *_wrap_new_btBoxShape_mbt_e879218550ba2e2b(btVector3 *_swig_go_0) { + btVector3 *arg1 = 0 ; + btBoxShape *result = 0 ; + btBoxShape *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + + result = (btBoxShape *)new btBoxShape((btVector3 const &)*arg1); + *(btBoxShape **)&_swig_go_result = (btBoxShape *)result; + return _swig_go_result; +} + + +void _wrap_btBoxShape_setMargin_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, float _swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setMargin(arg2); + +} + + +void _wrap_btBoxShape_setLocalScaling_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +void _wrap_btBoxShape_getAabb_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btBoxShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btBoxShape_calculateLocalInertia_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btBoxShape const *)arg1)->calculateLocalInertia(arg2,*arg3); + +} + + +void _wrap_btBoxShape_getPlane_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + int arg4 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + ((btBoxShape const *)arg1)->getPlane(*arg2,*arg3,arg4); + +} + + +intgo _wrap_btBoxShape_getNumPlanes_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + result = (int)((btBoxShape const *)arg1)->getNumPlanes(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btBoxShape_getNumVertices_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + result = (int)((btBoxShape const *)arg1)->getNumVertices(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btBoxShape_getNumEdges_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + result = (int)((btBoxShape const *)arg1)->getNumEdges(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBoxShape_getVertex_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btBoxShape const *)arg1)->getVertex(arg2,*arg3); + +} + + +void _wrap_btBoxShape_getPlaneEquation_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector4 *_swig_go_1, intgo _swig_go_2) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector4 *arg2 = 0 ; + int arg3 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector4 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + + ((btBoxShape const *)arg1)->getPlaneEquation(*arg2,arg3); + +} + + +void _wrap_btBoxShape_getEdge_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btBoxShape const *)arg1)->getEdge(arg2,*arg3,*arg4); + +} + + +bool _wrap_btBoxShape_isInside_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = (bool)((btBoxShape const *)arg1)->isInside((btVector3 const &)*arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btBoxShape_getName_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + result = (char *)((btBoxShape const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btBoxShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + result = (int)((btBoxShape const *)arg1)->getNumPreferredPenetrationDirections(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBoxShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btBoxShape const *)arg1)->getPreferredPenetrationDirection(arg2,*arg3); + +} + + +void _wrap_delete_btBoxShape_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btBoxShape_initializePolyhedralFeatures__SWIG_0_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, intgo _swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = (bool)(swig_b0)->initializePolyhedralFeatures(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBoxShape_initializePolyhedralFeatures__SWIG_1_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = (bool)(swig_b0)->initializePolyhedralFeatures(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBoxShape_setPolyhedralFeatures_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btConvexPolyhedron *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btConvexPolyhedron *arg2 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btConvexPolyhedron **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + (swig_b0)->setPolyhedralFeatures(*arg2); + +} + + +btConvexPolyhedron *_wrap_btBoxShape_getConvexPolyhedron_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btConvexPolyhedron *result = 0 ; + btConvexPolyhedron *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + result = (btConvexPolyhedron *)((btPolyhedralConvexShape const *)swig_b0)->getConvexPolyhedron(); + *(btConvexPolyhedron **)&_swig_go_result = (btConvexPolyhedron *)result; + return _swig_go_result; +} + + +btVector3 *_wrap_btBoxShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getImplicitShapeDimensions(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBoxShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setImplicitShapeDimensions((btVector3 const &)*arg2); + +} + + +void _wrap_btBoxShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin(arg2,arg3); + +} + + +void _wrap_btBoxShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, float _swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin(arg2); + +} + + +void _wrap_btBoxShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btBoxShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin((btVector3 const &)*arg2); + +} + + +void _wrap_btBoxShape_getAabbSlow_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + ((btConvexInternalShape const *)swig_b1)->getAabbSlow((btTransform const &)*arg2,*arg3,*arg4); + +} + + +btVector3 *_wrap_btBoxShape_getLocalScaling_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btBoxShape_getLocalScalingNV_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getLocalScalingNV(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBoxShape_getMargin_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btScalar)((btConvexInternalShape const *)swig_b1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBoxShape_getMarginNV_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btScalar)((btConvexInternalShape const *)swig_b1)->getMarginNV(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btBoxShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (int)((btConvexInternalShape const *)swig_b1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btBoxShape_serialize_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (char *)((btConvexInternalShape const *)swig_b1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btVector3 *_wrap_btBoxShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = ((btConvexShape const *)swig_b2)->localGetSupportVertexWithoutMarginNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btBoxShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = ((btConvexShape const *)swig_b2)->localGetSupportVertexNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btBoxShape_getMarginNonVirtual_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = (btScalar)((btConvexShape const *)swig_b2)->getMarginNonVirtual(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBoxShape_getAabbNonVirtual_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + ((btConvexShape const *)swig_b2)->getAabbNonVirtual((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btBoxShape_project_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + ((btConvexShape const *)swig_b2)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +void _wrap_btBoxShape_getBoundingSphere_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btBoxShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (btScalar)((btCollisionShape const *)swig_b3)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBoxShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, float _swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (btScalar)((btCollisionShape const *)swig_b3)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBoxShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btBoxShape_isPolyhedral_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBoxShape_isConvex2d_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBoxShape_isConvex_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBoxShape_isNonMoving_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBoxShape_isConcave_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBoxShape_isCompound_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBoxShape_isSoftBody_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBoxShape_isInfinite_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btBoxShape_getShapeType_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btBoxShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = ((btCollisionShape const *)swig_b3)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btBoxShape_setUserPointer_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, void *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserPointer(arg2); + +} + + +void *_wrap_btBoxShape_getUserPointer_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (void *)((btCollisionShape const *)swig_b3)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btBoxShape_setUserIndex_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, intgo _swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int arg2 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserIndex(arg2); + +} + + +intgo _wrap_btBoxShape_getUserIndex_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBoxShape_setUserIndex2_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, intgo _swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int arg2 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserIndex2(arg2); + +} + + +intgo _wrap_btBoxShape_getUserIndex2_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBoxShape_serializeSingleShape_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btSerializer *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btPolyhedralConvexShape *swig_b0 = (btPolyhedralConvexShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->serializeSingleShape(arg2); + +} + + +btCapsuleShape *_wrap_new_btCapsuleShape__SWIG_1_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1) { + btScalar arg1 ; + btScalar arg2 ; + btCapsuleShape *result = 0 ; + btCapsuleShape *_swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (btCapsuleShape *)new btCapsuleShape(arg1,arg2); + *(btCapsuleShape **)&_swig_go_result = (btCapsuleShape *)result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_calculateLocalInertia_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btCapsuleShape const *)arg1)->calculateLocalInertia(arg2,*arg3); + +} + + +btVector3 *_wrap_btCapsuleShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btCapsuleShape const *)arg1)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + int arg4 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + ((btCapsuleShape const *)arg1)->batchedUnitVectorGetSupportingVertexWithoutMargin((btVector3 const *)arg2,arg3,arg4); + +} + + +void _wrap_btCapsuleShape_setMargin_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, float _swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setMargin(arg2); + +} + + +void _wrap_btCapsuleShape_getAabb_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btCapsuleShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +_gostring_ _wrap_btCapsuleShape_getName_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + result = (char *)((btCapsuleShape const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btCapsuleShape_getUpAxis_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + result = (int)((btCapsuleShape const *)arg1)->getUpAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShape_getRadius_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + result = (btScalar)((btCapsuleShape const *)arg1)->getRadius(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShape_getHalfHeight_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + result = (btScalar)((btCapsuleShape const *)arg1)->getHalfHeight(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_setLocalScaling_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btCapsuleShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + result = ((btCapsuleShape const *)arg1)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +intgo _wrap_btCapsuleShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + result = (int)((btCapsuleShape const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btCapsuleShape_serialize_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btCapsuleShape const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_deSerializeFloat_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btCapsuleShapeData *_swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btCapsuleShapeData *arg2 = (btCapsuleShapeData *) 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btCapsuleShapeData **)&_swig_go_1; + + (arg1)->deSerializeFloat(arg2); + +} + + +void _wrap_delete_btCapsuleShape_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + delete arg1; + +} + + +btVector3 *_wrap_btCapsuleShape_localGetSupportingVertex_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = ((btConvexInternalShape const *)swig_b0)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btCapsuleShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getImplicitShapeDimensions(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setImplicitShapeDimensions((btVector3 const &)*arg2); + +} + + +void _wrap_btCapsuleShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin(arg2,arg3); + +} + + +void _wrap_btCapsuleShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, float _swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin(arg2); + +} + + +void _wrap_btCapsuleShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btCapsuleShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + (swig_b0)->setSafeMargin((btVector3 const &)*arg2); + +} + + +void _wrap_btCapsuleShape_getAabbSlow_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + ((btConvexInternalShape const *)swig_b0)->getAabbSlow((btTransform const &)*arg2,*arg3,*arg4); + +} + + +btVector3 *_wrap_btCapsuleShape_getLocalScaling_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btCapsuleShape_getLocalScalingNV_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b0)->getLocalScalingNV(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShape_getMargin_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btScalar)((btConvexInternalShape const *)swig_b0)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShape_getMarginNV_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (btScalar)((btConvexInternalShape const *)swig_b0)->getMarginNV(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCapsuleShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + result = (int)((btConvexInternalShape const *)swig_b0)->getNumPreferredPenetrationDirections(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + ((btConvexInternalShape const *)swig_b0)->getPreferredPenetrationDirection(arg2,*arg3); + +} + + +btVector3 *_wrap_btCapsuleShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = ((btConvexShape const *)swig_b1)->localGetSupportVertexWithoutMarginNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btCapsuleShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = ((btConvexShape const *)swig_b1)->localGetSupportVertexNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btCapsuleShape_getMarginNonVirtual_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + result = (btScalar)((btConvexShape const *)swig_b1)->getMarginNonVirtual(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_getAabbNonVirtual_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + ((btConvexShape const *)swig_b1)->getAabbNonVirtual((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btCapsuleShape_project_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + ((btConvexShape const *)swig_b1)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +void _wrap_btCapsuleShape_getBoundingSphere_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btCapsuleShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (btScalar)((btCollisionShape const *)swig_b2)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, float _swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (btScalar)((btCollisionShape const *)swig_b2)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btCapsuleShape_isPolyhedral_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShape_isConvex2d_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShape_isConvex_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShape_isNonMoving_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShape_isConcave_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShape_isCompound_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShape_isSoftBody_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShape_isInfinite_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCapsuleShape_getShapeType_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_setUserPointer_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, void *_swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserPointer(arg2); + +} + + +void *_wrap_btCapsuleShape_getUserPointer_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (void *)((btCollisionShape const *)swig_b2)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_setUserIndex_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, intgo _swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + int arg2 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserIndex(arg2); + +} + + +intgo _wrap_btCapsuleShape_getUserIndex_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_setUserIndex2_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, intgo _swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + int arg2 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserIndex2(arg2); + +} + + +intgo _wrap_btCapsuleShape_getUserIndex2_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShape_serializeSingleShape_mbt_e879218550ba2e2b(btCapsuleShape *_swig_go_0, btSerializer *_swig_go_1) { + btCapsuleShape *arg1 = (btCapsuleShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btCapsuleShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btConvexInternalShape *swig_b0 = (btConvexInternalShape *)arg1; + btConvexShape *swig_b1 = (btConvexShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->serializeSingleShape(arg2); + +} + + +btCapsuleShapeX *_wrap_new_btCapsuleShapeX_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1) { + btScalar arg1 ; + btScalar arg2 ; + btCapsuleShapeX *result = 0 ; + btCapsuleShapeX *_swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (btCapsuleShapeX *)new btCapsuleShapeX(arg1,arg2); + *(btCapsuleShapeX **)&_swig_go_result = (btCapsuleShapeX *)result; + return _swig_go_result; +} + + +_gostring_ _wrap_btCapsuleShapeX_getName_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + result = (char *)((btCapsuleShapeX const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_delete_btCapsuleShapeX_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btCapsuleShapeX_calculateLocalInertia_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + ((btCapsuleShape const *)swig_b0)->calculateLocalInertia(arg2,*arg3); + +} + + +btVector3 *_wrap_btCapsuleShapeX_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = ((btCapsuleShape const *)swig_b0)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + int arg4 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + ((btCapsuleShape const *)swig_b0)->batchedUnitVectorGetSupportingVertexWithoutMargin((btVector3 const *)arg2,arg3,arg4); + +} + + +void _wrap_btCapsuleShapeX_setMargin_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, float _swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar arg2 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + (swig_b0)->setMargin(arg2); + +} + + +void _wrap_btCapsuleShapeX_getAabb_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + ((btCapsuleShape const *)swig_b0)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +intgo _wrap_btCapsuleShapeX_getUpAxis_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = (int)((btCapsuleShape const *)swig_b0)->getUpAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeX_getRadius_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = (btScalar)((btCapsuleShape const *)swig_b0)->getRadius(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeX_getHalfHeight_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = (btScalar)((btCapsuleShape const *)swig_b0)->getHalfHeight(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_setLocalScaling_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + (swig_b0)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btCapsuleShapeX_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = ((btCapsuleShape const *)swig_b0)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +intgo _wrap_btCapsuleShapeX_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = (int)((btCapsuleShape const *)swig_b0)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btCapsuleShapeX_serialize_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = (char *)((btCapsuleShape const *)swig_b0)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_deSerializeFloat_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btCapsuleShapeData *_swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btCapsuleShapeData *arg2 = (btCapsuleShapeData *) 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btCapsuleShapeData **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + (swig_b0)->deSerializeFloat(arg2); + +} + + +btVector3 *_wrap_btCapsuleShapeX_localGetSupportingVertex_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = ((btConvexInternalShape const *)swig_b1)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btCapsuleShapeX_getImplicitShapeDimensions_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getImplicitShapeDimensions(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_setImplicitShapeDimensions_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setImplicitShapeDimensions((btVector3 const &)*arg2); + +} + + +void _wrap_btCapsuleShapeX_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin(arg2,arg3); + +} + + +void _wrap_btCapsuleShapeX_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, float _swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar arg2 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin(arg2); + +} + + +void _wrap_btCapsuleShapeX_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btCapsuleShapeX_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin((btVector3 const &)*arg2); + +} + + +void _wrap_btCapsuleShapeX_getAabbSlow_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + ((btConvexInternalShape const *)swig_b1)->getAabbSlow((btTransform const &)*arg2,*arg3,*arg4); + +} + + +btVector3 *_wrap_btCapsuleShapeX_getLocalScaling_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btCapsuleShapeX_getLocalScalingNV_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getLocalScalingNV(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeX_getMargin_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btScalar)((btConvexInternalShape const *)swig_b1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeX_getMarginNV_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btScalar)((btConvexInternalShape const *)swig_b1)->getMarginNV(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCapsuleShapeX_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (int)((btConvexInternalShape const *)swig_b1)->getNumPreferredPenetrationDirections(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + ((btConvexInternalShape const *)swig_b1)->getPreferredPenetrationDirection(arg2,*arg3); + +} + + +btVector3 *_wrap_btCapsuleShapeX_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = ((btConvexShape const *)swig_b2)->localGetSupportVertexWithoutMarginNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btCapsuleShapeX_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = ((btConvexShape const *)swig_b2)->localGetSupportVertexNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeX_getMarginNonVirtual_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = (btScalar)((btConvexShape const *)swig_b2)->getMarginNonVirtual(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_getAabbNonVirtual_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + ((btConvexShape const *)swig_b2)->getAabbNonVirtual((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btCapsuleShapeX_project_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + ((btConvexShape const *)swig_b2)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +void _wrap_btCapsuleShapeX_getBoundingSphere_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btCapsuleShapeX_getAngularMotionDisc_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (btScalar)((btCollisionShape const *)swig_b3)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeX_getContactBreakingThreshold_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, float _swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (btScalar)((btCollisionShape const *)swig_b3)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_calculateTemporalAabb_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btCapsuleShapeX_isPolyhedral_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeX_isConvex2d_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeX_isConvex_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeX_isNonMoving_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeX_isConcave_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeX_isCompound_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeX_isSoftBody_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeX_isInfinite_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCapsuleShapeX_getShapeType_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_setUserPointer_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, void *_swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserPointer(arg2); + +} + + +void *_wrap_btCapsuleShapeX_getUserPointer_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (void *)((btCollisionShape const *)swig_b3)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_setUserIndex_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, intgo _swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + int arg2 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserIndex(arg2); + +} + + +intgo _wrap_btCapsuleShapeX_getUserIndex_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_setUserIndex2_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, intgo _swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + int arg2 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserIndex2(arg2); + +} + + +intgo _wrap_btCapsuleShapeX_getUserIndex2_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeX_serializeSingleShape_mbt_e879218550ba2e2b(btCapsuleShapeX *_swig_go_0, btSerializer *_swig_go_1) { + btCapsuleShapeX *arg1 = (btCapsuleShapeX *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btCapsuleShapeX **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->serializeSingleShape(arg2); + +} + + +btCapsuleShapeZ *_wrap_new_btCapsuleShapeZ_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1) { + btScalar arg1 ; + btScalar arg2 ; + btCapsuleShapeZ *result = 0 ; + btCapsuleShapeZ *_swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (btCapsuleShapeZ *)new btCapsuleShapeZ(arg1,arg2); + *(btCapsuleShapeZ **)&_swig_go_result = (btCapsuleShapeZ *)result; + return _swig_go_result; +} + + +_gostring_ _wrap_btCapsuleShapeZ_getName_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + result = (char *)((btCapsuleShapeZ const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_delete_btCapsuleShapeZ_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btCapsuleShapeZ_calculateLocalInertia_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + ((btCapsuleShape const *)swig_b0)->calculateLocalInertia(arg2,*arg3); + +} + + +btVector3 *_wrap_btCapsuleShapeZ_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = ((btCapsuleShape const *)swig_b0)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + int arg4 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + ((btCapsuleShape const *)swig_b0)->batchedUnitVectorGetSupportingVertexWithoutMargin((btVector3 const *)arg2,arg3,arg4); + +} + + +void _wrap_btCapsuleShapeZ_setMargin_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, float _swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar arg2 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + (swig_b0)->setMargin(arg2); + +} + + +void _wrap_btCapsuleShapeZ_getAabb_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + ((btCapsuleShape const *)swig_b0)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +intgo _wrap_btCapsuleShapeZ_getUpAxis_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = (int)((btCapsuleShape const *)swig_b0)->getUpAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeZ_getRadius_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = (btScalar)((btCapsuleShape const *)swig_b0)->getRadius(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeZ_getHalfHeight_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = (btScalar)((btCapsuleShape const *)swig_b0)->getHalfHeight(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_setLocalScaling_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + (swig_b0)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btCapsuleShapeZ_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = ((btCapsuleShape const *)swig_b0)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +intgo _wrap_btCapsuleShapeZ_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = (int)((btCapsuleShape const *)swig_b0)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btCapsuleShapeZ_serialize_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + result = (char *)((btCapsuleShape const *)swig_b0)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_deSerializeFloat_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btCapsuleShapeData *_swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btCapsuleShapeData *arg2 = (btCapsuleShapeData *) 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btCapsuleShapeData **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + (swig_b0)->deSerializeFloat(arg2); + +} + + +btVector3 *_wrap_btCapsuleShapeZ_localGetSupportingVertex_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = ((btConvexInternalShape const *)swig_b1)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btCapsuleShapeZ_getImplicitShapeDimensions_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getImplicitShapeDimensions(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_setImplicitShapeDimensions_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setImplicitShapeDimensions((btVector3 const &)*arg2); + +} + + +void _wrap_btCapsuleShapeZ_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin(arg2,arg3); + +} + + +void _wrap_btCapsuleShapeZ_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, float _swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar arg2 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin(arg2); + +} + + +void _wrap_btCapsuleShapeZ_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btCapsuleShapeZ_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + (swig_b1)->setSafeMargin((btVector3 const &)*arg2); + +} + + +void _wrap_btCapsuleShapeZ_getAabbSlow_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + ((btConvexInternalShape const *)swig_b1)->getAabbSlow((btTransform const &)*arg2,*arg3,*arg4); + +} + + +btVector3 *_wrap_btCapsuleShapeZ_getLocalScaling_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btCapsuleShapeZ_getLocalScalingNV_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btVector3 *) &((btConvexInternalShape const *)swig_b1)->getLocalScalingNV(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeZ_getMargin_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btScalar)((btConvexInternalShape const *)swig_b1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeZ_getMarginNV_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (btScalar)((btConvexInternalShape const *)swig_b1)->getMarginNV(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCapsuleShapeZ_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + result = (int)((btConvexInternalShape const *)swig_b1)->getNumPreferredPenetrationDirections(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + ((btConvexInternalShape const *)swig_b1)->getPreferredPenetrationDirection(arg2,*arg3); + +} + + +btVector3 *_wrap_btCapsuleShapeZ_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = ((btConvexShape const *)swig_b2)->localGetSupportVertexWithoutMarginNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btCapsuleShapeZ_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btVector3 *_swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = ((btConvexShape const *)swig_b2)->localGetSupportVertexNonVirtual((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeZ_getMarginNonVirtual_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + result = (btScalar)((btConvexShape const *)swig_b2)->getMarginNonVirtual(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_getAabbNonVirtual_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + ((btConvexShape const *)swig_b2)->getAabbNonVirtual((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btCapsuleShapeZ_project_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + ((btConvexShape const *)swig_b2)->project((btTransform const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5,*arg6,*arg7); + +} + + +void _wrap_btCapsuleShapeZ_getBoundingSphere_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btCapsuleShapeZ_getAngularMotionDisc_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (btScalar)((btCollisionShape const *)swig_b3)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCapsuleShapeZ_getContactBreakingThreshold_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, float _swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (btScalar)((btCollisionShape const *)swig_b3)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_calculateTemporalAabb_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btCapsuleShapeZ_isPolyhedral_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeZ_isConvex2d_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeZ_isConvex_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeZ_isNonMoving_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeZ_isConcave_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeZ_isCompound_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeZ_isSoftBody_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCapsuleShapeZ_isInfinite_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (bool)((btCollisionShape const *)swig_b3)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCapsuleShapeZ_getShapeType_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_setUserPointer_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, void *_swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserPointer(arg2); + +} + + +void *_wrap_btCapsuleShapeZ_getUserPointer_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (void *)((btCollisionShape const *)swig_b3)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_setUserIndex_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, intgo _swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + int arg2 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserIndex(arg2); + +} + + +intgo _wrap_btCapsuleShapeZ_getUserIndex_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_setUserIndex2_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, intgo _swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + int arg2 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + (swig_b3)->setUserIndex2(arg2); + +} + + +intgo _wrap_btCapsuleShapeZ_getUserIndex2_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + result = (int)((btCollisionShape const *)swig_b3)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeZ_serializeSingleShape_mbt_e879218550ba2e2b(btCapsuleShapeZ *_swig_go_0, btSerializer *_swig_go_1) { + btCapsuleShapeZ *arg1 = (btCapsuleShapeZ *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btCapsuleShapeZ **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btCapsuleShape *swig_b0 = (btCapsuleShape *)arg1; + btConvexInternalShape *swig_b1 = (btConvexInternalShape *)swig_b0; + btConvexShape *swig_b2 = (btConvexShape *)swig_b1; + btCollisionShape *swig_b3 = (btCollisionShape *)swig_b2; + ((btCollisionShape const *)swig_b3)->serializeSingleShape(arg2); + +} + + +void _wrap_btCapsuleShapeData_m_convexInternalShapeData_set_mbt_e879218550ba2e2b(btCapsuleShapeData *_swig_go_0, btConvexInternalShapeData *_swig_go_1) { + btCapsuleShapeData *arg1 = (btCapsuleShapeData *) 0 ; + btConvexInternalShapeData *arg2 = (btConvexInternalShapeData *) 0 ; + + arg1 = *(btCapsuleShapeData **)&_swig_go_0; + arg2 = *(btConvexInternalShapeData **)&_swig_go_1; + + if (arg1) (arg1)->m_convexInternalShapeData = *arg2; + +} + + +btConvexInternalShapeData *_wrap_btCapsuleShapeData_m_convexInternalShapeData_get_mbt_e879218550ba2e2b(btCapsuleShapeData *_swig_go_0) { + btCapsuleShapeData *arg1 = (btCapsuleShapeData *) 0 ; + btConvexInternalShapeData *result = 0 ; + btConvexInternalShapeData *_swig_go_result; + + arg1 = *(btCapsuleShapeData **)&_swig_go_0; + + result = (btConvexInternalShapeData *)& ((arg1)->m_convexInternalShapeData); + *(btConvexInternalShapeData **)&_swig_go_result = (btConvexInternalShapeData *)result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeData_m_upAxis_set_mbt_e879218550ba2e2b(btCapsuleShapeData *_swig_go_0, intgo _swig_go_1) { + btCapsuleShapeData *arg1 = (btCapsuleShapeData *) 0 ; + int arg2 ; + + arg1 = *(btCapsuleShapeData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_upAxis = arg2; + +} + + +intgo _wrap_btCapsuleShapeData_m_upAxis_get_mbt_e879218550ba2e2b(btCapsuleShapeData *_swig_go_0) { + btCapsuleShapeData *arg1 = (btCapsuleShapeData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCapsuleShapeData **)&_swig_go_0; + + result = (int) ((arg1)->m_upAxis); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCapsuleShapeData_m_padding_set_mbt_e879218550ba2e2b(btCapsuleShapeData *_swig_go_0, _gostring_ _swig_go_1) { + btCapsuleShapeData *arg1 = (btCapsuleShapeData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btCapsuleShapeData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_padding, (const char *)arg2, 4-1); + arg1->m_padding[4-1] = 0; + } else { + arg1->m_padding[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btCapsuleShapeData_m_padding_get_mbt_e879218550ba2e2b(btCapsuleShapeData *_swig_go_0) { + btCapsuleShapeData *arg1 = (btCapsuleShapeData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCapsuleShapeData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_padding); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btCapsuleShapeData *_wrap_new_btCapsuleShapeData_mbt_e879218550ba2e2b() { + btCapsuleShapeData *result = 0 ; + btCapsuleShapeData *_swig_go_result; + + + result = (btCapsuleShapeData *)new btCapsuleShapeData(); + *(btCapsuleShapeData **)&_swig_go_result = (btCapsuleShapeData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCapsuleShapeData_mbt_e879218550ba2e2b(btCapsuleShapeData *_swig_go_0) { + btCapsuleShapeData *arg1 = (btCapsuleShapeData *) 0 ; + + arg1 = *(btCapsuleShapeData **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_CF_DYNAMIC_OBJECT_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_DYNAMIC_OBJECT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_STATIC_OBJECT_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_STATIC_OBJECT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_KINEMATIC_OBJECT_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_KINEMATIC_OBJECT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_NO_CONTACT_RESPONSE_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_NO_CONTACT_RESPONSE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_CUSTOM_MATERIAL_CALLBACK_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_CHARACTER_OBJECT_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_CHARACTER_OBJECT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_DISABLE_VISUALIZE_OBJECT_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_DISABLE_SPU_COLLISION_PROCESSING_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_DISABLE_SPU_COLLISION_PROCESSING; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_HAS_CONTACT_STIFFNESS_DAMPING_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_HAS_CONTACT_STIFFNESS_DAMPING; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_HAS_FRICTION_ANCHOR_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_HAS_FRICTION_ANCHOR; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_HAS_COLLISION_SOUND_TRIGGER_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_HAS_COLLISION_SOUND_TRIGGER; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CO_COLLISION_OBJECT_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionObjectTypes result; + intgo _swig_go_result; + + + result = btCollisionObject::CO_COLLISION_OBJECT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CO_RIGID_BODY_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionObjectTypes result; + intgo _swig_go_result; + + + result = btCollisionObject::CO_RIGID_BODY; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CO_GHOST_OBJECT_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionObjectTypes result; + intgo _swig_go_result; + + + result = btCollisionObject::CO_GHOST_OBJECT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CO_SOFT_BODY_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionObjectTypes result; + intgo _swig_go_result; + + + result = btCollisionObject::CO_SOFT_BODY; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CO_HF_FLUID_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionObjectTypes result; + intgo _swig_go_result; + + + result = btCollisionObject::CO_HF_FLUID; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CO_USER_TYPE_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionObjectTypes result; + intgo _swig_go_result; + + + result = btCollisionObject::CO_USER_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CO_FEATHERSTONE_LINK_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::CollisionObjectTypes result; + intgo _swig_go_result; + + + result = btCollisionObject::CO_FEATHERSTONE_LINK; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_ANISOTROPIC_FRICTION_DISABLED_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::AnisotropicFrictionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_ANISOTROPIC_FRICTION_DISABLED; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_ANISOTROPIC_FRICTION_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::AnisotropicFrictionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_ANISOTROPIC_FRICTION; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CF_ANISOTROPIC_ROLLING_FRICTION_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject::AnisotropicFrictionFlags result; + intgo _swig_go_result; + + + result = btCollisionObject::CF_ANISOTROPIC_ROLLING_FRICTION; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +bool _wrap_btCollisionObject_mergesSimulationIslands_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (bool)((btCollisionObject const *)arg1)->mergesSimulationIslands(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btCollisionObject_getAnisotropicFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btVector3 *) &((btCollisionObject const *)arg1)->getAnisotropicFriction(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btVector3 *arg2 = 0 ; + int arg3 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->setAnisotropicFriction((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btCollisionObject_setAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btVector3 *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setAnisotropicFriction((btVector3 const &)*arg2); + +} + + +bool _wrap_btCollisionObject_hasAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (bool)((btCollisionObject const *)arg1)->hasAnisotropicFriction(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionObject_hasAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (bool)((btCollisionObject const *)arg1)->hasAnisotropicFriction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setContactProcessingThreshold_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, float _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setContactProcessingThreshold(arg2); + +} + + +float _wrap_btCollisionObject_getContactProcessingThreshold_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getContactProcessingThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionObject_isStaticObject_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (bool)((btCollisionObject const *)arg1)->isStaticObject(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionObject_isKinematicObject_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (bool)((btCollisionObject const *)arg1)->isKinematicObject(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionObject_isStaticOrKinematicObject_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (bool)((btCollisionObject const *)arg1)->isStaticOrKinematicObject(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionObject_hasContactResponse_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (bool)((btCollisionObject const *)arg1)->hasContactResponse(); + _swig_go_result = result; + return _swig_go_result; +} + + +btCollisionObject *_wrap_new_btCollisionObject_mbt_e879218550ba2e2b() { + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + + result = (btCollisionObject *)new btCollisionObject(); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCollisionObject_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btCollisionObject_setCollisionShape_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionShape *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionShape *arg2 = (btCollisionShape *) 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionShape **)&_swig_go_1; + + (arg1)->setCollisionShape(arg2); + +} + + +btCollisionShape *_wrap_btCollisionObject_getCollisionShape__SWIG_0_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionShape *result = 0 ; + btCollisionShape *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btCollisionShape *)((btCollisionObject const *)arg1)->getCollisionShape(); + *(btCollisionShape **)&_swig_go_result = (btCollisionShape *)result; + return _swig_go_result; +} + + +btCollisionShape *_wrap_btCollisionObject_getCollisionShape__SWIG_1_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionShape *result = 0 ; + btCollisionShape *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btCollisionShape *)(arg1)->getCollisionShape(); + *(btCollisionShape **)&_swig_go_result = (btCollisionShape *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setIgnoreCollisionCheck_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1, bool _swig_go_2) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + bool arg3 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = (bool)_swig_go_2; + + (arg1)->setIgnoreCollisionCheck((btCollisionObject const *)arg2,arg3); + +} + + +intgo _wrap_btCollisionObject_getNumObjectsWithoutCollision_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getNumObjectsWithoutCollision(); + _swig_go_result = result; + return _swig_go_result; +} + + +btCollisionObject *_wrap_btCollisionObject_getObjectWithoutCollision_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btCollisionObject *)(arg1)->getObjectWithoutCollision(arg2); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +bool _wrap_btCollisionObject_checkCollideWithOverride_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (bool)((btCollisionObject const *)arg1)->checkCollideWithOverride((btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void *_wrap_btCollisionObject_internalGetExtensionPointer_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (void *)((btCollisionObject const *)arg1)->internalGetExtensionPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_internalSetExtensionPointer_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, void *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + (arg1)->internalSetExtensionPointer(arg2); + +} + + +intgo _wrap_btCollisionObject_getActivationState_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getActivationState(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setActivationState_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + ((btCollisionObject const *)arg1)->setActivationState(arg2); + +} + + +void _wrap_btCollisionObject_setDeactivationTime_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, float _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setDeactivationTime(arg2); + +} + + +float _wrap_btCollisionObject_getDeactivationTime_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getDeactivationTime(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_forceActivationState_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + ((btCollisionObject const *)arg1)->forceActivationState(arg2); + +} + + +void _wrap_btCollisionObject_activate__SWIG_0_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, bool _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + bool arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + ((btCollisionObject const *)arg1)->activate(arg2); + +} + + +void _wrap_btCollisionObject_activate__SWIG_1_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + ((btCollisionObject const *)arg1)->activate(); + +} + + +bool _wrap_btCollisionObject_isActive_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (bool)((btCollisionObject const *)arg1)->isActive(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setRestitution_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, float _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setRestitution(arg2); + +} + + +float _wrap_btCollisionObject_getRestitution_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getRestitution(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, float _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setFriction(arg2); + +} + + +float _wrap_btCollisionObject_getFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getFriction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setRollingFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, float _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setRollingFriction(arg2); + +} + + +float _wrap_btCollisionObject_getRollingFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getRollingFriction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setSpinningFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, float _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setSpinningFriction(arg2); + +} + + +float _wrap_btCollisionObject_getSpinningFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getSpinningFriction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setContactStiffnessAndDamping_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setContactStiffnessAndDamping(arg2,arg3); + +} + + +float _wrap_btCollisionObject_getContactStiffness_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getContactStiffness(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCollisionObject_getContactDamping_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getContactDamping(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCollisionObject_getInternalType_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getInternalType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btCollisionObject_getWorldTransform__SWIG_0_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btTransform *) &(arg1)->getWorldTransform(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btCollisionObject_getWorldTransform__SWIG_1_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btTransform *) &((btCollisionObject const *)arg1)->getWorldTransform(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setWorldTransform_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btTransform *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + (arg1)->setWorldTransform((btTransform const &)*arg2); + +} + + +btBroadphaseProxy *_wrap_btCollisionObject_getBroadphaseHandle__SWIG_0_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btBroadphaseProxy *)(arg1)->getBroadphaseHandle(); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +btBroadphaseProxy *_wrap_btCollisionObject_getBroadphaseHandle__SWIG_1_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btBroadphaseProxy *)((btCollisionObject const *)arg1)->getBroadphaseHandle(); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setBroadphaseHandle_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + (arg1)->setBroadphaseHandle(arg2); + +} + + +btTransform *_wrap_btCollisionObject_getInterpolationWorldTransform__SWIG_0_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btTransform *) &((btCollisionObject const *)arg1)->getInterpolationWorldTransform(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btCollisionObject_getInterpolationWorldTransform__SWIG_1_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btTransform *) &(arg1)->getInterpolationWorldTransform(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setInterpolationWorldTransform_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btTransform *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + (arg1)->setInterpolationWorldTransform((btTransform const &)*arg2); + +} + + +void _wrap_btCollisionObject_setInterpolationLinearVelocity_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btVector3 *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setInterpolationLinearVelocity((btVector3 const &)*arg2); + +} + + +void _wrap_btCollisionObject_setInterpolationAngularVelocity_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btVector3 *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setInterpolationAngularVelocity((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btCollisionObject_getInterpolationLinearVelocity_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btVector3 *) &((btCollisionObject const *)arg1)->getInterpolationLinearVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btCollisionObject_getInterpolationAngularVelocity_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btVector3 *) &((btCollisionObject const *)arg1)->getInterpolationAngularVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCollisionObject_getIslandTag_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getIslandTag(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setIslandTag_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setIslandTag(arg2); + +} + + +intgo _wrap_btCollisionObject_getCompanionId_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getCompanionId(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setCompanionId_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setCompanionId(arg2); + +} + + +intgo _wrap_btCollisionObject_getWorldArrayIndex_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getWorldArrayIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setWorldArrayIndex_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setWorldArrayIndex(arg2); + +} + + +float _wrap_btCollisionObject_getHitFraction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getHitFraction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setHitFraction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, float _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setHitFraction(arg2); + +} + + +intgo _wrap_btCollisionObject_getCollisionFlags_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getCollisionFlags(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setCollisionFlags_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setCollisionFlags(arg2); + +} + + +float _wrap_btCollisionObject_getCcdSweptSphereRadius_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getCcdSweptSphereRadius(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setCcdSweptSphereRadius_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, float _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setCcdSweptSphereRadius(arg2); + +} + + +float _wrap_btCollisionObject_getCcdMotionThreshold_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getCcdMotionThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btCollisionObject_getCcdSquareMotionThreshold_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btScalar)((btCollisionObject const *)arg1)->getCcdSquareMotionThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setCcdMotionThreshold_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, float _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btScalar arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setCcdMotionThreshold(arg2); + +} + + +void *_wrap_btCollisionObject_getUserPointer_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (void *)((btCollisionObject const *)arg1)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +intgo _wrap_btCollisionObject_getUserIndex_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCollisionObject_getUserIndex2_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCollisionObject_getUserIndex3_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getUserIndex3(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setUserPointer_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, void *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + (arg1)->setUserPointer(arg2); + +} + + +void _wrap_btCollisionObject_setUserIndex_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setUserIndex(arg2); + +} + + +void _wrap_btCollisionObject_setUserIndex2_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setUserIndex2(arg2); + +} + + +void _wrap_btCollisionObject_setUserIndex3_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, intgo _swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setUserIndex3(arg2); + +} + + +intgo _wrap_btCollisionObject_getUpdateRevisionInternal_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->getUpdateRevisionInternal(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObject_setCustomDebugColor_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btVector3 *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setCustomDebugColor((btVector3 const &)*arg2); + +} + + +void _wrap_btCollisionObject_removeCustomDebugColor_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + (arg1)->removeCustomDebugColor(); + +} + + +bool _wrap_btCollisionObject_getCustomDebugColor_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btVector3 *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btVector3 *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (bool)((btCollisionObject const *)arg1)->getCustomDebugColor(*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionObject_checkCollideWith_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (bool)((btCollisionObject const *)arg1)->checkCollideWith((btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btCollisionObject_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (int)((btCollisionObject const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btCollisionObject_serialize_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btCollisionObject const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btCollisionObject_serializeSingleObject_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btSerializer *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + ((btCollisionObject const *)arg1)->serializeSingleObject(arg2); + +} + + +void _wrap_btCollisionObjectDoubleData_m_broadphaseHandle_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, void *_swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + if (arg1) (arg1)->m_broadphaseHandle = arg2; + +} + + +void *_wrap_btCollisionObjectDoubleData_m_broadphaseHandle_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (void *) ((arg1)->m_broadphaseHandle); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_collisionShape_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, void *_swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionShape = arg2; + +} + + +void *_wrap_btCollisionObjectDoubleData_m_collisionShape_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (void *) ((arg1)->m_collisionShape); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_rootCollisionShape_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, btCollisionShapeData *_swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btCollisionShapeData *arg2 = (btCollisionShapeData *) 0 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = *(btCollisionShapeData **)&_swig_go_1; + + if (arg1) (arg1)->m_rootCollisionShape = arg2; + +} + + +btCollisionShapeData *_wrap_btCollisionObjectDoubleData_m_rootCollisionShape_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btCollisionShapeData *result = 0 ; + btCollisionShapeData *_swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (btCollisionShapeData *) ((arg1)->m_rootCollisionShape); + *(btCollisionShapeData **)&_swig_go_result = (btCollisionShapeData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_name_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, _gostring_ _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + delete [] arg1->m_name; + if (arg2) { + arg1->m_name = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->m_name, (const char *)arg2); + } else { + arg1->m_name = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btCollisionObjectDoubleData_m_name_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (char *) ((arg1)->m_name); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_worldTransform_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, btTransformDoubleData *_swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btTransformDoubleData *arg2 = (btTransformDoubleData *) 0 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = *(btTransformDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_worldTransform = *arg2; + +} + + +btTransformDoubleData *_wrap_btCollisionObjectDoubleData_m_worldTransform_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btTransformDoubleData *result = 0 ; + btTransformDoubleData *_swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (btTransformDoubleData *)& ((arg1)->m_worldTransform); + *(btTransformDoubleData **)&_swig_go_result = (btTransformDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_interpolationWorldTransform_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, btTransformDoubleData *_swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btTransformDoubleData *arg2 = (btTransformDoubleData *) 0 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = *(btTransformDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_interpolationWorldTransform = *arg2; + +} + + +btTransformDoubleData *_wrap_btCollisionObjectDoubleData_m_interpolationWorldTransform_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btTransformDoubleData *result = 0 ; + btTransformDoubleData *_swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (btTransformDoubleData *)& ((arg1)->m_interpolationWorldTransform); + *(btTransformDoubleData **)&_swig_go_result = (btTransformDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_interpolationLinearVelocity_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_interpolationLinearVelocity = *arg2; + +} + + +btVector3DoubleData *_wrap_btCollisionObjectDoubleData_m_interpolationLinearVelocity_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_interpolationLinearVelocity); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_interpolationAngularVelocity_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_interpolationAngularVelocity = *arg2; + +} + + +btVector3DoubleData *_wrap_btCollisionObjectDoubleData_m_interpolationAngularVelocity_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_interpolationAngularVelocity); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_anisotropicFriction_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_anisotropicFriction = *arg2; + +} + + +btVector3DoubleData *_wrap_btCollisionObjectDoubleData_m_anisotropicFriction_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_anisotropicFriction); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, double _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_contactProcessingThreshold = arg2; + +} + + +double _wrap_btCollisionObjectDoubleData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_contactProcessingThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_deactivationTime_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, double _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_deactivationTime = arg2; + +} + + +double _wrap_btCollisionObjectDoubleData_m_deactivationTime_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_deactivationTime); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_friction_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, double _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_friction = arg2; + +} + + +double _wrap_btCollisionObjectDoubleData_m_friction_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_friction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_rollingFriction_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, double _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_rollingFriction = arg2; + +} + + +double _wrap_btCollisionObjectDoubleData_m_rollingFriction_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_rollingFriction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_contactDamping_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, double _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_contactDamping = arg2; + +} + + +double _wrap_btCollisionObjectDoubleData_m_contactDamping_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_contactDamping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_contactStiffness_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, double _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_contactStiffness = arg2; + +} + + +double _wrap_btCollisionObjectDoubleData_m_contactStiffness_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_contactStiffness); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_restitution_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, double _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_restitution = arg2; + +} + + +double _wrap_btCollisionObjectDoubleData_m_restitution_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_restitution); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_hitFraction_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, double _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_hitFraction = arg2; + +} + + +double _wrap_btCollisionObjectDoubleData_m_hitFraction_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_hitFraction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_ccdSweptSphereRadius_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, double _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_ccdSweptSphereRadius = arg2; + +} + + +double _wrap_btCollisionObjectDoubleData_m_ccdSweptSphereRadius_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_ccdSweptSphereRadius); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_ccdMotionThreshold_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, double _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_ccdMotionThreshold = arg2; + +} + + +double _wrap_btCollisionObjectDoubleData_m_ccdMotionThreshold_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_ccdMotionThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_hasAnisotropicFriction_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_hasAnisotropicFriction = arg2; + +} + + +intgo _wrap_btCollisionObjectDoubleData_m_hasAnisotropicFriction_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_hasAnisotropicFriction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_collisionFlags_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_collisionFlags = arg2; + +} + + +intgo _wrap_btCollisionObjectDoubleData_m_collisionFlags_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_collisionFlags); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_islandTag1_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_islandTag1 = arg2; + +} + + +intgo _wrap_btCollisionObjectDoubleData_m_islandTag1_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_islandTag1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_companionId_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_companionId = arg2; + +} + + +intgo _wrap_btCollisionObjectDoubleData_m_companionId_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_companionId); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_activationState1_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_activationState1 = arg2; + +} + + +intgo _wrap_btCollisionObjectDoubleData_m_activationState1_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_activationState1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_internalType_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_internalType = arg2; + +} + + +intgo _wrap_btCollisionObjectDoubleData_m_internalType_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_internalType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_checkCollideWith_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_checkCollideWith = arg2; + +} + + +intgo _wrap_btCollisionObjectDoubleData_m_checkCollideWith_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_checkCollideWith); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_collisionFilterGroup_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_collisionFilterGroup = arg2; + +} + + +intgo _wrap_btCollisionObjectDoubleData_m_collisionFilterGroup_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_collisionFilterGroup); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_collisionFilterMask_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_collisionFilterMask = arg2; + +} + + +intgo _wrap_btCollisionObjectDoubleData_m_collisionFilterMask_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_collisionFilterMask); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectDoubleData_m_uniqueId_set_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_uniqueId = arg2; + +} + + +intgo _wrap_btCollisionObjectDoubleData_m_uniqueId_get_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_uniqueId); + _swig_go_result = result; + return _swig_go_result; +} + + +btCollisionObjectDoubleData *_wrap_new_btCollisionObjectDoubleData_mbt_e879218550ba2e2b() { + btCollisionObjectDoubleData *result = 0 ; + btCollisionObjectDoubleData *_swig_go_result; + + + result = (btCollisionObjectDoubleData *)new btCollisionObjectDoubleData(); + *(btCollisionObjectDoubleData **)&_swig_go_result = (btCollisionObjectDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCollisionObjectDoubleData_mbt_e879218550ba2e2b(btCollisionObjectDoubleData *_swig_go_0) { + btCollisionObjectDoubleData *arg1 = (btCollisionObjectDoubleData *) 0 ; + + arg1 = *(btCollisionObjectDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btCollisionObjectFloatData_m_broadphaseHandle_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, void *_swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + if (arg1) (arg1)->m_broadphaseHandle = arg2; + +} + + +void *_wrap_btCollisionObjectFloatData_m_broadphaseHandle_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (void *) ((arg1)->m_broadphaseHandle); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_collisionShape_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, void *_swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionShape = arg2; + +} + + +void *_wrap_btCollisionObjectFloatData_m_collisionShape_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (void *) ((arg1)->m_collisionShape); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_rootCollisionShape_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, btCollisionShapeData *_swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btCollisionShapeData *arg2 = (btCollisionShapeData *) 0 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = *(btCollisionShapeData **)&_swig_go_1; + + if (arg1) (arg1)->m_rootCollisionShape = arg2; + +} + + +btCollisionShapeData *_wrap_btCollisionObjectFloatData_m_rootCollisionShape_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btCollisionShapeData *result = 0 ; + btCollisionShapeData *_swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (btCollisionShapeData *) ((arg1)->m_rootCollisionShape); + *(btCollisionShapeData **)&_swig_go_result = (btCollisionShapeData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_name_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, _gostring_ _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + delete [] arg1->m_name; + if (arg2) { + arg1->m_name = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->m_name, (const char *)arg2); + } else { + arg1->m_name = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btCollisionObjectFloatData_m_name_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (char *) ((arg1)->m_name); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_worldTransform_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, btTransformFloatData *_swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btTransformFloatData *arg2 = (btTransformFloatData *) 0 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = *(btTransformFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_worldTransform = *arg2; + +} + + +btTransformFloatData *_wrap_btCollisionObjectFloatData_m_worldTransform_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btTransformFloatData *result = 0 ; + btTransformFloatData *_swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (btTransformFloatData *)& ((arg1)->m_worldTransform); + *(btTransformFloatData **)&_swig_go_result = (btTransformFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_interpolationWorldTransform_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, btTransformFloatData *_swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btTransformFloatData *arg2 = (btTransformFloatData *) 0 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = *(btTransformFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_interpolationWorldTransform = *arg2; + +} + + +btTransformFloatData *_wrap_btCollisionObjectFloatData_m_interpolationWorldTransform_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btTransformFloatData *result = 0 ; + btTransformFloatData *_swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (btTransformFloatData *)& ((arg1)->m_interpolationWorldTransform); + *(btTransformFloatData **)&_swig_go_result = (btTransformFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_interpolationLinearVelocity_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_interpolationLinearVelocity = *arg2; + +} + + +btVector3FloatData *_wrap_btCollisionObjectFloatData_m_interpolationLinearVelocity_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_interpolationLinearVelocity); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_interpolationAngularVelocity_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_interpolationAngularVelocity = *arg2; + +} + + +btVector3FloatData *_wrap_btCollisionObjectFloatData_m_interpolationAngularVelocity_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_interpolationAngularVelocity); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_anisotropicFriction_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_anisotropicFriction = *arg2; + +} + + +btVector3FloatData *_wrap_btCollisionObjectFloatData_m_anisotropicFriction_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_anisotropicFriction); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, float _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_contactProcessingThreshold = arg2; + +} + + +float _wrap_btCollisionObjectFloatData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_contactProcessingThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_deactivationTime_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, float _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_deactivationTime = arg2; + +} + + +float _wrap_btCollisionObjectFloatData_m_deactivationTime_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_deactivationTime); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_friction_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, float _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_friction = arg2; + +} + + +float _wrap_btCollisionObjectFloatData_m_friction_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_friction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_rollingFriction_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, float _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_rollingFriction = arg2; + +} + + +float _wrap_btCollisionObjectFloatData_m_rollingFriction_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_rollingFriction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_contactDamping_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, float _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_contactDamping = arg2; + +} + + +float _wrap_btCollisionObjectFloatData_m_contactDamping_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_contactDamping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_contactStiffness_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, float _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_contactStiffness = arg2; + +} + + +float _wrap_btCollisionObjectFloatData_m_contactStiffness_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_contactStiffness); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_restitution_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, float _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_restitution = arg2; + +} + + +float _wrap_btCollisionObjectFloatData_m_restitution_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_restitution); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_hitFraction_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, float _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_hitFraction = arg2; + +} + + +float _wrap_btCollisionObjectFloatData_m_hitFraction_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_hitFraction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_ccdSweptSphereRadius_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, float _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_ccdSweptSphereRadius = arg2; + +} + + +float _wrap_btCollisionObjectFloatData_m_ccdSweptSphereRadius_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_ccdSweptSphereRadius); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_ccdMotionThreshold_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, float _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_ccdMotionThreshold = arg2; + +} + + +float _wrap_btCollisionObjectFloatData_m_ccdMotionThreshold_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_ccdMotionThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_hasAnisotropicFriction_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_hasAnisotropicFriction = arg2; + +} + + +intgo _wrap_btCollisionObjectFloatData_m_hasAnisotropicFriction_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_hasAnisotropicFriction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_collisionFlags_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_collisionFlags = arg2; + +} + + +intgo _wrap_btCollisionObjectFloatData_m_collisionFlags_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_collisionFlags); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_islandTag1_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_islandTag1 = arg2; + +} + + +intgo _wrap_btCollisionObjectFloatData_m_islandTag1_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_islandTag1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_companionId_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_companionId = arg2; + +} + + +intgo _wrap_btCollisionObjectFloatData_m_companionId_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_companionId); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_activationState1_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_activationState1 = arg2; + +} + + +intgo _wrap_btCollisionObjectFloatData_m_activationState1_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_activationState1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_internalType_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_internalType = arg2; + +} + + +intgo _wrap_btCollisionObjectFloatData_m_internalType_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_internalType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_checkCollideWith_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_checkCollideWith = arg2; + +} + + +intgo _wrap_btCollisionObjectFloatData_m_checkCollideWith_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_checkCollideWith); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_collisionFilterGroup_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_collisionFilterGroup = arg2; + +} + + +intgo _wrap_btCollisionObjectFloatData_m_collisionFilterGroup_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_collisionFilterGroup); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_collisionFilterMask_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_collisionFilterMask = arg2; + +} + + +intgo _wrap_btCollisionObjectFloatData_m_collisionFilterMask_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_collisionFilterMask); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionObjectFloatData_m_uniqueId_set_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0, intgo _swig_go_1) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int arg2 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_uniqueId = arg2; + +} + + +intgo _wrap_btCollisionObjectFloatData_m_uniqueId_get_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_uniqueId); + _swig_go_result = result; + return _swig_go_result; +} + + +btCollisionObjectFloatData *_wrap_new_btCollisionObjectFloatData_mbt_e879218550ba2e2b() { + btCollisionObjectFloatData *result = 0 ; + btCollisionObjectFloatData *_swig_go_result; + + + result = (btCollisionObjectFloatData *)new btCollisionObjectFloatData(); + *(btCollisionObjectFloatData **)&_swig_go_result = (btCollisionObjectFloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCollisionObjectFloatData_mbt_e879218550ba2e2b(btCollisionObjectFloatData *_swig_go_0) { + btCollisionObjectFloatData *arg1 = (btCollisionObjectFloatData *) 0 ; + + arg1 = *(btCollisionObjectFloatData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_gDeactivationTime_set_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + + arg1 = (btScalar)_swig_go_0; + + gDeactivationTime = arg1; + +} + + +float _wrap_gDeactivationTime_get_mbt_e879218550ba2e2b() { + btScalar result; + float _swig_go_result; + + + result = (btScalar)gDeactivationTime; + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_gDisableDeactivation_set_mbt_e879218550ba2e2b(bool _swig_go_0) { + bool arg1 ; + + arg1 = (bool)_swig_go_0; + + gDisableDeactivation = arg1; + +} + + +bool _wrap_gDisableDeactivation_get_mbt_e879218550ba2e2b() { + bool result; + bool _swig_go_result; + + + result = (bool)gDisableDeactivation; + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_BT_DISABLE_WORLD_GRAVITY_mbt_e879218550ba2e2b() { + btRigidBodyFlags result; + intgo _swig_go_result; + + + result = BT_DISABLE_WORLD_GRAVITY; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT_mbt_e879218550ba2e2b() { + btRigidBodyFlags result; + intgo _swig_go_result; + + + result = BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD_mbt_e879218550ba2e2b() { + btRigidBodyFlags result; + intgo _swig_go_result; + + + result = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY_mbt_e879218550ba2e2b() { + btRigidBodyFlags result; + intgo _swig_go_result; + + + result = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_ENABLE_GYROPSCOPIC_FORCE_mbt_e879218550ba2e2b() { + btRigidBodyFlags result; + intgo _swig_go_result; + + + result = BT_ENABLE_GYROPSCOPIC_FORCE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +btRigidBody *_wrap_new_btRigidBody__SWIG_0_mbt_e879218550ba2e2b(btRigidBody::btRigidBodyConstructionInfo *_swig_go_0) { + btRigidBody::btRigidBodyConstructionInfo *arg1 = 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btRigidBody::btRigidBodyConstructionInfo **)&_swig_go_0; + + result = (btRigidBody *)new btRigidBody((btRigidBody::btRigidBodyConstructionInfo const &)*arg1); + *(btRigidBody **)&_swig_go_result = (btRigidBody *)result; + return _swig_go_result; +} + + +btRigidBody *_wrap_new_btRigidBody__SWIG_1_mbt_e879218550ba2e2b(float _swig_go_0, btMotionState *_swig_go_1, btCollisionShape *_swig_go_2, btVector3 *_swig_go_3) { + btScalar arg1 ; + btMotionState *arg2 = (btMotionState *) 0 ; + btCollisionShape *arg3 = (btCollisionShape *) 0 ; + btVector3 *arg4 = 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = *(btMotionState **)&_swig_go_1; + arg3 = *(btCollisionShape **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = (btRigidBody *)new btRigidBody(arg1,arg2,arg3,(btVector3 const &)*arg4); + *(btRigidBody **)&_swig_go_result = (btRigidBody *)result; + return _swig_go_result; +} + + +btRigidBody *_wrap_new_btRigidBody__SWIG_2_mbt_e879218550ba2e2b(float _swig_go_0, btMotionState *_swig_go_1, btCollisionShape *_swig_go_2) { + btScalar arg1 ; + btMotionState *arg2 = (btMotionState *) 0 ; + btCollisionShape *arg3 = (btCollisionShape *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = *(btMotionState **)&_swig_go_1; + arg3 = *(btCollisionShape **)&_swig_go_2; + + result = (btRigidBody *)new btRigidBody(arg1,arg2,arg3); + *(btRigidBody **)&_swig_go_result = (btRigidBody *)result; + return _swig_go_result; +} + + +void _wrap_delete_btRigidBody_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btRigidBody_proceedToTransform_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btTransform *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + (arg1)->proceedToTransform((btTransform const &)*arg2); + +} + + +btRigidBody *_wrap_btRigidBody_upcast__SWIG_0_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btRigidBody *)btRigidBody::upcast((btCollisionObject const *)arg1); + *(btRigidBody **)&_swig_go_result = (btRigidBody *)result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btRigidBody_upcast__SWIG_1_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + + result = (btRigidBody *)btRigidBody::upcast(arg1); + *(btRigidBody **)&_swig_go_result = (btRigidBody *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_predictIntegratedTransform_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1, btTransform *_swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + btTransform *arg3 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + + (arg1)->predictIntegratedTransform(arg2,*arg3); + +} + + +void _wrap_btRigidBody_saveKinematicState_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->saveKinematicState(arg2); + +} + + +void _wrap_btRigidBody_applyGravity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + + (arg1)->applyGravity(); + +} + + +void _wrap_btRigidBody_clearGravity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + + (arg1)->clearGravity(); + +} + + +void _wrap_btRigidBody_setGravity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setGravity((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btRigidBody_getGravity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btVector3 *) &((btRigidBody const *)arg1)->getGravity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setDamping_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setDamping(arg2,arg3); + +} + + +float _wrap_btRigidBody_getLinearDamping_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btScalar)((btRigidBody const *)arg1)->getLinearDamping(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btRigidBody_getAngularDamping_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btScalar)((btRigidBody const *)arg1)->getAngularDamping(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btRigidBody_getLinearSleepingThreshold_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btScalar)((btRigidBody const *)arg1)->getLinearSleepingThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btRigidBody_getAngularSleepingThreshold_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btScalar)((btRigidBody const *)arg1)->getAngularSleepingThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_applyDamping_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->applyDamping(arg2); + +} + + +btCollisionShape *_wrap_btRigidBody_getCollisionShape__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btCollisionShape *result = 0 ; + btCollisionShape *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btCollisionShape *)((btRigidBody const *)arg1)->getCollisionShape(); + *(btCollisionShape **)&_swig_go_result = (btCollisionShape *)result; + return _swig_go_result; +} + + +btCollisionShape *_wrap_btRigidBody_getCollisionShape__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btCollisionShape *result = 0 ; + btCollisionShape *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btCollisionShape *)(arg1)->getCollisionShape(); + *(btCollisionShape **)&_swig_go_result = (btCollisionShape *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setMassProps_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->setMassProps(arg2,(btVector3 const &)*arg3); + +} + + +btVector3 *_wrap_btRigidBody_getLinearFactor_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btVector3 *) &((btRigidBody const *)arg1)->getLinearFactor(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setLinearFactor_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLinearFactor((btVector3 const &)*arg2); + +} + + +float _wrap_btRigidBody_getInvMass_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btScalar)((btRigidBody const *)arg1)->getInvMass(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btRigidBody_getMass_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btScalar)((btRigidBody const *)arg1)->getMass(); + _swig_go_result = result; + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_btRigidBody_getInvInertiaTensorWorld_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btMatrix3x3 *result = 0 ; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btMatrix3x3 *) &((btRigidBody const *)arg1)->getInvInertiaTensorWorld(); + *(btMatrix3x3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_integrateVelocities_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->integrateVelocities(arg2); + +} + + +void _wrap_btRigidBody_setCenterOfMassTransform_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btTransform *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + (arg1)->setCenterOfMassTransform((btTransform const &)*arg2); + +} + + +void _wrap_btRigidBody_applyCentralForce_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->applyCentralForce((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btRigidBody_getTotalForce_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btVector3 *) &((btRigidBody const *)arg1)->getTotalForce(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_getTotalTorque_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btVector3 *) &((btRigidBody const *)arg1)->getTotalTorque(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_getInvInertiaDiagLocal_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btVector3 *) &((btRigidBody const *)arg1)->getInvInertiaDiagLocal(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setInvInertiaDiagLocal_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setInvInertiaDiagLocal((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_setSleepingThresholds_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setSleepingThresholds(arg2,arg3); + +} + + +void _wrap_btRigidBody_applyTorque_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->applyTorque((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_applyForce_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->applyForce((btVector3 const &)*arg2,(btVector3 const &)*arg3); + +} + + +void _wrap_btRigidBody_applyCentralImpulse_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->applyCentralImpulse((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_applyTorqueImpulse_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->applyTorqueImpulse((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_applyImpulse_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->applyImpulse((btVector3 const &)*arg2,(btVector3 const &)*arg3); + +} + + +void _wrap_btRigidBody_applyPushImpulse_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->applyPushImpulse((btVector3 const &)*arg2,(btVector3 const &)*arg3); + +} + + +btVector3 *_wrap_btRigidBody_getPushVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = ((btRigidBody const *)arg1)->getPushVelocity(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_getTurnVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = ((btRigidBody const *)arg1)->getTurnVelocity(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btRigidBody_setPushVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setPushVelocity((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_setTurnVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setTurnVelocity((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_applyCentralPushImpulse_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->applyCentralPushImpulse((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_applyTorqueTurnImpulse_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->applyTorqueTurnImpulse((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_clearForces_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + + (arg1)->clearForces(); + +} + + +void _wrap_btRigidBody_updateInertiaTensor_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + + (arg1)->updateInertiaTensor(); + +} + + +btVector3 *_wrap_btRigidBody_getCenterOfMassPosition_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btVector3 *) &((btRigidBody const *)arg1)->getCenterOfMassPosition(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btQuaternion *_wrap_btRigidBody_getOrientation_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btQuaternion result; + btQuaternion *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = ((btRigidBody const *)arg1)->getOrientation(); + *(btQuaternion **)&_swig_go_result = new btQuaternion(result); + return _swig_go_result; +} + + +btTransform *_wrap_btRigidBody_getCenterOfMassTransform_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btTransform *) &((btRigidBody const *)arg1)->getCenterOfMassTransform(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_getLinearVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btVector3 *) &((btRigidBody const *)arg1)->getLinearVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_getAngularVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btVector3 *) &((btRigidBody const *)arg1)->getAngularVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setLinearVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLinearVelocity((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_setAngularVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setAngularVelocity((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btRigidBody_getVelocityInLocalPoint_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btRigidBody const *)arg1)->getVelocityInLocalPoint((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_getPushVelocityInLocalPoint_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btRigidBody const *)arg1)->getPushVelocityInLocalPoint((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btRigidBody_translate_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->translate((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_getAabb_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btRigidBody const *)arg1)->getAabb(*arg2,*arg3); + +} + + +float _wrap_btRigidBody_computeImpulseDenominator_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (btScalar)((btRigidBody const *)arg1)->computeImpulseDenominator((btVector3 const &)*arg2,(btVector3 const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btRigidBody_computeAngularImpulseDenominator_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btScalar)((btRigidBody const *)arg1)->computeAngularImpulseDenominator((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_updateDeactivation_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->updateDeactivation(arg2); + +} + + +bool _wrap_btRigidBody_wantsSleeping_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (bool)(arg1)->wantsSleeping(); + _swig_go_result = result; + return _swig_go_result; +} + + +btBroadphaseProxy *_wrap_btRigidBody_getConstBroadphaseProxy_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btBroadphaseProxy *)((btRigidBody const *)arg1)->getConstBroadphaseProxy(); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +btBroadphaseProxy *_wrap_btRigidBody_getBroadphaseProxy_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btBroadphaseProxy *)(arg1)->getBroadphaseProxy(); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setNewBroadphaseProxy_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + (arg1)->setNewBroadphaseProxy(arg2); + +} + + +btMotionState *_wrap_btRigidBody_getMotionState__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btMotionState *result = 0 ; + btMotionState *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btMotionState *)(arg1)->getMotionState(); + *(btMotionState **)&_swig_go_result = (btMotionState *)result; + return _swig_go_result; +} + + +btMotionState *_wrap_btRigidBody_getMotionState__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btMotionState *result = 0 ; + btMotionState *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btMotionState *)((btRigidBody const *)arg1)->getMotionState(); + *(btMotionState **)&_swig_go_result = (btMotionState *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setMotionState_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btMotionState *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btMotionState *arg2 = (btMotionState *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btMotionState **)&_swig_go_1; + + (arg1)->setMotionState(arg2); + +} + + +void _wrap_btRigidBody_m_contactSolverType_set_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_contactSolverType = arg2; + +} + + +intgo _wrap_btRigidBody_m_contactSolverType_get_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (int) ((arg1)->m_contactSolverType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_m_frictionSolverType_set_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_frictionSolverType = arg2; + +} + + +intgo _wrap_btRigidBody_m_frictionSolverType_get_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (int) ((arg1)->m_frictionSolverType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setAngularFactor__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setAngularFactor((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_setAngularFactor__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setAngularFactor(arg2); + +} + + +btVector3 *_wrap_btRigidBody_getAngularFactor_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (btVector3 *) &((btRigidBody const *)arg1)->getAngularFactor(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btRigidBody_isInWorld_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (bool)((btRigidBody const *)arg1)->isInWorld(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_addConstraintRef_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btTypedConstraint *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTypedConstraint *arg2 = (btTypedConstraint *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btTypedConstraint **)&_swig_go_1; + + (arg1)->addConstraintRef(arg2); + +} + + +void _wrap_btRigidBody_removeConstraintRef_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btTypedConstraint *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTypedConstraint *arg2 = (btTypedConstraint *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btTypedConstraint **)&_swig_go_1; + + (arg1)->removeConstraintRef(arg2); + +} + + +btTypedConstraint *_wrap_btRigidBody_getConstraintRef_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + btTypedConstraint *result = 0 ; + btTypedConstraint *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btTypedConstraint *)(arg1)->getConstraintRef(arg2); + *(btTypedConstraint **)&_swig_go_result = (btTypedConstraint *)result; + return _swig_go_result; +} + + +intgo _wrap_btRigidBody_getNumConstraintRefs_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (int)((btRigidBody const *)arg1)->getNumConstraintRefs(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setFlags_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setFlags(arg2); + +} + + +intgo _wrap_btRigidBody_getFlags_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (int)((btRigidBody const *)arg1)->getFlags(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_computeGyroscopicImpulseImplicit_World_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = ((btRigidBody const *)arg1)->computeGyroscopicImpulseImplicit_World(arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_computeGyroscopicImpulseImplicit_Body_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = ((btRigidBody const *)arg1)->computeGyroscopicImpulseImplicit_Body(arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_computeGyroscopicForceExplicit_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = ((btRigidBody const *)arg1)->computeGyroscopicForceExplicit(arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_getLocalInertia_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = ((btRigidBody const *)arg1)->getLocalInertia(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +intgo _wrap_btRigidBody_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + result = (int)((btRigidBody const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btRigidBody_serialize_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btRigidBody const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btRigidBody_serializeSingleObject_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btSerializer *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + ((btRigidBody const *)arg1)->serializeSingleObject(arg2); + +} + + +bool _wrap_btRigidBody_mergesSimulationIslands_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->mergesSimulationIslands(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_getAnisotropicFriction_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btVector3 *) &((btCollisionObject const *)swig_b0)->getAnisotropicFriction(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + int arg3 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setAnisotropicFriction((btVector3 const &)*arg2,arg3); + +} + + +void _wrap_btRigidBody_setAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setAnisotropicFriction((btVector3 const &)*arg2); + +} + + +bool _wrap_btRigidBody_hasAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->hasAnisotropicFriction(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btRigidBody_hasAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->hasAnisotropicFriction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setContactProcessingThreshold_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setContactProcessingThreshold(arg2); + +} + + +float _wrap_btRigidBody_getContactProcessingThreshold_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getContactProcessingThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btRigidBody_isStaticObject_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->isStaticObject(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btRigidBody_isKinematicObject_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->isKinematicObject(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btRigidBody_isStaticOrKinematicObject_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->isStaticOrKinematicObject(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btRigidBody_hasContactResponse_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->hasContactResponse(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setCollisionShape_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btCollisionShape *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btCollisionShape *arg2 = (btCollisionShape *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btCollisionShape **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setCollisionShape(arg2); + +} + + +void _wrap_btRigidBody_setIgnoreCollisionCheck_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btCollisionObject *_swig_go_1, bool _swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + bool arg3 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = (bool)_swig_go_2; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setIgnoreCollisionCheck((btCollisionObject const *)arg2,arg3); + +} + + +intgo _wrap_btRigidBody_getNumObjectsWithoutCollision_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getNumObjectsWithoutCollision(); + _swig_go_result = result; + return _swig_go_result; +} + + +btCollisionObject *_wrap_btRigidBody_getObjectWithoutCollision_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btCollisionObject *)(swig_b0)->getObjectWithoutCollision(arg2); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +bool _wrap_btRigidBody_checkCollideWithOverride_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btCollisionObject *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->checkCollideWithOverride((btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void *_wrap_btRigidBody_internalGetExtensionPointer_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (void *)((btCollisionObject const *)swig_b0)->internalGetExtensionPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_internalSetExtensionPointer_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, void *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->internalSetExtensionPointer(arg2); + +} + + +intgo _wrap_btRigidBody_getActivationState_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getActivationState(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setActivationState_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + ((btCollisionObject const *)swig_b0)->setActivationState(arg2); + +} + + +void _wrap_btRigidBody_setDeactivationTime_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setDeactivationTime(arg2); + +} + + +float _wrap_btRigidBody_getDeactivationTime_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getDeactivationTime(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_forceActivationState_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + ((btCollisionObject const *)swig_b0)->forceActivationState(arg2); + +} + + +void _wrap_btRigidBody_activate__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, bool _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + bool arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + ((btCollisionObject const *)swig_b0)->activate(arg2); + +} + + +void _wrap_btRigidBody_activate__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + ((btCollisionObject const *)swig_b0)->activate(); + +} + + +bool _wrap_btRigidBody_isActive_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->isActive(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setRestitution_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setRestitution(arg2); + +} + + +float _wrap_btRigidBody_getRestitution_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getRestitution(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setFriction_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setFriction(arg2); + +} + + +float _wrap_btRigidBody_getFriction_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getFriction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setRollingFriction_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setRollingFriction(arg2); + +} + + +float _wrap_btRigidBody_getRollingFriction_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getRollingFriction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setSpinningFriction_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setSpinningFriction(arg2); + +} + + +float _wrap_btRigidBody_getSpinningFriction_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getSpinningFriction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setContactStiffnessAndDamping_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setContactStiffnessAndDamping(arg2,arg3); + +} + + +float _wrap_btRigidBody_getContactStiffness_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getContactStiffness(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btRigidBody_getContactDamping_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getContactDamping(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btRigidBody_getInternalType_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getInternalType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btRigidBody_getWorldTransform__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btTransform *) &(swig_b0)->getWorldTransform(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btRigidBody_getWorldTransform__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btTransform *) &((btCollisionObject const *)swig_b0)->getWorldTransform(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setWorldTransform_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btTransform *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setWorldTransform((btTransform const &)*arg2); + +} + + +btBroadphaseProxy *_wrap_btRigidBody_getBroadphaseHandle__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btBroadphaseProxy *)(swig_b0)->getBroadphaseHandle(); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +btBroadphaseProxy *_wrap_btRigidBody_getBroadphaseHandle__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btBroadphaseProxy *)((btCollisionObject const *)swig_b0)->getBroadphaseHandle(); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setBroadphaseHandle_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setBroadphaseHandle(arg2); + +} + + +btTransform *_wrap_btRigidBody_getInterpolationWorldTransform__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btTransform *) &((btCollisionObject const *)swig_b0)->getInterpolationWorldTransform(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btRigidBody_getInterpolationWorldTransform__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btTransform *) &(swig_b0)->getInterpolationWorldTransform(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setInterpolationWorldTransform_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btTransform *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setInterpolationWorldTransform((btTransform const &)*arg2); + +} + + +void _wrap_btRigidBody_setInterpolationLinearVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setInterpolationLinearVelocity((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_setInterpolationAngularVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setInterpolationAngularVelocity((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btRigidBody_getInterpolationLinearVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btVector3 *) &((btCollisionObject const *)swig_b0)->getInterpolationLinearVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btRigidBody_getInterpolationAngularVelocity_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btVector3 *) &((btCollisionObject const *)swig_b0)->getInterpolationAngularVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btRigidBody_getIslandTag_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getIslandTag(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setIslandTag_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setIslandTag(arg2); + +} + + +intgo _wrap_btRigidBody_getCompanionId_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getCompanionId(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setCompanionId_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setCompanionId(arg2); + +} + + +intgo _wrap_btRigidBody_getWorldArrayIndex_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getWorldArrayIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setWorldArrayIndex_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setWorldArrayIndex(arg2); + +} + + +float _wrap_btRigidBody_getHitFraction_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getHitFraction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setHitFraction_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setHitFraction(arg2); + +} + + +intgo _wrap_btRigidBody_getCollisionFlags_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getCollisionFlags(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setCollisionFlags_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setCollisionFlags(arg2); + +} + + +float _wrap_btRigidBody_getCcdSweptSphereRadius_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getCcdSweptSphereRadius(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setCcdSweptSphereRadius_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setCcdSweptSphereRadius(arg2); + +} + + +float _wrap_btRigidBody_getCcdMotionThreshold_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getCcdMotionThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btRigidBody_getCcdSquareMotionThreshold_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (btScalar)((btCollisionObject const *)swig_b0)->getCcdSquareMotionThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setCcdMotionThreshold_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, float _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btScalar arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setCcdMotionThreshold(arg2); + +} + + +void *_wrap_btRigidBody_getUserPointer_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (void *)((btCollisionObject const *)swig_b0)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +intgo _wrap_btRigidBody_getUserIndex_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btRigidBody_getUserIndex2_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btRigidBody_getUserIndex3_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getUserIndex3(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setUserPointer_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, void *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setUserPointer(arg2); + +} + + +void _wrap_btRigidBody_setUserIndex_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setUserIndex(arg2); + +} + + +void _wrap_btRigidBody_setUserIndex2_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setUserIndex2(arg2); + +} + + +void _wrap_btRigidBody_setUserIndex3_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, intgo _swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int arg2 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setUserIndex3(arg2); + +} + + +intgo _wrap_btRigidBody_getUpdateRevisionInternal_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (int)((btCollisionObject const *)swig_b0)->getUpdateRevisionInternal(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBody_setCustomDebugColor_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->setCustomDebugColor((btVector3 const &)*arg2); + +} + + +void _wrap_btRigidBody_removeCustomDebugColor_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + + arg1 = *(btRigidBody **)&_swig_go_0; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + (swig_b0)->removeCustomDebugColor(); + +} + + +bool _wrap_btRigidBody_getCustomDebugColor_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btVector3 *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btVector3 *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->getCustomDebugColor(*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btRigidBody_checkCollideWith_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btCollisionObject *_swig_go_1) { + btRigidBody *arg1 = (btRigidBody *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + btCollisionObject *swig_b0 = (btCollisionObject *)arg1; + result = (bool)((btCollisionObject const *)swig_b0)->checkCollideWith((btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_collisionObjectData_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btCollisionObjectFloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btCollisionObjectFloatData *arg2 = (btCollisionObjectFloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btCollisionObjectFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionObjectData = *arg2; + +} + + +btCollisionObjectFloatData *_wrap_btRigidBodyFloatData_m_collisionObjectData_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btCollisionObjectFloatData *result = 0 ; + btCollisionObjectFloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btCollisionObjectFloatData *)& ((arg1)->m_collisionObjectData); + *(btCollisionObjectFloatData **)&_swig_go_result = (btCollisionObjectFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_invInertiaTensorWorld_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btMatrix3x3FloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btMatrix3x3FloatData *arg2 = (btMatrix3x3FloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btMatrix3x3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_invInertiaTensorWorld = *arg2; + +} + + +btMatrix3x3FloatData *_wrap_btRigidBodyFloatData_m_invInertiaTensorWorld_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btMatrix3x3FloatData *result = 0 ; + btMatrix3x3FloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btMatrix3x3FloatData *)& ((arg1)->m_invInertiaTensorWorld); + *(btMatrix3x3FloatData **)&_swig_go_result = (btMatrix3x3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_linearVelocity_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_linearVelocity = *arg2; + +} + + +btVector3FloatData *_wrap_btRigidBodyFloatData_m_linearVelocity_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_linearVelocity); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_angularVelocity_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_angularVelocity = *arg2; + +} + + +btVector3FloatData *_wrap_btRigidBodyFloatData_m_angularVelocity_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_angularVelocity); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_angularFactor_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_angularFactor = *arg2; + +} + + +btVector3FloatData *_wrap_btRigidBodyFloatData_m_angularFactor_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_angularFactor); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_linearFactor_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_linearFactor = *arg2; + +} + + +btVector3FloatData *_wrap_btRigidBodyFloatData_m_linearFactor_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_linearFactor); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_gravity_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_gravity = *arg2; + +} + + +btVector3FloatData *_wrap_btRigidBodyFloatData_m_gravity_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_gravity); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_gravity_acceleration_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_gravity_acceleration = *arg2; + +} + + +btVector3FloatData *_wrap_btRigidBodyFloatData_m_gravity_acceleration_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_gravity_acceleration); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_invInertiaLocal_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_invInertiaLocal = *arg2; + +} + + +btVector3FloatData *_wrap_btRigidBodyFloatData_m_invInertiaLocal_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_invInertiaLocal); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_totalForce_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_totalForce = *arg2; + +} + + +btVector3FloatData *_wrap_btRigidBodyFloatData_m_totalForce_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_totalForce); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_totalTorque_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_totalTorque = *arg2; + +} + + +btVector3FloatData *_wrap_btRigidBodyFloatData_m_totalTorque_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_totalTorque); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_inverseMass_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, float _swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float arg2 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_inverseMass = arg2; + +} + + +float _wrap_btRigidBodyFloatData_m_inverseMass_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_inverseMass); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_linearDamping_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, float _swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float arg2 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_linearDamping = arg2; + +} + + +float _wrap_btRigidBodyFloatData_m_linearDamping_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_linearDamping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_angularDamping_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, float _swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float arg2 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_angularDamping = arg2; + +} + + +float _wrap_btRigidBodyFloatData_m_angularDamping_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_angularDamping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_additionalDampingFactor_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, float _swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float arg2 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_additionalDampingFactor = arg2; + +} + + +float _wrap_btRigidBodyFloatData_m_additionalDampingFactor_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_additionalDampingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, float _swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float arg2 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_additionalLinearDampingThresholdSqr = arg2; + +} + + +float _wrap_btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_additionalLinearDampingThresholdSqr); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, float _swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float arg2 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_additionalAngularDampingThresholdSqr = arg2; + +} + + +float _wrap_btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_additionalAngularDampingThresholdSqr); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_additionalAngularDampingFactor_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, float _swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float arg2 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_additionalAngularDampingFactor = arg2; + +} + + +float _wrap_btRigidBodyFloatData_m_additionalAngularDampingFactor_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_additionalAngularDampingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_linearSleepingThreshold_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, float _swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float arg2 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_linearSleepingThreshold = arg2; + +} + + +float _wrap_btRigidBodyFloatData_m_linearSleepingThreshold_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_linearSleepingThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_angularSleepingThreshold_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, float _swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float arg2 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_angularSleepingThreshold = arg2; + +} + + +float _wrap_btRigidBodyFloatData_m_angularSleepingThreshold_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_angularSleepingThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyFloatData_m_additionalDamping_set_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0, intgo _swig_go_1) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + int arg2 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_additionalDamping = arg2; + +} + + +intgo _wrap_btRigidBodyFloatData_m_additionalDamping_get_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_additionalDamping); + _swig_go_result = result; + return _swig_go_result; +} + + +btRigidBodyFloatData *_wrap_new_btRigidBodyFloatData_mbt_e879218550ba2e2b() { + btRigidBodyFloatData *result = 0 ; + btRigidBodyFloatData *_swig_go_result; + + + result = (btRigidBodyFloatData *)new btRigidBodyFloatData(); + *(btRigidBodyFloatData **)&_swig_go_result = (btRigidBodyFloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btRigidBodyFloatData_mbt_e879218550ba2e2b(btRigidBodyFloatData *_swig_go_0) { + btRigidBodyFloatData *arg1 = (btRigidBodyFloatData *) 0 ; + + arg1 = *(btRigidBodyFloatData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btRigidBodyDoubleData_m_collisionObjectData_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btCollisionObjectDoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btCollisionObjectDoubleData *arg2 = (btCollisionObjectDoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btCollisionObjectDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionObjectData = *arg2; + +} + + +btCollisionObjectDoubleData *_wrap_btRigidBodyDoubleData_m_collisionObjectData_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btCollisionObjectDoubleData *result = 0 ; + btCollisionObjectDoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btCollisionObjectDoubleData *)& ((arg1)->m_collisionObjectData); + *(btCollisionObjectDoubleData **)&_swig_go_result = (btCollisionObjectDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_invInertiaTensorWorld_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btMatrix3x3DoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btMatrix3x3DoubleData *arg2 = (btMatrix3x3DoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btMatrix3x3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_invInertiaTensorWorld = *arg2; + +} + + +btMatrix3x3DoubleData *_wrap_btRigidBodyDoubleData_m_invInertiaTensorWorld_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btMatrix3x3DoubleData *result = 0 ; + btMatrix3x3DoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btMatrix3x3DoubleData *)& ((arg1)->m_invInertiaTensorWorld); + *(btMatrix3x3DoubleData **)&_swig_go_result = (btMatrix3x3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_linearVelocity_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_linearVelocity = *arg2; + +} + + +btVector3DoubleData *_wrap_btRigidBodyDoubleData_m_linearVelocity_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_linearVelocity); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_angularVelocity_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_angularVelocity = *arg2; + +} + + +btVector3DoubleData *_wrap_btRigidBodyDoubleData_m_angularVelocity_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_angularVelocity); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_angularFactor_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_angularFactor = *arg2; + +} + + +btVector3DoubleData *_wrap_btRigidBodyDoubleData_m_angularFactor_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_angularFactor); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_linearFactor_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_linearFactor = *arg2; + +} + + +btVector3DoubleData *_wrap_btRigidBodyDoubleData_m_linearFactor_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_linearFactor); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_gravity_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_gravity = *arg2; + +} + + +btVector3DoubleData *_wrap_btRigidBodyDoubleData_m_gravity_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_gravity); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_gravity_acceleration_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_gravity_acceleration = *arg2; + +} + + +btVector3DoubleData *_wrap_btRigidBodyDoubleData_m_gravity_acceleration_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_gravity_acceleration); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_invInertiaLocal_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_invInertiaLocal = *arg2; + +} + + +btVector3DoubleData *_wrap_btRigidBodyDoubleData_m_invInertiaLocal_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_invInertiaLocal); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_totalForce_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_totalForce = *arg2; + +} + + +btVector3DoubleData *_wrap_btRigidBodyDoubleData_m_totalForce_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_totalForce); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_totalTorque_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_totalTorque = *arg2; + +} + + +btVector3DoubleData *_wrap_btRigidBodyDoubleData_m_totalTorque_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_totalTorque); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_inverseMass_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, double _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_inverseMass = arg2; + +} + + +double _wrap_btRigidBodyDoubleData_m_inverseMass_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_inverseMass); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_linearDamping_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, double _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_linearDamping = arg2; + +} + + +double _wrap_btRigidBodyDoubleData_m_linearDamping_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_linearDamping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_angularDamping_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, double _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_angularDamping = arg2; + +} + + +double _wrap_btRigidBodyDoubleData_m_angularDamping_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_angularDamping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_additionalDampingFactor_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, double _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_additionalDampingFactor = arg2; + +} + + +double _wrap_btRigidBodyDoubleData_m_additionalDampingFactor_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_additionalDampingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, double _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_additionalLinearDampingThresholdSqr = arg2; + +} + + +double _wrap_btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_additionalLinearDampingThresholdSqr); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, double _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_additionalAngularDampingThresholdSqr = arg2; + +} + + +double _wrap_btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_additionalAngularDampingThresholdSqr); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_additionalAngularDampingFactor_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, double _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_additionalAngularDampingFactor = arg2; + +} + + +double _wrap_btRigidBodyDoubleData_m_additionalAngularDampingFactor_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_additionalAngularDampingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_linearSleepingThreshold_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, double _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_linearSleepingThreshold = arg2; + +} + + +double _wrap_btRigidBodyDoubleData_m_linearSleepingThreshold_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_linearSleepingThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_angularSleepingThreshold_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, double _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_angularSleepingThreshold = arg2; + +} + + +double _wrap_btRigidBodyDoubleData_m_angularSleepingThreshold_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_angularSleepingThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_additionalDamping_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, intgo _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_additionalDamping = arg2; + +} + + +intgo _wrap_btRigidBodyDoubleData_m_additionalDamping_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_additionalDamping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRigidBodyDoubleData_m_padding_set_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0, _gostring_ _swig_go_1) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_padding, (const char *)arg2, 4-1); + arg1->m_padding[4-1] = 0; + } else { + arg1->m_padding[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btRigidBodyDoubleData_m_padding_get_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_padding); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btRigidBodyDoubleData *_wrap_new_btRigidBodyDoubleData_mbt_e879218550ba2e2b() { + btRigidBodyDoubleData *result = 0 ; + btRigidBodyDoubleData *_swig_go_result; + + + result = (btRigidBodyDoubleData *)new btRigidBodyDoubleData(); + *(btRigidBodyDoubleData **)&_swig_go_result = (btRigidBodyDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btRigidBodyDoubleData_mbt_e879218550ba2e2b(btRigidBodyDoubleData *_swig_go_0) { + btRigidBodyDoubleData *arg1 = (btRigidBodyDoubleData *) 0 ; + + arg1 = *(btRigidBodyDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +btVector3 *_wrap_btAabbSupport_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = btAabbSupport((btVector3 const &)*arg1,(btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btTransformUtil_integrateTransform_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3, btTransform *_swig_go_4) { + btTransform *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + btTransform *arg5 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + + btTransformUtil::integrateTransform((btTransform const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,*arg5); + +} + + +void _wrap_btTransformUtil_calculateVelocityQuaternion_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btQuaternion *_swig_go_2, btQuaternion *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btQuaternion *arg3 = 0 ; + btQuaternion *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btQuaternion **)&_swig_go_2; + arg4 = *(btQuaternion **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btTransformUtil::calculateVelocityQuaternion((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btQuaternion const &)*arg3,(btQuaternion const &)*arg4,arg5,*arg6,*arg7); + +} + + +void _wrap_btTransformUtil_calculateDiffAxisAngleQuaternion_mbt_e879218550ba2e2b(btQuaternion *_swig_go_0, btQuaternion *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3) { + btQuaternion *arg1 = 0 ; + btQuaternion *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btQuaternion **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + btTransformUtil::calculateDiffAxisAngleQuaternion((btQuaternion const &)*arg1,(btQuaternion const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btTransformUtil_calculateVelocity_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1, float _swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4) { + btTransform *arg1 = 0 ; + btTransform *arg2 = 0 ; + btScalar arg3 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + btTransformUtil::calculateVelocity((btTransform const &)*arg1,(btTransform const &)*arg2,arg3,*arg4,*arg5); + +} + + +void _wrap_btTransformUtil_calculateDiffAxisAngle_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3) { + btTransform *arg1 = 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + + btTransformUtil::calculateDiffAxisAngle((btTransform const &)*arg1,(btTransform const &)*arg2,*arg3,*arg4); + +} + + +btTransformUtil *_wrap_new_btTransformUtil_mbt_e879218550ba2e2b() { + btTransformUtil *result = 0 ; + btTransformUtil *_swig_go_result; + + + result = (btTransformUtil *)new btTransformUtil(); + *(btTransformUtil **)&_swig_go_result = (btTransformUtil *)result; + return _swig_go_result; +} + + +void _wrap_delete_btTransformUtil_mbt_e879218550ba2e2b(btTransformUtil *_swig_go_0) { + btTransformUtil *arg1 = (btTransformUtil *) 0 ; + + arg1 = *(btTransformUtil **)&_swig_go_0; + + delete arg1; + +} + + +btConvexSeparatingDistanceUtil *_wrap_new_btConvexSeparatingDistanceUtil_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1) { + btScalar arg1 ; + btScalar arg2 ; + btConvexSeparatingDistanceUtil *result = 0 ; + btConvexSeparatingDistanceUtil *_swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (btConvexSeparatingDistanceUtil *)new btConvexSeparatingDistanceUtil(arg1,arg2); + *(btConvexSeparatingDistanceUtil **)&_swig_go_result = (btConvexSeparatingDistanceUtil *)result; + return _swig_go_result; +} + + +float _wrap_btConvexSeparatingDistanceUtil_getConservativeSeparatingDistance_mbt_e879218550ba2e2b(btConvexSeparatingDistanceUtil *_swig_go_0) { + btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexSeparatingDistanceUtil **)&_swig_go_0; + + result = (btScalar)(arg1)->getConservativeSeparatingDistance(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexSeparatingDistanceUtil_updateSeparatingDistance_mbt_e879218550ba2e2b(btConvexSeparatingDistanceUtil *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2) { + btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + + arg1 = *(btConvexSeparatingDistanceUtil **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + + (arg1)->updateSeparatingDistance((btTransform const &)*arg2,(btTransform const &)*arg3); + +} + + +void _wrap_btConvexSeparatingDistanceUtil_initSeparatingDistance_mbt_e879218550ba2e2b(btConvexSeparatingDistanceUtil *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2, btTransform *_swig_go_3, btTransform *_swig_go_4) { + btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + btTransform *arg4 = 0 ; + btTransform *arg5 = 0 ; + + arg1 = *(btConvexSeparatingDistanceUtil **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + + (arg1)->initSeparatingDistance((btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,(btTransform const &)*arg5); + +} + + +void _wrap_delete_btConvexSeparatingDistanceUtil_mbt_e879218550ba2e2b(btConvexSeparatingDistanceUtil *_swig_go_0) { + btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; + + arg1 = *(btConvexSeparatingDistanceUtil **)&_swig_go_0; + + delete arg1; + +} + + +btJacobianEntry *_wrap_new_btJacobianEntry__SWIG_0_mbt_e879218550ba2e2b() { + btJacobianEntry *result = 0 ; + btJacobianEntry *_swig_go_result; + + + result = (btJacobianEntry *)new btJacobianEntry(); + *(btJacobianEntry **)&_swig_go_result = (btJacobianEntry *)result; + return _swig_go_result; +} + + +btJacobianEntry *_wrap_new_btJacobianEntry__SWIG_1_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btMatrix3x3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, float _swig_go_6, btVector3 *_swig_go_7, float _swig_go_8) { + btMatrix3x3 *arg1 = 0 ; + btMatrix3x3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btScalar arg7 ; + btVector3 *arg8 = 0 ; + btScalar arg9 ; + btJacobianEntry *result = 0 ; + btJacobianEntry *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btMatrix3x3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = (btScalar)_swig_go_8; + + result = (btJacobianEntry *)new btJacobianEntry((btMatrix3x3 const &)*arg1,(btMatrix3x3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,arg7,(btVector3 const &)*arg8,arg9); + *(btJacobianEntry **)&_swig_go_result = (btJacobianEntry *)result; + return _swig_go_result; +} + + +btJacobianEntry *_wrap_new_btJacobianEntry__SWIG_2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btMatrix3x3 *_swig_go_1, btMatrix3x3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4) { + btVector3 *arg1 = 0 ; + btMatrix3x3 *arg2 = 0 ; + btMatrix3x3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btJacobianEntry *result = 0 ; + btJacobianEntry *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btMatrix3x3 **)&_swig_go_1; + arg3 = *(btMatrix3x3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + result = (btJacobianEntry *)new btJacobianEntry((btVector3 const &)*arg1,(btMatrix3x3 const &)*arg2,(btMatrix3x3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5); + *(btJacobianEntry **)&_swig_go_result = (btJacobianEntry *)result; + return _swig_go_result; +} + + +btJacobianEntry *_wrap_new_btJacobianEntry__SWIG_3_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btJacobianEntry *result = 0 ; + btJacobianEntry *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = (btJacobianEntry *)new btJacobianEntry((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + *(btJacobianEntry **)&_swig_go_result = (btJacobianEntry *)result; + return _swig_go_result; +} + + +btJacobianEntry *_wrap_new_btJacobianEntry__SWIG_4_mbt_e879218550ba2e2b(btMatrix3x3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, float _swig_go_5) { + btMatrix3x3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btScalar arg6 ; + btJacobianEntry *result = 0 ; + btJacobianEntry *_swig_go_result; + + arg1 = *(btMatrix3x3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + result = (btJacobianEntry *)new btJacobianEntry((btMatrix3x3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,arg6); + *(btJacobianEntry **)&_swig_go_result = (btJacobianEntry *)result; + return _swig_go_result; +} + + +float _wrap_btJacobianEntry_getDiagonal_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + + result = (btScalar)((btJacobianEntry const *)arg1)->getDiagonal(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btJacobianEntry_getNonDiagonal__SWIG_0_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0, btJacobianEntry *_swig_go_1, float _swig_go_2) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btJacobianEntry *arg2 = 0 ; + btScalar arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + arg2 = *(btJacobianEntry **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = (btScalar)((btJacobianEntry const *)arg1)->getNonDiagonal((btJacobianEntry const &)*arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btJacobianEntry_getNonDiagonal__SWIG_1_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0, btJacobianEntry *_swig_go_1, float _swig_go_2, float _swig_go_3) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btJacobianEntry *arg2 = 0 ; + btScalar arg3 ; + btScalar arg4 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + arg2 = *(btJacobianEntry **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + result = (btScalar)((btJacobianEntry const *)arg1)->getNonDiagonal((btJacobianEntry const &)*arg2,arg3,arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btJacobianEntry_getRelativeVelocity_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + result = (btScalar)(arg1)->getRelativeVelocity((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btJacobianEntry_m_linearJointAxis_set_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0, btVector3 *_swig_go_1) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_linearJointAxis = *arg2; + +} + + +btVector3 *_wrap_btJacobianEntry_m_linearJointAxis_get_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_linearJointAxis); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btJacobianEntry_m_aJ_set_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0, btVector3 *_swig_go_1) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_aJ = *arg2; + +} + + +btVector3 *_wrap_btJacobianEntry_m_aJ_get_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_aJ); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btJacobianEntry_m_bJ_set_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0, btVector3 *_swig_go_1) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_bJ = *arg2; + +} + + +btVector3 *_wrap_btJacobianEntry_m_bJ_get_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_bJ); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btJacobianEntry_m_0MinvJt_set_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0, btVector3 *_swig_go_1) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_0MinvJt = *arg2; + +} + + +btVector3 *_wrap_btJacobianEntry_m_0MinvJt_get_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_0MinvJt); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btJacobianEntry_m_1MinvJt_set_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0, btVector3 *_swig_go_1) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_1MinvJt = *arg2; + +} + + +btVector3 *_wrap_btJacobianEntry_m_1MinvJt_get_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_1MinvJt); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btJacobianEntry_m_Adiag_set_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0, float _swig_go_1) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btScalar arg2 ; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_Adiag = arg2; + +} + + +float _wrap_btJacobianEntry_m_Adiag_get_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_Adiag); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btJacobianEntry_mbt_e879218550ba2e2b(btJacobianEntry *_swig_go_0) { + btJacobianEntry *arg1 = (btJacobianEntry *) 0 ; + + arg1 = *(btJacobianEntry **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btSolverBody_m_worldTransform_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btTransform *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_worldTransform = *arg2; + +} + + +btTransform *_wrap_btSolverBody_m_worldTransform_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_worldTransform); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_deltaLinearVelocity_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_deltaLinearVelocity = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_deltaLinearVelocity_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_deltaLinearVelocity); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_deltaAngularVelocity_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_deltaAngularVelocity = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_deltaAngularVelocity_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_deltaAngularVelocity); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_angularFactor_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_angularFactor = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_angularFactor_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_angularFactor); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_linearFactor_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_linearFactor = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_linearFactor_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_linearFactor); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_invMass_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_invMass = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_invMass_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_invMass); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_pushVelocity_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_pushVelocity = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_pushVelocity_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_pushVelocity); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_turnVelocity_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_turnVelocity = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_turnVelocity_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_turnVelocity); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_linearVelocity_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_linearVelocity = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_linearVelocity_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_linearVelocity); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_angularVelocity_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_angularVelocity = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_angularVelocity_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_angularVelocity); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_externalForceImpulse_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_externalForceImpulse = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_externalForceImpulse_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_externalForceImpulse); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_externalTorqueImpulse_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_externalTorqueImpulse = *arg2; + +} + + +btVector3 *_wrap_btSolverBody_m_externalTorqueImpulse_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_externalTorqueImpulse); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_m_originalBody_set_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btRigidBody *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btRigidBody *arg2 = (btRigidBody *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + + if (arg1) (arg1)->m_originalBody = arg2; + +} + + +btRigidBody *_wrap_btSolverBody_m_originalBody_get_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btRigidBody *) ((arg1)->m_originalBody); + *(btRigidBody **)&_swig_go_result = (btRigidBody *)result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_setWorldTransform_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btTransform *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btTransform *arg2 = 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + (arg1)->setWorldTransform((btTransform const &)*arg2); + +} + + +btTransform *_wrap_btSolverBody_getWorldTransform_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btTransform *) &((btSolverBody const *)arg1)->getWorldTransform(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_getVelocityInLocalPointNoDelta_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btSolverBody const *)arg1)->getVelocityInLocalPointNoDelta((btVector3 const &)*arg2,*arg3); + +} + + +void _wrap_btSolverBody_getVelocityInLocalPointObsolete_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btSolverBody const *)arg1)->getVelocityInLocalPointObsolete((btVector3 const &)*arg2,*arg3); + +} + + +void _wrap_btSolverBody_getAngularVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + ((btSolverBody const *)arg1)->getAngularVelocity(*arg2); + +} + + +void _wrap_btSolverBody_applyImpulse_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->applyImpulse((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +void _wrap_btSolverBody_internalApplyPushImpulse_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->internalApplyPushImpulse((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +btVector3 *_wrap_btSolverBody_getDeltaLinearVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *) &((btSolverBody const *)arg1)->getDeltaLinearVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSolverBody_getDeltaAngularVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *) &((btSolverBody const *)arg1)->getDeltaAngularVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSolverBody_getPushVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *) &((btSolverBody const *)arg1)->getPushVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSolverBody_getTurnVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *) &((btSolverBody const *)arg1)->getTurnVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSolverBody_internalGetDeltaLinearVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *) &(arg1)->internalGetDeltaLinearVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSolverBody_internalGetDeltaAngularVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *) &(arg1)->internalGetDeltaAngularVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSolverBody_internalGetAngularFactor_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *) &((btSolverBody const *)arg1)->internalGetAngularFactor(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSolverBody_internalGetInvMass_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *) &((btSolverBody const *)arg1)->internalGetInvMass(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_internalSetInvMass_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->internalSetInvMass((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btSolverBody_internalGetPushVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *) &(arg1)->internalGetPushVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSolverBody_internalGetTurnVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverBody **)&_swig_go_0; + + result = (btVector3 *) &(arg1)->internalGetTurnVelocity(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverBody_internalGetVelocityInLocalPointObsolete_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btSolverBody const *)arg1)->internalGetVelocityInLocalPointObsolete((btVector3 const &)*arg2,*arg3); + +} + + +void _wrap_btSolverBody_internalGetAngularVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + ((btSolverBody const *)arg1)->internalGetAngularVelocity(*arg2); + +} + + +void _wrap_btSolverBody_internalApplyImpulse_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->internalApplyImpulse((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +void _wrap_btSolverBody_writebackVelocity_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + + (arg1)->writebackVelocity(); + +} + + +void _wrap_btSolverBody_writebackVelocityAndTransform_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->writebackVelocityAndTransform(arg2,arg3); + +} + + +btSolverBody *_wrap_new_btSolverBody_mbt_e879218550ba2e2b() { + btSolverBody *result = 0 ; + btSolverBody *_swig_go_result; + + + result = (btSolverBody *)new btSolverBody(); + *(btSolverBody **)&_swig_go_result = (btSolverBody *)result; + return _swig_go_result; +} + + +void _wrap_delete_btSolverBody_mbt_e879218550ba2e2b(btSolverBody *_swig_go_0) { + btSolverBody *arg1 = (btSolverBody *) 0 ; + + arg1 = *(btSolverBody **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btSolverConstraint_m_relpos1CrossNormal_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_relpos1CrossNormal = *arg2; + +} + + +btVector3 *_wrap_btSolverConstraint_m_relpos1CrossNormal_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_relpos1CrossNormal); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_contactNormal1_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_contactNormal1 = *arg2; + +} + + +btVector3 *_wrap_btSolverConstraint_m_contactNormal1_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_contactNormal1); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_relpos2CrossNormal_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_relpos2CrossNormal = *arg2; + +} + + +btVector3 *_wrap_btSolverConstraint_m_relpos2CrossNormal_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_relpos2CrossNormal); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_contactNormal2_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_contactNormal2 = *arg2; + +} + + +btVector3 *_wrap_btSolverConstraint_m_contactNormal2_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_contactNormal2); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_angularComponentA_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_angularComponentA = *arg2; + +} + + +btVector3 *_wrap_btSolverConstraint_m_angularComponentA_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_angularComponentA); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_angularComponentB_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_angularComponentB = *arg2; + +} + + +btVector3 *_wrap_btSolverConstraint_m_angularComponentB_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_angularComponentB); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_appliedPushImpulse_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, float _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_appliedPushImpulse = arg2; + +} + + +float _wrap_btSolverConstraint_m_appliedPushImpulse_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_appliedPushImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_appliedImpulse_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, float _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_appliedImpulse = arg2; + +} + + +float _wrap_btSolverConstraint_m_appliedImpulse_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_appliedImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_friction_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, float _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_friction = arg2; + +} + + +float _wrap_btSolverConstraint_m_friction_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_friction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_jacDiagABInv_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, float _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_jacDiagABInv = arg2; + +} + + +float _wrap_btSolverConstraint_m_jacDiagABInv_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_jacDiagABInv); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_rhs_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, float _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_rhs = arg2; + +} + + +float _wrap_btSolverConstraint_m_rhs_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_rhs); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_cfm_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, float _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_cfm = arg2; + +} + + +float _wrap_btSolverConstraint_m_cfm_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_cfm); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_lowerLimit_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, float _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_lowerLimit = arg2; + +} + + +float _wrap_btSolverConstraint_m_lowerLimit_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_lowerLimit); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_upperLimit_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, float _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_upperLimit = arg2; + +} + + +float _wrap_btSolverConstraint_m_upperLimit_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_upperLimit); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_rhsPenetration_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, float _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_rhsPenetration = arg2; + +} + + +float _wrap_btSolverConstraint_m_rhsPenetration_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_rhsPenetration); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, intgo _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + int arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_overrideNumSolverIterations = arg2; + +} + + +intgo _wrap_btSolverConstraint_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (int) ((arg1)->m_overrideNumSolverIterations); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_frictionIndex_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, intgo _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + int arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_frictionIndex = arg2; + +} + + +intgo _wrap_btSolverConstraint_m_frictionIndex_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (int) ((arg1)->m_frictionIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_solverBodyIdA_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, intgo _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + int arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_solverBodyIdA = arg2; + +} + + +intgo _wrap_btSolverConstraint_m_solverBodyIdA_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (int) ((arg1)->m_solverBodyIdA); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverConstraint_m_solverBodyIdB_set_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0, intgo _swig_go_1) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + int arg2 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_solverBodyIdB = arg2; + +} + + +intgo _wrap_btSolverConstraint_m_solverBodyIdB_get_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + result = (int) ((arg1)->m_solverBodyIdB); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_BT_SOLVER_CONTACT_1D_btSolverConstraint_mbt_e879218550ba2e2b() { + btSolverConstraint::btSolverConstraintType result; + intgo _swig_go_result; + + + result = btSolverConstraint::BT_SOLVER_CONTACT_1D; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_SOLVER_FRICTION_1D_btSolverConstraint_mbt_e879218550ba2e2b() { + btSolverConstraint::btSolverConstraintType result; + intgo _swig_go_result; + + + result = btSolverConstraint::BT_SOLVER_FRICTION_1D; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +btSolverConstraint *_wrap_new_btSolverConstraint_mbt_e879218550ba2e2b() { + btSolverConstraint *result = 0 ; + btSolverConstraint *_swig_go_result; + + + result = (btSolverConstraint *)new btSolverConstraint(); + *(btSolverConstraint **)&_swig_go_result = (btSolverConstraint *)result; + return _swig_go_result; +} + + +void _wrap_delete_btSolverConstraint_mbt_e879218550ba2e2b(btSolverConstraint *_swig_go_0) { + btSolverConstraint *arg1 = (btSolverConstraint *) 0 ; + + arg1 = *(btSolverConstraint **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_POINT2POINT_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = POINT2POINT_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_HINGE_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = HINGE_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CONETWIST_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = CONETWIST_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_D6_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = D6_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SLIDER_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = SLIDER_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CONTACT_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = CONTACT_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_D6_SPRING_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = D6_SPRING_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_GEAR_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = GEAR_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_FIXED_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = FIXED_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_D6_SPRING_2_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = D6_SPRING_2_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_MAX_CONSTRAINT_TYPE_mbt_e879218550ba2e2b() { + btTypedConstraintType result; + intgo _swig_go_result; + + + result = MAX_CONSTRAINT_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONSTRAINT_ERP_mbt_e879218550ba2e2b() { + btConstraintParams result; + intgo _swig_go_result; + + + result = BT_CONSTRAINT_ERP; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONSTRAINT_STOP_ERP_mbt_e879218550ba2e2b() { + btConstraintParams result; + intgo _swig_go_result; + + + result = BT_CONSTRAINT_STOP_ERP; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONSTRAINT_CFM_mbt_e879218550ba2e2b() { + btConstraintParams result; + intgo _swig_go_result; + + + result = BT_CONSTRAINT_CFM; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONSTRAINT_STOP_CFM_mbt_e879218550ba2e2b() { + btConstraintParams result; + intgo _swig_go_result; + + + result = BT_CONSTRAINT_STOP_CFM; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btJointFeedback_m_appliedForceBodyA_set_mbt_e879218550ba2e2b(btJointFeedback *_swig_go_0, btVector3 *_swig_go_1) { + btJointFeedback *arg1 = (btJointFeedback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btJointFeedback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_appliedForceBodyA = *arg2; + +} + + +btVector3 *_wrap_btJointFeedback_m_appliedForceBodyA_get_mbt_e879218550ba2e2b(btJointFeedback *_swig_go_0) { + btJointFeedback *arg1 = (btJointFeedback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btJointFeedback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_appliedForceBodyA); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btJointFeedback_m_appliedTorqueBodyA_set_mbt_e879218550ba2e2b(btJointFeedback *_swig_go_0, btVector3 *_swig_go_1) { + btJointFeedback *arg1 = (btJointFeedback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btJointFeedback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_appliedTorqueBodyA = *arg2; + +} + + +btVector3 *_wrap_btJointFeedback_m_appliedTorqueBodyA_get_mbt_e879218550ba2e2b(btJointFeedback *_swig_go_0) { + btJointFeedback *arg1 = (btJointFeedback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btJointFeedback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_appliedTorqueBodyA); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btJointFeedback_m_appliedForceBodyB_set_mbt_e879218550ba2e2b(btJointFeedback *_swig_go_0, btVector3 *_swig_go_1) { + btJointFeedback *arg1 = (btJointFeedback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btJointFeedback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_appliedForceBodyB = *arg2; + +} + + +btVector3 *_wrap_btJointFeedback_m_appliedForceBodyB_get_mbt_e879218550ba2e2b(btJointFeedback *_swig_go_0) { + btJointFeedback *arg1 = (btJointFeedback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btJointFeedback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_appliedForceBodyB); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btJointFeedback_m_appliedTorqueBodyB_set_mbt_e879218550ba2e2b(btJointFeedback *_swig_go_0, btVector3 *_swig_go_1) { + btJointFeedback *arg1 = (btJointFeedback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btJointFeedback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_appliedTorqueBodyB = *arg2; + +} + + +btVector3 *_wrap_btJointFeedback_m_appliedTorqueBodyB_get_mbt_e879218550ba2e2b(btJointFeedback *_swig_go_0) { + btJointFeedback *arg1 = (btJointFeedback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btJointFeedback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_appliedTorqueBodyB); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +btJointFeedback *_wrap_new_btJointFeedback_mbt_e879218550ba2e2b() { + btJointFeedback *result = 0 ; + btJointFeedback *_swig_go_result; + + + result = (btJointFeedback *)new btJointFeedback(); + *(btJointFeedback **)&_swig_go_result = (btJointFeedback *)result; + return _swig_go_result; +} + + +void _wrap_delete_btJointFeedback_mbt_e879218550ba2e2b(btJointFeedback *_swig_go_0) { + btJointFeedback *arg1 = (btJointFeedback *) 0 ; + + arg1 = *(btJointFeedback **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_delete_btTypedConstraint_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + delete arg1; + +} + + +btRigidBody *_wrap_btTypedConstraint_getFixedBody_mbt_e879218550ba2e2b() { + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + + result = (btRigidBody *) &btTypedConstraint::getFixedBody(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btTypedConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (int)((btTypedConstraint const *)arg1)->getOverrideNumSolverIterations(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, intgo _swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setOverrideNumSolverIterations(arg2); + +} + + +void _wrap_btTypedConstraint_buildJacobian_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + (arg1)->buildJacobian(); + +} + + +void _wrap_btTypedConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, btAlignedObjectArray< btSolverConstraint > *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3, float _swig_go_4) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btConstraintArray *arg2 = 0 ; + int arg3 ; + int arg4 ; + btScalar arg5 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = *(btConstraintArray **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + + (arg1)->setupSolverConstraint(*arg2,arg3,arg4,arg5); + +} + + +void _wrap_btTypedConstraint_getInfo1_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo1 *_swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btTypedConstraint::btConstraintInfo1 *arg2 = (btTypedConstraint::btConstraintInfo1 *) 0 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo1 **)&_swig_go_1; + + (arg1)->getInfo1(arg2); + +} + + +void _wrap_btTypedConstraint_getInfo2_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo2 *_swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btTypedConstraint::btConstraintInfo2 *arg2 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_1; + + (arg1)->getInfo2(arg2); + +} + + +void _wrap_btTypedConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, float _swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->internalSetAppliedImpulse(arg2); + +} + + +float _wrap_btTypedConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btScalar)(arg1)->internalGetAppliedImpulse(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btTypedConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btScalar)((btTypedConstraint const *)arg1)->getBreakingImpulseThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, float _swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setBreakingImpulseThreshold(arg2); + +} + + +bool _wrap_btTypedConstraint_isEnabled_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (bool)((btTypedConstraint const *)arg1)->isEnabled(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraint_setEnabled_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, bool _swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setEnabled(arg2); + +} + + +void _wrap_btTypedConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, btSolverBody *_swig_go_1, btSolverBody *_swig_go_2, float _swig_go_3) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btSolverBody *arg2 = 0 ; + btSolverBody *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = *(btSolverBody **)&_swig_go_1; + arg3 = *(btSolverBody **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->solveConstraintObsolete(*arg2,*arg3,arg4); + +} + + +btRigidBody *_wrap_btTypedConstraint_getRigidBodyA__SWIG_0_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btRigidBody *) &((btTypedConstraint const *)arg1)->getRigidBodyA(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btTypedConstraint_getRigidBodyB__SWIG_0_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btRigidBody *) &((btTypedConstraint const *)arg1)->getRigidBodyB(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btTypedConstraint_getRigidBodyA__SWIG_1_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btRigidBody *) &(arg1)->getRigidBodyA(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btTypedConstraint_getRigidBodyB__SWIG_1_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btRigidBody *) &(arg1)->getRigidBodyB(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btTypedConstraint_getUserConstraintType_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (int)((btTypedConstraint const *)arg1)->getUserConstraintType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraint_setUserConstraintType_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, intgo _swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setUserConstraintType(arg2); + +} + + +void _wrap_btTypedConstraint_setUserConstraintId_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, intgo _swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setUserConstraintId(arg2); + +} + + +intgo _wrap_btTypedConstraint_getUserConstraintId_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (int)((btTypedConstraint const *)arg1)->getUserConstraintId(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, void *_swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + (arg1)->setUserConstraintPtr(arg2); + +} + + +void *_wrap_btTypedConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (void *)(arg1)->getUserConstraintPtr(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraint_setJointFeedback_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, btJointFeedback *_swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btJointFeedback *arg2 = (btJointFeedback *) 0 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = *(btJointFeedback **)&_swig_go_1; + + (arg1)->setJointFeedback(arg2); + +} + + +btJointFeedback *_wrap_btTypedConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btJointFeedback *result = 0 ; + btJointFeedback *_swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btJointFeedback *)((btTypedConstraint const *)arg1)->getJointFeedback(); + *(btJointFeedback **)&_swig_go_result = (btJointFeedback *)result; + return _swig_go_result; +} + + +btJointFeedback *_wrap_btTypedConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btJointFeedback *result = 0 ; + btJointFeedback *_swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btJointFeedback *)(arg1)->getJointFeedback(); + *(btJointFeedback **)&_swig_go_result = (btJointFeedback *)result; + return _swig_go_result; +} + + +intgo _wrap_btTypedConstraint_getUid_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (int)((btTypedConstraint const *)arg1)->getUid(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btTypedConstraint_needsFeedback_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (bool)((btTypedConstraint const *)arg1)->needsFeedback(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraint_enableFeedback_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, bool _swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->enableFeedback(arg2); + +} + + +float _wrap_btTypedConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btScalar)((btTypedConstraint const *)arg1)->getAppliedImpulse(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btTypedConstraint_getConstraintType_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btTypedConstraintType result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btTypedConstraintType)((btTypedConstraint const *)arg1)->getConstraintType(); + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, float _swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setDbgDrawSize(arg2); + +} + + +float _wrap_btTypedConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (btScalar)(arg1)->getDbgDrawSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2, intgo _swig_go_3) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + int arg4 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->setParam(arg2,arg3,arg4); + +} + + +void _wrap_btTypedConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setParam(arg2,arg3); + +} + + +float _wrap_btTypedConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int arg2 ; + int arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btScalar)((btTypedConstraint const *)arg1)->getParam(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btTypedConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, intgo _swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btScalar)((btTypedConstraint const *)arg1)->getParam(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btTypedConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (int)((btTypedConstraint const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btTypedConstraint_serialize_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btTypedConstraint const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_SetbtTypedConstraint_M_objectType_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0, intgo _swig_go_1) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTypedObject *swig_b0 = (btTypedObject *)arg1; + if (swig_b0) (swig_b0)->m_objectType = arg2; + +} + + +intgo _wrap_GetbtTypedConstraint_M_objectType_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + btTypedObject *swig_b0 = (btTypedObject *)arg1; + result = (int) ((swig_b0)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btTypedConstraint_getObjectType_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + btTypedObject *swig_b0 = (btTypedObject *)arg1; + result = (int)((btTypedObject const *)swig_b0)->getObjectType(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAdjustAngleToLimits_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1, float _swig_go_2) { + btScalar arg1 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = (btScalar)btAdjustAngleToLimits(arg1,arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_rbA_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, btRigidBodyFloatData *_swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + btRigidBodyFloatData *arg2 = (btRigidBodyFloatData *) 0 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = *(btRigidBodyFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbA = arg2; + +} + + +btRigidBodyFloatData *_wrap_btTypedConstraintFloatData_m_rbA_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + btRigidBodyFloatData *result = 0 ; + btRigidBodyFloatData *_swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (btRigidBodyFloatData *) ((arg1)->m_rbA); + *(btRigidBodyFloatData **)&_swig_go_result = (btRigidBodyFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_rbB_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, btRigidBodyFloatData *_swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + btRigidBodyFloatData *arg2 = (btRigidBodyFloatData *) 0 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = *(btRigidBodyFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbB = arg2; + +} + + +btRigidBodyFloatData *_wrap_btTypedConstraintFloatData_m_rbB_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + btRigidBodyFloatData *result = 0 ; + btRigidBodyFloatData *_swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (btRigidBodyFloatData *) ((arg1)->m_rbB); + *(btRigidBodyFloatData **)&_swig_go_result = (btRigidBodyFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_name_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, _gostring_ _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + delete [] arg1->m_name; + if (arg2) { + arg1->m_name = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->m_name, (const char *)arg2); + } else { + arg1->m_name = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btTypedConstraintFloatData_m_name_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (char *) ((arg1)->m_name); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_objectType_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_objectType = arg2; + +} + + +intgo _wrap_btTypedConstraintFloatData_m_objectType_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_userConstraintType_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_userConstraintType = arg2; + +} + + +intgo _wrap_btTypedConstraintFloatData_m_userConstraintType_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_userConstraintType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_userConstraintId_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_userConstraintId = arg2; + +} + + +intgo _wrap_btTypedConstraintFloatData_m_userConstraintId_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_userConstraintId); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_needsFeedback_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_needsFeedback = arg2; + +} + + +intgo _wrap_btTypedConstraintFloatData_m_needsFeedback_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_needsFeedback); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_appliedImpulse_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, float _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + float arg2 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_appliedImpulse = arg2; + +} + + +float _wrap_btTypedConstraintFloatData_m_appliedImpulse_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_appliedImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_dbgDrawSize_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, float _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + float arg2 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_dbgDrawSize = arg2; + +} + + +float _wrap_btTypedConstraintFloatData_m_dbgDrawSize_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_dbgDrawSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_disableCollisionsBetweenLinkedBodies_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_disableCollisionsBetweenLinkedBodies = arg2; + +} + + +intgo _wrap_btTypedConstraintFloatData_m_disableCollisionsBetweenLinkedBodies_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_disableCollisionsBetweenLinkedBodies); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_overrideNumSolverIterations = arg2; + +} + + +intgo _wrap_btTypedConstraintFloatData_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_overrideNumSolverIterations); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_breakingImpulseThreshold_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, float _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + float arg2 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_breakingImpulseThreshold = arg2; + +} + + +float _wrap_btTypedConstraintFloatData_m_breakingImpulseThreshold_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_breakingImpulseThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintFloatData_m_isEnabled_set_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_isEnabled = arg2; + +} + + +intgo _wrap_btTypedConstraintFloatData_m_isEnabled_get_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_isEnabled); + _swig_go_result = result; + return _swig_go_result; +} + + +btTypedConstraintFloatData *_wrap_new_btTypedConstraintFloatData_mbt_e879218550ba2e2b() { + btTypedConstraintFloatData *result = 0 ; + btTypedConstraintFloatData *_swig_go_result; + + + result = (btTypedConstraintFloatData *)new btTypedConstraintFloatData(); + *(btTypedConstraintFloatData **)&_swig_go_result = (btTypedConstraintFloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btTypedConstraintFloatData_mbt_e879218550ba2e2b(btTypedConstraintFloatData *_swig_go_0) { + btTypedConstraintFloatData *arg1 = (btTypedConstraintFloatData *) 0 ; + + arg1 = *(btTypedConstraintFloatData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btTypedConstraintData_m_rbA_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, btRigidBodyFloatData *_swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + btRigidBodyFloatData *arg2 = (btRigidBodyFloatData *) 0 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = *(btRigidBodyFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbA = arg2; + +} + + +btRigidBodyFloatData *_wrap_btTypedConstraintData_m_rbA_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + btRigidBodyFloatData *result = 0 ; + btRigidBodyFloatData *_swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (btRigidBodyFloatData *) ((arg1)->m_rbA); + *(btRigidBodyFloatData **)&_swig_go_result = (btRigidBodyFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_rbB_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, btRigidBodyFloatData *_swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + btRigidBodyFloatData *arg2 = (btRigidBodyFloatData *) 0 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = *(btRigidBodyFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbB = arg2; + +} + + +btRigidBodyFloatData *_wrap_btTypedConstraintData_m_rbB_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + btRigidBodyFloatData *result = 0 ; + btRigidBodyFloatData *_swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (btRigidBodyFloatData *) ((arg1)->m_rbB); + *(btRigidBodyFloatData **)&_swig_go_result = (btRigidBodyFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_name_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, _gostring_ _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + delete [] arg1->m_name; + if (arg2) { + arg1->m_name = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->m_name, (const char *)arg2); + } else { + arg1->m_name = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btTypedConstraintData_m_name_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (char *) ((arg1)->m_name); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_objectType_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_objectType = arg2; + +} + + +intgo _wrap_btTypedConstraintData_m_objectType_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (int) ((arg1)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_userConstraintType_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_userConstraintType = arg2; + +} + + +intgo _wrap_btTypedConstraintData_m_userConstraintType_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (int) ((arg1)->m_userConstraintType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_userConstraintId_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_userConstraintId = arg2; + +} + + +intgo _wrap_btTypedConstraintData_m_userConstraintId_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (int) ((arg1)->m_userConstraintId); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_needsFeedback_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_needsFeedback = arg2; + +} + + +intgo _wrap_btTypedConstraintData_m_needsFeedback_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (int) ((arg1)->m_needsFeedback); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_appliedImpulse_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, float _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + float arg2 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_appliedImpulse = arg2; + +} + + +float _wrap_btTypedConstraintData_m_appliedImpulse_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (float) ((arg1)->m_appliedImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_dbgDrawSize_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, float _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + float arg2 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_dbgDrawSize = arg2; + +} + + +float _wrap_btTypedConstraintData_m_dbgDrawSize_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (float) ((arg1)->m_dbgDrawSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_disableCollisionsBetweenLinkedBodies_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_disableCollisionsBetweenLinkedBodies = arg2; + +} + + +intgo _wrap_btTypedConstraintData_m_disableCollisionsBetweenLinkedBodies_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (int) ((arg1)->m_disableCollisionsBetweenLinkedBodies); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_overrideNumSolverIterations = arg2; + +} + + +intgo _wrap_btTypedConstraintData_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (int) ((arg1)->m_overrideNumSolverIterations); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_breakingImpulseThreshold_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, float _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + float arg2 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_breakingImpulseThreshold = arg2; + +} + + +float _wrap_btTypedConstraintData_m_breakingImpulseThreshold_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (float) ((arg1)->m_breakingImpulseThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintData_m_isEnabled_set_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_isEnabled = arg2; + +} + + +intgo _wrap_btTypedConstraintData_m_isEnabled_get_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + result = (int) ((arg1)->m_isEnabled); + _swig_go_result = result; + return _swig_go_result; +} + + +btTypedConstraintData *_wrap_new_btTypedConstraintData_mbt_e879218550ba2e2b() { + btTypedConstraintData *result = 0 ; + btTypedConstraintData *_swig_go_result; + + + result = (btTypedConstraintData *)new btTypedConstraintData(); + *(btTypedConstraintData **)&_swig_go_result = (btTypedConstraintData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btTypedConstraintData_mbt_e879218550ba2e2b(btTypedConstraintData *_swig_go_0) { + btTypedConstraintData *arg1 = (btTypedConstraintData *) 0 ; + + arg1 = *(btTypedConstraintData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btTypedConstraintDoubleData_m_rbA_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, btRigidBodyDoubleData *_swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + btRigidBodyDoubleData *arg2 = (btRigidBodyDoubleData *) 0 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = *(btRigidBodyDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbA = arg2; + +} + + +btRigidBodyDoubleData *_wrap_btTypedConstraintDoubleData_m_rbA_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + btRigidBodyDoubleData *result = 0 ; + btRigidBodyDoubleData *_swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (btRigidBodyDoubleData *) ((arg1)->m_rbA); + *(btRigidBodyDoubleData **)&_swig_go_result = (btRigidBodyDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_rbB_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, btRigidBodyDoubleData *_swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + btRigidBodyDoubleData *arg2 = (btRigidBodyDoubleData *) 0 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = *(btRigidBodyDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbB = arg2; + +} + + +btRigidBodyDoubleData *_wrap_btTypedConstraintDoubleData_m_rbB_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + btRigidBodyDoubleData *result = 0 ; + btRigidBodyDoubleData *_swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (btRigidBodyDoubleData *) ((arg1)->m_rbB); + *(btRigidBodyDoubleData **)&_swig_go_result = (btRigidBodyDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_name_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, _gostring_ _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + delete [] arg1->m_name; + if (arg2) { + arg1->m_name = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->m_name, (const char *)arg2); + } else { + arg1->m_name = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btTypedConstraintDoubleData_m_name_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (char *) ((arg1)->m_name); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_objectType_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_objectType = arg2; + +} + + +intgo _wrap_btTypedConstraintDoubleData_m_objectType_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_userConstraintType_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_userConstraintType = arg2; + +} + + +intgo _wrap_btTypedConstraintDoubleData_m_userConstraintType_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_userConstraintType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_userConstraintId_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_userConstraintId = arg2; + +} + + +intgo _wrap_btTypedConstraintDoubleData_m_userConstraintId_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_userConstraintId); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_needsFeedback_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_needsFeedback = arg2; + +} + + +intgo _wrap_btTypedConstraintDoubleData_m_needsFeedback_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_needsFeedback); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_appliedImpulse_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, double _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_appliedImpulse = arg2; + +} + + +double _wrap_btTypedConstraintDoubleData_m_appliedImpulse_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_appliedImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_dbgDrawSize_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, double _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_dbgDrawSize = arg2; + +} + + +double _wrap_btTypedConstraintDoubleData_m_dbgDrawSize_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_dbgDrawSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_disableCollisionsBetweenLinkedBodies_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_disableCollisionsBetweenLinkedBodies = arg2; + +} + + +intgo _wrap_btTypedConstraintDoubleData_m_disableCollisionsBetweenLinkedBodies_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_disableCollisionsBetweenLinkedBodies); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_overrideNumSolverIterations = arg2; + +} + + +intgo _wrap_btTypedConstraintDoubleData_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_overrideNumSolverIterations); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_breakingImpulseThreshold_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, double _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_breakingImpulseThreshold = arg2; + +} + + +double _wrap_btTypedConstraintDoubleData_m_breakingImpulseThreshold_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_breakingImpulseThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_m_isEnabled_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, intgo _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_isEnabled = arg2; + +} + + +intgo _wrap_btTypedConstraintDoubleData_m_isEnabled_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_isEnabled); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTypedConstraintDoubleData_padding_set_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0, _gostring_ _swig_go_1) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->padding, (const char *)arg2, 4-1); + arg1->padding[4-1] = 0; + } else { + arg1->padding[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btTypedConstraintDoubleData_padding_get_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->padding); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btTypedConstraintDoubleData *_wrap_new_btTypedConstraintDoubleData_mbt_e879218550ba2e2b() { + btTypedConstraintDoubleData *result = 0 ; + btTypedConstraintDoubleData *_swig_go_result; + + + result = (btTypedConstraintDoubleData *)new btTypedConstraintDoubleData(); + *(btTypedConstraintDoubleData **)&_swig_go_result = (btTypedConstraintDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btTypedConstraintDoubleData_mbt_e879218550ba2e2b(btTypedConstraintDoubleData *_swig_go_0) { + btTypedConstraintDoubleData *arg1 = (btTypedConstraintDoubleData *) 0 ; + + arg1 = *(btTypedConstraintDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +btAngularLimit *_wrap_new_btAngularLimit_mbt_e879218550ba2e2b() { + btAngularLimit *result = 0 ; + btAngularLimit *_swig_go_result; + + + result = (btAngularLimit *)new btAngularLimit(); + *(btAngularLimit **)&_swig_go_result = (btAngularLimit *)result; + return _swig_go_result; +} + + +void _wrap_btAngularLimit_set__SWIG_0_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4, float _swig_go_5) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar arg4 ; + btScalar arg5 ; + btScalar arg6 ; + + arg1 = *(btAngularLimit **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + (arg1)->set(arg2,arg3,arg4,arg5,arg6); + +} + + +void _wrap_btAngularLimit_set__SWIG_1_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar arg4 ; + btScalar arg5 ; + + arg1 = *(btAngularLimit **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + + (arg1)->set(arg2,arg3,arg4,arg5); + +} + + +void _wrap_btAngularLimit_set__SWIG_2_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar arg4 ; + + arg1 = *(btAngularLimit **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->set(arg2,arg3,arg4); + +} + + +void _wrap_btAngularLimit_set__SWIG_3_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btAngularLimit **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->set(arg2,arg3); + +} + + +void _wrap_btAngularLimit_test_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0, float _swig_go_1) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar arg2 ; + + arg1 = *(btAngularLimit **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->test(arg2); + +} + + +float _wrap_btAngularLimit_getSoftness_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + result = (btScalar)((btAngularLimit const *)arg1)->getSoftness(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAngularLimit_getBiasFactor_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + result = (btScalar)((btAngularLimit const *)arg1)->getBiasFactor(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAngularLimit_getRelaxationFactor_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + result = (btScalar)((btAngularLimit const *)arg1)->getRelaxationFactor(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAngularLimit_getCorrection_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + result = (btScalar)((btAngularLimit const *)arg1)->getCorrection(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAngularLimit_getSign_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + result = (btScalar)((btAngularLimit const *)arg1)->getSign(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAngularLimit_getHalfRange_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + result = (btScalar)((btAngularLimit const *)arg1)->getHalfRange(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btAngularLimit_isLimit_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + result = (bool)((btAngularLimit const *)arg1)->isLimit(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btAngularLimit_fit_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0, float *_swig_go_1) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar *arg2 = 0 ; + + arg1 = *(btAngularLimit **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + ((btAngularLimit const *)arg1)->fit(*arg2); + +} + + +float _wrap_btAngularLimit_getError_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + result = (btScalar)((btAngularLimit const *)arg1)->getError(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAngularLimit_getLow_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + result = (btScalar)((btAngularLimit const *)arg1)->getLow(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btAngularLimit_getHigh_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + result = (btScalar)((btAngularLimit const *)arg1)->getHigh(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btAngularLimit_mbt_e879218550ba2e2b(btAngularLimit *_swig_go_0) { + btAngularLimit *arg1 = (btAngularLimit *) 0 ; + + arg1 = *(btAngularLimit **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btHashString_m_string1_set_mbt_e879218550ba2e2b(btHashString *_swig_go_0, std::string *_swig_go_1) { + btHashString *arg1 = (btHashString *) 0 ; + std::string arg2 ; + std::string *argp2 ; + + arg1 = *(btHashString **)&_swig_go_0; + + argp2 = (std::string *)_swig_go_1; + if (argp2 == NULL) { + _swig_gopanic("Attempt to dereference null std::string"); + } + arg2 = (std::string)*argp2; + + + if (arg1) (arg1)->m_string1 = arg2; + +} + + +std::string *_wrap_btHashString_m_string1_get_mbt_e879218550ba2e2b(btHashString *_swig_go_0) { + btHashString *arg1 = (btHashString *) 0 ; + std::string result; + std::string *_swig_go_result; + + arg1 = *(btHashString **)&_swig_go_0; + + result = ((arg1)->m_string1); + *(std::string **)&_swig_go_result = new std::string(result); + return _swig_go_result; +} + + +void _wrap_btHashString_m_hash_set_mbt_e879218550ba2e2b(btHashString *_swig_go_0, intgo _swig_go_1) { + btHashString *arg1 = (btHashString *) 0 ; + unsigned int arg2 ; + + arg1 = *(btHashString **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + + if (arg1) (arg1)->m_hash = arg2; + +} + + +intgo _wrap_btHashString_m_hash_get_mbt_e879218550ba2e2b(btHashString *_swig_go_0) { + btHashString *arg1 = (btHashString *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btHashString **)&_swig_go_0; + + result = (unsigned int) ((arg1)->m_hash); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btHashString_getHash_mbt_e879218550ba2e2b(btHashString *_swig_go_0) { + btHashString *arg1 = (btHashString *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btHashString **)&_swig_go_0; + + result = (unsigned int)((btHashString const *)arg1)->getHash(); + _swig_go_result = result; + return _swig_go_result; +} + + +btHashString *_wrap_new_btHashString__SWIG_0_mbt_e879218550ba2e2b() { + btHashString *result = 0 ; + btHashString *_swig_go_result; + + + result = (btHashString *)new btHashString(); + *(btHashString **)&_swig_go_result = (btHashString *)result; + return _swig_go_result; +} + + +btHashString *_wrap_new_btHashString__SWIG_1_mbt_e879218550ba2e2b(_gostring_ _swig_go_0) { + char *arg1 = (char *) 0 ; + btHashString *result = 0 ; + btHashString *_swig_go_result; + + + arg1 = (char *)malloc(_swig_go_0.n + 1); + memcpy(arg1, _swig_go_0.p, _swig_go_0.n); + arg1[_swig_go_0.n] = '\0'; + + + result = (btHashString *)new btHashString((char const *)arg1); + *(btHashString **)&_swig_go_result = (btHashString *)result; + free(arg1); + return _swig_go_result; +} + + +bool _wrap_btHashString_equals_mbt_e879218550ba2e2b(btHashString *_swig_go_0, btHashString *_swig_go_1) { + btHashString *arg1 = (btHashString *) 0 ; + btHashString *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHashString **)&_swig_go_0; + arg2 = *(btHashString **)&_swig_go_1; + + result = (bool)((btHashString const *)arg1)->equals((btHashString const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btHashString_mbt_e879218550ba2e2b(btHashString *_swig_go_0) { + btHashString *arg1 = (btHashString *) 0 ; + + arg1 = *(btHashString **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_BT_HASH_NULL_get_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)(int)BT_HASH_NULL; + _swig_go_result = result; + return _swig_go_result; +} + + +btHashInt *_wrap_new_btHashInt__SWIG_0_mbt_e879218550ba2e2b() { + btHashInt *result = 0 ; + btHashInt *_swig_go_result; + + + result = (btHashInt *)new btHashInt(); + *(btHashInt **)&_swig_go_result = (btHashInt *)result; + return _swig_go_result; +} + + +btHashInt *_wrap_new_btHashInt__SWIG_1_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + btHashInt *result = 0 ; + btHashInt *_swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (btHashInt *)new btHashInt(arg1); + *(btHashInt **)&_swig_go_result = (btHashInt *)result; + return _swig_go_result; +} + + +intgo _wrap_btHashInt_getUid1_mbt_e879218550ba2e2b(btHashInt *_swig_go_0) { + btHashInt *arg1 = (btHashInt *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btHashInt **)&_swig_go_0; + + result = (int)((btHashInt const *)arg1)->getUid1(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btHashInt_setUid1_mbt_e879218550ba2e2b(btHashInt *_swig_go_0, intgo _swig_go_1) { + btHashInt *arg1 = (btHashInt *) 0 ; + int arg2 ; + + arg1 = *(btHashInt **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setUid1(arg2); + +} + + +bool _wrap_btHashInt_equals_mbt_e879218550ba2e2b(btHashInt *_swig_go_0, btHashInt *_swig_go_1) { + btHashInt *arg1 = (btHashInt *) 0 ; + btHashInt *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHashInt **)&_swig_go_0; + arg2 = *(btHashInt **)&_swig_go_1; + + result = (bool)((btHashInt const *)arg1)->equals((btHashInt const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btHashInt_getHash_mbt_e879218550ba2e2b(btHashInt *_swig_go_0) { + btHashInt *arg1 = (btHashInt *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btHashInt **)&_swig_go_0; + + result = (unsigned int)((btHashInt const *)arg1)->getHash(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btHashInt_mbt_e879218550ba2e2b(btHashInt *_swig_go_0) { + btHashInt *arg1 = (btHashInt *) 0 ; + + arg1 = *(btHashInt **)&_swig_go_0; + + delete arg1; + +} + + +btHashPtr *_wrap_new_btHashPtr__SWIG_0_mbt_e879218550ba2e2b() { + btHashPtr *result = 0 ; + btHashPtr *_swig_go_result; + + + result = (btHashPtr *)new btHashPtr(); + *(btHashPtr **)&_swig_go_result = (btHashPtr *)result; + return _swig_go_result; +} + + +btHashPtr *_wrap_new_btHashPtr__SWIG_1_mbt_e879218550ba2e2b(void *_swig_go_0) { + void *arg1 = (void *) 0 ; + btHashPtr *result = 0 ; + btHashPtr *_swig_go_result; + + arg1 = *(void **)&_swig_go_0; + + result = (btHashPtr *)new btHashPtr((void const *)arg1); + *(btHashPtr **)&_swig_go_result = (btHashPtr *)result; + return _swig_go_result; +} + + +void *_wrap_btHashPtr_getPointer_mbt_e879218550ba2e2b(btHashPtr *_swig_go_0) { + btHashPtr *arg1 = (btHashPtr *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btHashPtr **)&_swig_go_0; + + result = (void *)((btHashPtr const *)arg1)->getPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +bool _wrap_btHashPtr_equals_mbt_e879218550ba2e2b(btHashPtr *_swig_go_0, btHashPtr *_swig_go_1) { + btHashPtr *arg1 = (btHashPtr *) 0 ; + btHashPtr *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHashPtr **)&_swig_go_0; + arg2 = *(btHashPtr **)&_swig_go_1; + + result = (bool)((btHashPtr const *)arg1)->equals((btHashPtr const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btHashPtr_getHash_mbt_e879218550ba2e2b(btHashPtr *_swig_go_0) { + btHashPtr *arg1 = (btHashPtr *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btHashPtr **)&_swig_go_0; + + result = (unsigned int)((btHashPtr const *)arg1)->getHash(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btHashPtr_mbt_e879218550ba2e2b(btHashPtr *_swig_go_0) { + btHashPtr *arg1 = (btHashPtr *) 0 ; + + arg1 = *(btHashPtr **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_sBulletDNAstr_set_mbt_e879218550ba2e2b(_gostring_ _swig_go_0) { + char *arg1 = (char *) (char *)0 ; + + + arg1 = (char *)malloc(_swig_go_0.n + 1); + memcpy(arg1, _swig_go_0.p, _swig_go_0.n); + arg1[_swig_go_0.n] = '\0'; + + + { + if (arg1) strcpy((char *)sBulletDNAstr, (const char *)arg1); + else sBulletDNAstr[0] = 0; + } + + free(arg1); +} + + +_gostring_ _wrap_sBulletDNAstr_get_mbt_e879218550ba2e2b() { + char *result = 0 ; + _gostring_ _swig_go_result; + + + result = (char *)(char *)sBulletDNAstr; + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_sBulletDNAlen_set_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + + arg1 = (int)_swig_go_0; + + sBulletDNAlen = arg1; + +} + + +intgo _wrap_sBulletDNAlen_get_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)sBulletDNAlen; + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_sBulletDNAstr64_set_mbt_e879218550ba2e2b(_gostring_ _swig_go_0) { + char *arg1 = (char *) (char *)0 ; + + + arg1 = (char *)malloc(_swig_go_0.n + 1); + memcpy(arg1, _swig_go_0.p, _swig_go_0.n); + arg1[_swig_go_0.n] = '\0'; + + + { + if (arg1) strcpy((char *)sBulletDNAstr64, (const char *)arg1); + else sBulletDNAstr64[0] = 0; + } + + free(arg1); +} + + +_gostring_ _wrap_sBulletDNAstr64_get_mbt_e879218550ba2e2b() { + char *result = 0 ; + _gostring_ _swig_go_result; + + + result = (char *)(char *)sBulletDNAstr64; + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_sBulletDNAlen64_set_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + + arg1 = (int)_swig_go_0; + + sBulletDNAlen64 = arg1; + +} + + +intgo _wrap_sBulletDNAlen64_get_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)sBulletDNAlen64; + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btStrLen_mbt_e879218550ba2e2b(_gostring_ _swig_go_0) { + char *arg1 = (char *) 0 ; + int result; + intgo _swig_go_result; + + + arg1 = (char *)malloc(_swig_go_0.n + 1); + memcpy(arg1, _swig_go_0.p, _swig_go_0.n); + arg1[_swig_go_0.n] = '\0'; + + + result = (int)btStrLen((char const *)arg1); + _swig_go_result = result; + free(arg1); + return _swig_go_result; +} + + +void _wrap_btChunk_m_chunkCode_set_mbt_e879218550ba2e2b(btChunk *_swig_go_0, intgo _swig_go_1) { + btChunk *arg1 = (btChunk *) 0 ; + int arg2 ; + + arg1 = *(btChunk **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_chunkCode = arg2; + +} + + +intgo _wrap_btChunk_m_chunkCode_get_mbt_e879218550ba2e2b(btChunk *_swig_go_0) { + btChunk *arg1 = (btChunk *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btChunk **)&_swig_go_0; + + result = (int) ((arg1)->m_chunkCode); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btChunk_m_length_set_mbt_e879218550ba2e2b(btChunk *_swig_go_0, intgo _swig_go_1) { + btChunk *arg1 = (btChunk *) 0 ; + int arg2 ; + + arg1 = *(btChunk **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_length = arg2; + +} + + +intgo _wrap_btChunk_m_length_get_mbt_e879218550ba2e2b(btChunk *_swig_go_0) { + btChunk *arg1 = (btChunk *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btChunk **)&_swig_go_0; + + result = (int) ((arg1)->m_length); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btChunk_m_oldPtr_set_mbt_e879218550ba2e2b(btChunk *_swig_go_0, void *_swig_go_1) { + btChunk *arg1 = (btChunk *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btChunk **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + if (arg1) (arg1)->m_oldPtr = arg2; + +} + + +void *_wrap_btChunk_m_oldPtr_get_mbt_e879218550ba2e2b(btChunk *_swig_go_0) { + btChunk *arg1 = (btChunk *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btChunk **)&_swig_go_0; + + result = (void *) ((arg1)->m_oldPtr); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btChunk_m_dna_nr_set_mbt_e879218550ba2e2b(btChunk *_swig_go_0, intgo _swig_go_1) { + btChunk *arg1 = (btChunk *) 0 ; + int arg2 ; + + arg1 = *(btChunk **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_dna_nr = arg2; + +} + + +intgo _wrap_btChunk_m_dna_nr_get_mbt_e879218550ba2e2b(btChunk *_swig_go_0) { + btChunk *arg1 = (btChunk *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btChunk **)&_swig_go_0; + + result = (int) ((arg1)->m_dna_nr); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btChunk_m_number_set_mbt_e879218550ba2e2b(btChunk *_swig_go_0, intgo _swig_go_1) { + btChunk *arg1 = (btChunk *) 0 ; + int arg2 ; + + arg1 = *(btChunk **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_number = arg2; + +} + + +intgo _wrap_btChunk_m_number_get_mbt_e879218550ba2e2b(btChunk *_swig_go_0) { + btChunk *arg1 = (btChunk *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btChunk **)&_swig_go_0; + + result = (int) ((arg1)->m_number); + _swig_go_result = result; + return _swig_go_result; +} + + +btChunk *_wrap_new_btChunk_mbt_e879218550ba2e2b() { + btChunk *result = 0 ; + btChunk *_swig_go_result; + + + result = (btChunk *)new btChunk(); + *(btChunk **)&_swig_go_result = (btChunk *)result; + return _swig_go_result; +} + + +void _wrap_delete_btChunk_mbt_e879218550ba2e2b(btChunk *_swig_go_0) { + btChunk *arg1 = (btChunk *) 0 ; + + arg1 = *(btChunk **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_BT_SERIALIZE_NO_BVH_mbt_e879218550ba2e2b() { + btSerializationFlags result; + intgo _swig_go_result; + + + result = BT_SERIALIZE_NO_BVH; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_SERIALIZE_NO_TRIANGLEINFOMAP_mbt_e879218550ba2e2b() { + btSerializationFlags result; + intgo _swig_go_result; + + + result = BT_SERIALIZE_NO_TRIANGLEINFOMAP; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_SERIALIZE_NO_DUPLICATE_ASSERT_mbt_e879218550ba2e2b() { + btSerializationFlags result; + intgo _swig_go_result; + + + result = BT_SERIALIZE_NO_DUPLICATE_ASSERT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_SERIALIZE_CONTACT_MANIFOLDS_mbt_e879218550ba2e2b() { + btSerializationFlags result; + intgo _swig_go_result; + + + result = BT_SERIALIZE_CONTACT_MANIFOLDS; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_delete_btSerializer_mbt_e879218550ba2e2b(btSerializer *_swig_go_0) { + btSerializer *arg1 = (btSerializer *) 0 ; + + arg1 = *(btSerializer **)&_swig_go_0; + + delete arg1; + +} + + +char *_wrap_btSerializer_getBufferPointer_mbt_e879218550ba2e2b(btSerializer *_swig_go_0) { + btSerializer *arg1 = (btSerializer *) 0 ; + unsigned char *result = 0 ; + char *_swig_go_result; + + arg1 = *(btSerializer **)&_swig_go_0; + + result = (unsigned char *)((btSerializer const *)arg1)->getBufferPointer(); + *(unsigned char **)&_swig_go_result = (unsigned char *)result; + return _swig_go_result; +} + + +intgo _wrap_btSerializer_getCurrentBufferSize_mbt_e879218550ba2e2b(btSerializer *_swig_go_0) { + btSerializer *arg1 = (btSerializer *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSerializer **)&_swig_go_0; + + result = (int)((btSerializer const *)arg1)->getCurrentBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +btChunk *_wrap_btSerializer_allocate_mbt_e879218550ba2e2b(btSerializer *_swig_go_0, long long _swig_go_1, intgo _swig_go_2) { + btSerializer *arg1 = (btSerializer *) 0 ; + size_t arg2 ; + int arg3 ; + btChunk *result = 0 ; + btChunk *_swig_go_result; + + arg1 = *(btSerializer **)&_swig_go_0; + arg2 = (size_t)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btChunk *)(arg1)->allocate(arg2,arg3); + *(btChunk **)&_swig_go_result = (btChunk *)result; + return _swig_go_result; +} + + +void _wrap_btSerializer_finalizeChunk_mbt_e879218550ba2e2b(btSerializer *_swig_go_0, btChunk *_swig_go_1, _gostring_ _swig_go_2, intgo _swig_go_3, void *_swig_go_4) { + btSerializer *arg1 = (btSerializer *) 0 ; + btChunk *arg2 = (btChunk *) 0 ; + char *arg3 = (char *) 0 ; + int arg4 ; + void *arg5 = (void *) 0 ; + + arg1 = *(btSerializer **)&_swig_go_0; + arg2 = *(btChunk **)&_swig_go_1; + + arg3 = (char *)malloc(_swig_go_2.n + 1); + memcpy(arg3, _swig_go_2.p, _swig_go_2.n); + arg3[_swig_go_2.n] = '\0'; + + arg4 = (int)_swig_go_3; + arg5 = *(void **)&_swig_go_4; + + (arg1)->finalizeChunk(arg2,(char const *)arg3,arg4,arg5); + + free(arg3); +} + + +void *_wrap_btSerializer_findPointer_mbt_e879218550ba2e2b(btSerializer *_swig_go_0, void *_swig_go_1) { + btSerializer *arg1 = (btSerializer *) 0 ; + void *arg2 = (void *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btSerializer **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + result = (void *)(arg1)->findPointer(arg2); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void *_wrap_btSerializer_getUniquePointer_mbt_e879218550ba2e2b(btSerializer *_swig_go_0, void *_swig_go_1) { + btSerializer *arg1 = (btSerializer *) 0 ; + void *arg2 = (void *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btSerializer **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + result = (void *)(arg1)->getUniquePointer(arg2); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btSerializer_startSerialization_mbt_e879218550ba2e2b(btSerializer *_swig_go_0) { + btSerializer *arg1 = (btSerializer *) 0 ; + + arg1 = *(btSerializer **)&_swig_go_0; + + (arg1)->startSerialization(); + +} + + +void _wrap_btSerializer_finishSerialization_mbt_e879218550ba2e2b(btSerializer *_swig_go_0) { + btSerializer *arg1 = (btSerializer *) 0 ; + + arg1 = *(btSerializer **)&_swig_go_0; + + (arg1)->finishSerialization(); + +} + + +_gostring_ _wrap_btSerializer_findNameForPointer_mbt_e879218550ba2e2b(btSerializer *_swig_go_0, void *_swig_go_1) { + btSerializer *arg1 = (btSerializer *) 0 ; + void *arg2 = (void *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btSerializer **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + result = (char *)((btSerializer const *)arg1)->findNameForPointer((void const *)arg2); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btSerializer_registerNameForPointer_mbt_e879218550ba2e2b(btSerializer *_swig_go_0, void *_swig_go_1, _gostring_ _swig_go_2) { + btSerializer *arg1 = (btSerializer *) 0 ; + void *arg2 = (void *) 0 ; + char *arg3 = (char *) 0 ; + + arg1 = *(btSerializer **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + arg3 = (char *)malloc(_swig_go_2.n + 1); + memcpy(arg3, _swig_go_2.p, _swig_go_2.n); + arg3[_swig_go_2.n] = '\0'; + + + (arg1)->registerNameForPointer((void const *)arg2,(char const *)arg3); + + free(arg3); +} + + +void _wrap_btSerializer_serializeName_mbt_e879218550ba2e2b(btSerializer *_swig_go_0, _gostring_ _swig_go_1) { + btSerializer *arg1 = (btSerializer *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = *(btSerializer **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + (arg1)->serializeName((char const *)arg2); + + free(arg2); +} + + +intgo _wrap_btSerializer_getSerializationFlags_mbt_e879218550ba2e2b(btSerializer *_swig_go_0) { + btSerializer *arg1 = (btSerializer *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSerializer **)&_swig_go_0; + + result = (int)((btSerializer const *)arg1)->getSerializationFlags(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSerializer_setSerializationFlags_mbt_e879218550ba2e2b(btSerializer *_swig_go_0, intgo _swig_go_1) { + btSerializer *arg1 = (btSerializer *) 0 ; + int arg2 ; + + arg1 = *(btSerializer **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setSerializationFlags(arg2); + +} + + +intgo _wrap_btSerializer_getNumChunks_mbt_e879218550ba2e2b(btSerializer *_swig_go_0) { + btSerializer *arg1 = (btSerializer *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSerializer **)&_swig_go_0; + + result = (int)((btSerializer const *)arg1)->getNumChunks(); + _swig_go_result = result; + return _swig_go_result; +} + + +btChunk *_wrap_btSerializer_getChunk_mbt_e879218550ba2e2b(btSerializer *_swig_go_0, intgo _swig_go_1) { + btSerializer *arg1 = (btSerializer *) 0 ; + int arg2 ; + btChunk *result = 0 ; + btChunk *_swig_go_result; + + arg1 = *(btSerializer **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btChunk *)((btSerializer const *)arg1)->getChunk(arg2); + *(btChunk **)&_swig_go_result = (btChunk *)result; + return _swig_go_result; +} + + +btPointerUid *_wrap_new_btPointerUid_mbt_e879218550ba2e2b() { + btPointerUid *result = 0 ; + btPointerUid *_swig_go_result; + + + result = (btPointerUid *)new btPointerUid(); + *(btPointerUid **)&_swig_go_result = (btPointerUid *)result; + return _swig_go_result; +} + + +void _wrap_delete_btPointerUid_mbt_e879218550ba2e2b(btPointerUid *_swig_go_0) { + btPointerUid *arg1 = (btPointerUid *) 0 ; + + arg1 = *(btPointerUid **)&_swig_go_0; + + delete arg1; + +} + + +btBulletSerializedArrays *_wrap_new_btBulletSerializedArrays_mbt_e879218550ba2e2b() { + btBulletSerializedArrays *result = 0 ; + btBulletSerializedArrays *_swig_go_result; + + + result = (btBulletSerializedArrays *)new btBulletSerializedArrays(); + *(btBulletSerializedArrays **)&_swig_go_result = (btBulletSerializedArrays *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_bvhsDouble_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btQuantizedBvhDoubleData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btQuantizedBvhDoubleData * > *arg2 = (btAlignedObjectArray< btQuantizedBvhDoubleData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btQuantizedBvhDoubleData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_bvhsDouble = *arg2; + +} + + +btAlignedObjectArray< btQuantizedBvhDoubleData * > *_wrap_btBulletSerializedArrays_m_bvhsDouble_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btQuantizedBvhDoubleData * > *result = 0 ; + btAlignedObjectArray< btQuantizedBvhDoubleData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btQuantizedBvhDoubleData * > *)& ((arg1)->m_bvhsDouble); + *(btAlignedObjectArray< btQuantizedBvhDoubleData * > **)&_swig_go_result = (btAlignedObjectArray< btQuantizedBvhDoubleData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_bvhsFloat_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btQuantizedBvhFloatData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btQuantizedBvhFloatData * > *arg2 = (btAlignedObjectArray< btQuantizedBvhFloatData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btQuantizedBvhFloatData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_bvhsFloat = *arg2; + +} + + +btAlignedObjectArray< btQuantizedBvhFloatData * > *_wrap_btBulletSerializedArrays_m_bvhsFloat_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btQuantizedBvhFloatData * > *result = 0 ; + btAlignedObjectArray< btQuantizedBvhFloatData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btQuantizedBvhFloatData * > *)& ((arg1)->m_bvhsFloat); + *(btAlignedObjectArray< btQuantizedBvhFloatData * > **)&_swig_go_result = (btAlignedObjectArray< btQuantizedBvhFloatData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_colShapeData_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btCollisionShapeData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btCollisionShapeData * > *arg2 = (btAlignedObjectArray< btCollisionShapeData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btCollisionShapeData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_colShapeData = *arg2; + +} + + +btAlignedObjectArray< btCollisionShapeData * > *_wrap_btBulletSerializedArrays_m_colShapeData_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btCollisionShapeData * > *result = 0 ; + btAlignedObjectArray< btCollisionShapeData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btCollisionShapeData * > *)& ((arg1)->m_colShapeData); + *(btAlignedObjectArray< btCollisionShapeData * > **)&_swig_go_result = (btAlignedObjectArray< btCollisionShapeData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataDouble_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btDynamicsWorldDoubleData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btDynamicsWorldDoubleData * > *arg2 = (btAlignedObjectArray< btDynamicsWorldDoubleData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btDynamicsWorldDoubleData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_dynamicWorldInfoDataDouble = *arg2; + +} + + +btAlignedObjectArray< btDynamicsWorldDoubleData * > *_wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataDouble_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btDynamicsWorldDoubleData * > *result = 0 ; + btAlignedObjectArray< btDynamicsWorldDoubleData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btDynamicsWorldDoubleData * > *)& ((arg1)->m_dynamicWorldInfoDataDouble); + *(btAlignedObjectArray< btDynamicsWorldDoubleData * > **)&_swig_go_result = (btAlignedObjectArray< btDynamicsWorldDoubleData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataFloat_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btDynamicsWorldFloatData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btDynamicsWorldFloatData * > *arg2 = (btAlignedObjectArray< btDynamicsWorldFloatData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btDynamicsWorldFloatData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_dynamicWorldInfoDataFloat = *arg2; + +} + + +btAlignedObjectArray< btDynamicsWorldFloatData * > *_wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataFloat_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btDynamicsWorldFloatData * > *result = 0 ; + btAlignedObjectArray< btDynamicsWorldFloatData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btDynamicsWorldFloatData * > *)& ((arg1)->m_dynamicWorldInfoDataFloat); + *(btAlignedObjectArray< btDynamicsWorldFloatData * > **)&_swig_go_result = (btAlignedObjectArray< btDynamicsWorldFloatData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_rigidBodyDataDouble_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btRigidBodyDoubleData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btRigidBodyDoubleData * > *arg2 = (btAlignedObjectArray< btRigidBodyDoubleData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btRigidBodyDoubleData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_rigidBodyDataDouble = *arg2; + +} + + +btAlignedObjectArray< btRigidBodyDoubleData * > *_wrap_btBulletSerializedArrays_m_rigidBodyDataDouble_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btRigidBodyDoubleData * > *result = 0 ; + btAlignedObjectArray< btRigidBodyDoubleData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btRigidBodyDoubleData * > *)& ((arg1)->m_rigidBodyDataDouble); + *(btAlignedObjectArray< btRigidBodyDoubleData * > **)&_swig_go_result = (btAlignedObjectArray< btRigidBodyDoubleData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_rigidBodyDataFloat_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btRigidBodyFloatData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btRigidBodyFloatData * > *arg2 = (btAlignedObjectArray< btRigidBodyFloatData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btRigidBodyFloatData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_rigidBodyDataFloat = *arg2; + +} + + +btAlignedObjectArray< btRigidBodyFloatData * > *_wrap_btBulletSerializedArrays_m_rigidBodyDataFloat_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btRigidBodyFloatData * > *result = 0 ; + btAlignedObjectArray< btRigidBodyFloatData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btRigidBodyFloatData * > *)& ((arg1)->m_rigidBodyDataFloat); + *(btAlignedObjectArray< btRigidBodyFloatData * > **)&_swig_go_result = (btAlignedObjectArray< btRigidBodyFloatData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_collisionObjectDataDouble_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btCollisionObjectDoubleData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btCollisionObjectDoubleData * > *arg2 = (btAlignedObjectArray< btCollisionObjectDoubleData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btCollisionObjectDoubleData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionObjectDataDouble = *arg2; + +} + + +btAlignedObjectArray< btCollisionObjectDoubleData * > *_wrap_btBulletSerializedArrays_m_collisionObjectDataDouble_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btCollisionObjectDoubleData * > *result = 0 ; + btAlignedObjectArray< btCollisionObjectDoubleData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btCollisionObjectDoubleData * > *)& ((arg1)->m_collisionObjectDataDouble); + *(btAlignedObjectArray< btCollisionObjectDoubleData * > **)&_swig_go_result = (btAlignedObjectArray< btCollisionObjectDoubleData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_collisionObjectDataFloat_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btCollisionObjectFloatData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btCollisionObjectFloatData * > *arg2 = (btAlignedObjectArray< btCollisionObjectFloatData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btCollisionObjectFloatData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionObjectDataFloat = *arg2; + +} + + +btAlignedObjectArray< btCollisionObjectFloatData * > *_wrap_btBulletSerializedArrays_m_collisionObjectDataFloat_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btCollisionObjectFloatData * > *result = 0 ; + btAlignedObjectArray< btCollisionObjectFloatData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btCollisionObjectFloatData * > *)& ((arg1)->m_collisionObjectDataFloat); + *(btAlignedObjectArray< btCollisionObjectFloatData * > **)&_swig_go_result = (btAlignedObjectArray< btCollisionObjectFloatData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_constraintDataFloat_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btTypedConstraintFloatData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btTypedConstraintFloatData * > *arg2 = (btAlignedObjectArray< btTypedConstraintFloatData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btTypedConstraintFloatData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_constraintDataFloat = *arg2; + +} + + +btAlignedObjectArray< btTypedConstraintFloatData * > *_wrap_btBulletSerializedArrays_m_constraintDataFloat_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btTypedConstraintFloatData * > *result = 0 ; + btAlignedObjectArray< btTypedConstraintFloatData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btTypedConstraintFloatData * > *)& ((arg1)->m_constraintDataFloat); + *(btAlignedObjectArray< btTypedConstraintFloatData * > **)&_swig_go_result = (btAlignedObjectArray< btTypedConstraintFloatData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_constraintDataDouble_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btTypedConstraintDoubleData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btTypedConstraintDoubleData * > *arg2 = (btAlignedObjectArray< btTypedConstraintDoubleData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btTypedConstraintDoubleData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_constraintDataDouble = *arg2; + +} + + +btAlignedObjectArray< btTypedConstraintDoubleData * > *_wrap_btBulletSerializedArrays_m_constraintDataDouble_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btTypedConstraintDoubleData * > *result = 0 ; + btAlignedObjectArray< btTypedConstraintDoubleData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btTypedConstraintDoubleData * > *)& ((arg1)->m_constraintDataDouble); + *(btAlignedObjectArray< btTypedConstraintDoubleData * > **)&_swig_go_result = (btAlignedObjectArray< btTypedConstraintDoubleData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_constraintData_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btTypedConstraintData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btTypedConstraintData * > *arg2 = (btAlignedObjectArray< btTypedConstraintData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btTypedConstraintData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_constraintData = *arg2; + +} + + +btAlignedObjectArray< btTypedConstraintData * > *_wrap_btBulletSerializedArrays_m_constraintData_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btTypedConstraintData * > *result = 0 ; + btAlignedObjectArray< btTypedConstraintData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btTypedConstraintData * > *)& ((arg1)->m_constraintData); + *(btAlignedObjectArray< btTypedConstraintData * > **)&_swig_go_result = (btAlignedObjectArray< btTypedConstraintData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_softBodyFloatData_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btSoftBodyFloatData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btSoftBodyFloatData * > *arg2 = (btAlignedObjectArray< btSoftBodyFloatData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btSoftBodyFloatData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_softBodyFloatData = *arg2; + +} + + +btAlignedObjectArray< btSoftBodyFloatData * > *_wrap_btBulletSerializedArrays_m_softBodyFloatData_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btSoftBodyFloatData * > *result = 0 ; + btAlignedObjectArray< btSoftBodyFloatData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btSoftBodyFloatData * > *)& ((arg1)->m_softBodyFloatData); + *(btAlignedObjectArray< btSoftBodyFloatData * > **)&_swig_go_result = (btAlignedObjectArray< btSoftBodyFloatData * > *)result; + return _swig_go_result; +} + + +void _wrap_btBulletSerializedArrays_m_softBodyDoubleData_set_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0, btAlignedObjectArray< btSoftBodyDoubleData * > *_swig_go_1) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btSoftBodyDoubleData * > *arg2 = (btAlignedObjectArray< btSoftBodyDoubleData * > *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btSoftBodyDoubleData * > **)&_swig_go_1; + + if (arg1) (arg1)->m_softBodyDoubleData = *arg2; + +} + + +btAlignedObjectArray< btSoftBodyDoubleData * > *_wrap_btBulletSerializedArrays_m_softBodyDoubleData_get_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + btAlignedObjectArray< btSoftBodyDoubleData * > *result = 0 ; + btAlignedObjectArray< btSoftBodyDoubleData * > *_swig_go_result; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + result = (btAlignedObjectArray< btSoftBodyDoubleData * > *)& ((arg1)->m_softBodyDoubleData); + *(btAlignedObjectArray< btSoftBodyDoubleData * > **)&_swig_go_result = (btAlignedObjectArray< btSoftBodyDoubleData * > *)result; + return _swig_go_result; +} + + +void _wrap_delete_btBulletSerializedArrays_mbt_e879218550ba2e2b(btBulletSerializedArrays *_swig_go_0) { + btBulletSerializedArrays *arg1 = (btBulletSerializedArrays *) 0 ; + + arg1 = *(btBulletSerializedArrays **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btDefaultSerializer_m_skipPointers_set_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, btHashMap< btHashPtr,void * > *_swig_go_1) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + btHashMap< btHashPtr,void * > *arg2 = (btHashMap< btHashPtr,void * > *) 0 ; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = *(btHashMap< btHashPtr,void * > **)&_swig_go_1; + + if (arg1) (arg1)->m_skipPointers = *arg2; + +} + + +btHashMap< btHashPtr,void * > *_wrap_btDefaultSerializer_m_skipPointers_get_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + btHashMap< btHashPtr,void * > *result = 0 ; + btHashMap< btHashPtr,void * > *_swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + + result = (btHashMap< btHashPtr,void * > *)& ((arg1)->m_skipPointers); + *(btHashMap< btHashPtr,void * > **)&_swig_go_result = (btHashMap< btHashPtr,void * > *)result; + return _swig_go_result; +} + + +btDefaultSerializer *_wrap_new_btDefaultSerializer__SWIG_0_mbt_e879218550ba2e2b(intgo _swig_go_0, char *_swig_go_1) { + int arg1 ; + unsigned char *arg2 = (unsigned char *) 0 ; + btDefaultSerializer *result = 0 ; + btDefaultSerializer *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = *(unsigned char **)&_swig_go_1; + + result = (btDefaultSerializer *)new btDefaultSerializer(arg1,arg2); + *(btDefaultSerializer **)&_swig_go_result = (btDefaultSerializer *)result; + return _swig_go_result; +} + + +btDefaultSerializer *_wrap_new_btDefaultSerializer__SWIG_1_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + btDefaultSerializer *result = 0 ; + btDefaultSerializer *_swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (btDefaultSerializer *)new btDefaultSerializer(arg1); + *(btDefaultSerializer **)&_swig_go_result = (btDefaultSerializer *)result; + return _swig_go_result; +} + + +btDefaultSerializer *_wrap_new_btDefaultSerializer__SWIG_2_mbt_e879218550ba2e2b() { + btDefaultSerializer *result = 0 ; + btDefaultSerializer *_swig_go_result; + + + result = (btDefaultSerializer *)new btDefaultSerializer(); + *(btDefaultSerializer **)&_swig_go_result = (btDefaultSerializer *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDefaultSerializer_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_btDefaultSerializer_getMemoryDnaSizeInBytes_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)btDefaultSerializer::getMemoryDnaSizeInBytes(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btDefaultSerializer_getMemoryDna_mbt_e879218550ba2e2b() { + char *result = 0 ; + _gostring_ _swig_go_result; + + + result = (char *)btDefaultSerializer::getMemoryDna(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btDefaultSerializer_insertHeader_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + + (arg1)->insertHeader(); + +} + + +void _wrap_btDefaultSerializer_writeHeader_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, char *_swig_go_1) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + unsigned char *arg2 = (unsigned char *) 0 ; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = *(unsigned char **)&_swig_go_1; + + ((btDefaultSerializer const *)arg1)->writeHeader(arg2); + +} + + +void _wrap_btDefaultSerializer_startSerialization_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + + (arg1)->startSerialization(); + +} + + +void _wrap_btDefaultSerializer_finishSerialization_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + + (arg1)->finishSerialization(); + +} + + +void *_wrap_btDefaultSerializer_getUniquePointer_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, void *_swig_go_1) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + void *arg2 = (void *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + result = (void *)(arg1)->getUniquePointer(arg2); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +char *_wrap_btDefaultSerializer_getBufferPointer_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + unsigned char *result = 0 ; + char *_swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + + result = (unsigned char *)((btDefaultSerializer const *)arg1)->getBufferPointer(); + *(unsigned char **)&_swig_go_result = (unsigned char *)result; + return _swig_go_result; +} + + +intgo _wrap_btDefaultSerializer_getCurrentBufferSize_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + + result = (int)((btDefaultSerializer const *)arg1)->getCurrentBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDefaultSerializer_finalizeChunk_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, btChunk *_swig_go_1, _gostring_ _swig_go_2, intgo _swig_go_3, void *_swig_go_4) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + btChunk *arg2 = (btChunk *) 0 ; + char *arg3 = (char *) 0 ; + int arg4 ; + void *arg5 = (void *) 0 ; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = *(btChunk **)&_swig_go_1; + + arg3 = (char *)malloc(_swig_go_2.n + 1); + memcpy(arg3, _swig_go_2.p, _swig_go_2.n); + arg3[_swig_go_2.n] = '\0'; + + arg4 = (int)_swig_go_3; + arg5 = *(void **)&_swig_go_4; + + (arg1)->finalizeChunk(arg2,(char const *)arg3,arg4,arg5); + + free(arg3); +} + + +char *_wrap_btDefaultSerializer_internalAlloc_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, long long _swig_go_1) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + size_t arg2 ; + unsigned char *result = 0 ; + char *_swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = (size_t)_swig_go_1; + + result = (unsigned char *)(arg1)->internalAlloc(arg2); + *(unsigned char **)&_swig_go_result = (unsigned char *)result; + return _swig_go_result; +} + + +btChunk *_wrap_btDefaultSerializer_allocate_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, long long _swig_go_1, intgo _swig_go_2) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + size_t arg2 ; + int arg3 ; + btChunk *result = 0 ; + btChunk *_swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = (size_t)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btChunk *)(arg1)->allocate(arg2,arg3); + *(btChunk **)&_swig_go_result = (btChunk *)result; + return _swig_go_result; +} + + +_gostring_ _wrap_btDefaultSerializer_findNameForPointer_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, void *_swig_go_1) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + void *arg2 = (void *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + result = (char *)((btDefaultSerializer const *)arg1)->findNameForPointer((void const *)arg2); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btDefaultSerializer_registerNameForPointer_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, void *_swig_go_1, _gostring_ _swig_go_2) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + void *arg2 = (void *) 0 ; + char *arg3 = (char *) 0 ; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + arg3 = (char *)malloc(_swig_go_2.n + 1); + memcpy(arg3, _swig_go_2.p, _swig_go_2.n); + arg3[_swig_go_2.n] = '\0'; + + + (arg1)->registerNameForPointer((void const *)arg2,(char const *)arg3); + + free(arg3); +} + + +void _wrap_btDefaultSerializer_serializeName_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, _gostring_ _swig_go_1) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + (arg1)->serializeName((char const *)arg2); + + free(arg2); +} + + +intgo _wrap_btDefaultSerializer_getSerializationFlags_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + + result = (int)((btDefaultSerializer const *)arg1)->getSerializationFlags(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDefaultSerializer_setSerializationFlags_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, intgo _swig_go_1) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + int arg2 ; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setSerializationFlags(arg2); + +} + + +intgo _wrap_btDefaultSerializer_getNumChunks_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + + result = (int)((btDefaultSerializer const *)arg1)->getNumChunks(); + _swig_go_result = result; + return _swig_go_result; +} + + +btChunk *_wrap_btDefaultSerializer_getChunk_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, intgo _swig_go_1) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + int arg2 ; + btChunk *result = 0 ; + btChunk *_swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btChunk *)((btDefaultSerializer const *)arg1)->getChunk(arg2); + *(btChunk **)&_swig_go_result = (btChunk *)result; + return _swig_go_result; +} + + +void *_wrap_btDefaultSerializer_findPointer_mbt_e879218550ba2e2b(btDefaultSerializer *_swig_go_0, void *_swig_go_1) { + btDefaultSerializer *arg1 = (btDefaultSerializer *) 0 ; + void *arg2 = (void *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btDefaultSerializer **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btSerializer *swig_b0 = (btSerializer *)arg1; + result = (void *)(swig_b0)->findPointer(arg2); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_uniqueId_set_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + + arg1 = (int)_swig_go_0; + + uniqueId = arg1; + +} + + +intgo _wrap_uniqueId_get_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)uniqueId; + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_evalEulerEqn_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3, btMatrix3x3 *_swig_go_4) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + btMatrix3x3 *arg5 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = *(btMatrix3x3 **)&_swig_go_4; + + result = evalEulerEqn((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,(btMatrix3x3 const &)*arg5); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btMatrix3x3 *_wrap_evalEulerEqnDeriv_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2, btMatrix3x3 *_swig_go_3) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + btMatrix3x3 *arg4 = 0 ; + btMatrix3x3 result; + btMatrix3x3 *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = *(btMatrix3x3 **)&_swig_go_3; + + result = evalEulerEqnDeriv((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,(btMatrix3x3 const &)*arg4); + *(btMatrix3x3 **)&_swig_go_result = new btMatrix3x3(result); + return _swig_go_result; +} + + +btDbvtAabbMm *_wrap_new_btDbvtAabbMm_mbt_e879218550ba2e2b() { + btDbvtAabbMm *result = 0 ; + btDbvtAabbMm *_swig_go_result; + + + result = (btDbvtAabbMm *)new btDbvtAabbMm(); + *(btDbvtAabbMm **)&_swig_go_result = (btDbvtAabbMm *)result; + return _swig_go_result; +} + + +btVector3 *_wrap_btDbvtAabbMm_Center_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + + result = ((btDbvtAabbMm const *)arg1)->Center(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btDbvtAabbMm_Lengths_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + + result = ((btDbvtAabbMm const *)arg1)->Lengths(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btDbvtAabbMm_Extents_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + + result = ((btDbvtAabbMm const *)arg1)->Extents(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btDbvtAabbMm_Mins_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + + result = (btVector3 *) &((btDbvtAabbMm const *)arg1)->Mins(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btDbvtAabbMm_Maxs_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + + result = (btVector3 *) &((btDbvtAabbMm const *)arg1)->Maxs(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btDbvtAabbMm *_wrap_btDbvtAabbMm_FromCE_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btDbvtAabbMm result; + btDbvtAabbMm *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = btDbvtAabbMm::FromCE((btVector3 const &)*arg1,(btVector3 const &)*arg2); + *(btDbvtAabbMm **)&_swig_go_result = new btDbvtAabbMm(result); + return _swig_go_result; +} + + +btDbvtAabbMm *_wrap_btDbvtAabbMm_FromCR_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float _swig_go_1) { + btVector3 *arg1 = 0 ; + btScalar arg2 ; + btDbvtAabbMm result; + btDbvtAabbMm *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = btDbvtAabbMm::FromCR((btVector3 const &)*arg1,arg2); + *(btDbvtAabbMm **)&_swig_go_result = new btDbvtAabbMm(result); + return _swig_go_result; +} + + +btDbvtAabbMm *_wrap_btDbvtAabbMm_FromMM_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btDbvtAabbMm result; + btDbvtAabbMm *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = btDbvtAabbMm::FromMM((btVector3 const &)*arg1,(btVector3 const &)*arg2); + *(btDbvtAabbMm **)&_swig_go_result = new btDbvtAabbMm(result); + return _swig_go_result; +} + + +btDbvtAabbMm *_wrap_btDbvtAabbMm_FromPoints__SWIG_0_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, intgo _swig_go_1) { + btVector3 *arg1 = (btVector3 *) 0 ; + int arg2 ; + btDbvtAabbMm result; + btDbvtAabbMm *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = btDbvtAabbMm::FromPoints((btVector3 const *)arg1,arg2); + *(btDbvtAabbMm **)&_swig_go_result = new btDbvtAabbMm(result); + return _swig_go_result; +} + + +btDbvtAabbMm *_wrap_btDbvtAabbMm_FromPoints__SWIG_1_mbt_e879218550ba2e2b(btVector3 **_swig_go_0, intgo _swig_go_1) { + btVector3 **arg1 = (btVector3 **) 0 ; + int arg2 ; + btDbvtAabbMm result; + btDbvtAabbMm *_swig_go_result; + + arg1 = *(btVector3 ***)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = btDbvtAabbMm::FromPoints((btVector3 const **)arg1,arg2); + *(btDbvtAabbMm **)&_swig_go_result = new btDbvtAabbMm(result); + return _swig_go_result; +} + + +void _wrap_btDbvtAabbMm_Expand_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btVector3 *_swig_go_1) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->Expand((btVector3 const &)*arg2); + +} + + +void _wrap_btDbvtAabbMm_SignedExpand_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btVector3 *_swig_go_1) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->SignedExpand((btVector3 const &)*arg2); + +} + + +bool _wrap_btDbvtAabbMm_Contain_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btDbvtAabbMm *_swig_go_1) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btDbvtAabbMm *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btDbvtAabbMm **)&_swig_go_1; + + result = (bool)((btDbvtAabbMm const *)arg1)->Contain((btDbvtAabbMm const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btDbvtAabbMm_Classify_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2, intgo _swig_go_3) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + int arg4 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + + result = (int)((btDbvtAabbMm const *)arg1)->Classify((btVector3 const &)*arg2,arg3,arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btDbvtAabbMm_ProjectMinimum_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 *arg2 = 0 ; + unsigned int arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (unsigned int)_swig_go_2; + + result = (btScalar)((btDbvtAabbMm const *)arg1)->ProjectMinimum((btVector3 const &)*arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_Intersect__SWIG_0_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btDbvtAabbMm *_swig_go_1) { + btDbvtAabbMm *arg1 = 0 ; + btDbvtAabbMm *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btDbvtAabbMm **)&_swig_go_1; + + result = (bool)Intersect((btDbvtAabbMm const &)*arg1,(btDbvtAabbMm const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_Intersect__SWIG_1_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btVector3 *_swig_go_1) { + btDbvtAabbMm *arg1 = 0 ; + btVector3 *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (bool)Intersect((btDbvtAabbMm const &)*arg1,(btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_Proximity_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btDbvtAabbMm *_swig_go_1) { + btDbvtAabbMm *arg1 = 0 ; + btDbvtAabbMm *arg2 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btDbvtAabbMm **)&_swig_go_1; + + result = (btScalar)Proximity((btDbvtAabbMm const &)*arg1,(btDbvtAabbMm const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_Select_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btDbvtAabbMm *_swig_go_1, btDbvtAabbMm *_swig_go_2) { + btDbvtAabbMm *arg1 = 0 ; + btDbvtAabbMm *arg2 = 0 ; + btDbvtAabbMm *arg3 = 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btDbvtAabbMm **)&_swig_go_1; + arg3 = *(btDbvtAabbMm **)&_swig_go_2; + + result = (int)Select((btDbvtAabbMm const &)*arg1,(btDbvtAabbMm const &)*arg2,(btDbvtAabbMm const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_Merge_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btDbvtAabbMm *_swig_go_1, btDbvtAabbMm *_swig_go_2) { + btDbvtAabbMm *arg1 = 0 ; + btDbvtAabbMm *arg2 = 0 ; + btDbvtAabbMm *arg3 = 0 ; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btDbvtAabbMm **)&_swig_go_1; + arg3 = *(btDbvtAabbMm **)&_swig_go_2; + + Merge((btDbvtAabbMm const &)*arg1,(btDbvtAabbMm const &)*arg2,*arg3); + +} + + +bool _wrap_NotEqual_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0, btDbvtAabbMm *_swig_go_1) { + btDbvtAabbMm *arg1 = 0 ; + btDbvtAabbMm *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + arg2 = *(btDbvtAabbMm **)&_swig_go_1; + + result = (bool)NotEqual((btDbvtAabbMm const &)*arg1,(btDbvtAabbMm const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btDbvtAabbMm_tMins_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + + result = (btVector3 *) &(arg1)->tMins(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btDbvtAabbMm_tMaxs_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + + result = (btVector3 *) &(arg1)->tMaxs(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btDbvtAabbMm_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0) { + btDbvtAabbMm *arg1 = (btDbvtAabbMm *) 0 ; + + arg1 = *(btDbvtAabbMm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btDbvtNode_volume_set_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btDbvtAabbMm *_swig_go_1) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btDbvtVolume *arg2 = (btDbvtVolume *) 0 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btDbvtVolume **)&_swig_go_1; + + if (arg1) (arg1)->volume = *arg2; + +} + + +btDbvtAabbMm *_wrap_btDbvtNode_volume_get_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btDbvtVolume *result = 0 ; + btDbvtAabbMm *_swig_go_result; + + arg1 = *(btDbvtNode **)&_swig_go_0; + + result = (btDbvtVolume *)& ((arg1)->volume); + *(btDbvtVolume **)&_swig_go_result = (btDbvtVolume *)result; + return _swig_go_result; +} + + +void _wrap_btDbvtNode_parent_set_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + if (arg1) (arg1)->parent = arg2; + +} + + +btDbvtNode *_wrap_btDbvtNode_parent_get_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvtNode **)&_swig_go_0; + + result = (btDbvtNode *) ((arg1)->parent); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +bool _wrap_btDbvtNode_isleaf_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvtNode **)&_swig_go_0; + + result = (bool)((btDbvtNode const *)arg1)->isleaf(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvtNode_isinternal_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvtNode **)&_swig_go_0; + + result = (bool)((btDbvtNode const *)arg1)->isinternal(); + _swig_go_result = result; + return _swig_go_result; +} + + +btDbvtNode *_wrap_new_btDbvtNode_mbt_e879218550ba2e2b() { + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + + result = (btDbvtNode *)new btDbvtNode(); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDbvtNode_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btDbvntNode_volume_set_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0, btDbvtAabbMm *_swig_go_1) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + btDbvtVolume *arg2 = (btDbvtVolume *) 0 ; + + arg1 = *(btDbvntNode **)&_swig_go_0; + arg2 = *(btDbvtVolume **)&_swig_go_1; + + if (arg1) (arg1)->volume = *arg2; + +} + + +btDbvtAabbMm *_wrap_btDbvntNode_volume_get_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + btDbvtVolume *result = 0 ; + btDbvtAabbMm *_swig_go_result; + + arg1 = *(btDbvntNode **)&_swig_go_0; + + result = (btDbvtVolume *)& ((arg1)->volume); + *(btDbvtVolume **)&_swig_go_result = (btDbvtVolume *)result; + return _swig_go_result; +} + + +void _wrap_btDbvntNode_normal_set_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0, btVector3 *_swig_go_1) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btDbvntNode **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->normal = *arg2; + +} + + +btVector3 *_wrap_btDbvntNode_normal_get_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btDbvntNode **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->normal); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btDbvntNode_angle_set_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0, float _swig_go_1) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + btScalar arg2 ; + + arg1 = *(btDbvntNode **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->angle = arg2; + +} + + +float _wrap_btDbvntNode_angle_get_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDbvntNode **)&_swig_go_0; + + result = (btScalar) ((arg1)->angle); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvntNode_isleaf_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvntNode **)&_swig_go_0; + + result = (bool)((btDbvntNode const *)arg1)->isleaf(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvntNode_isinternal_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvntNode **)&_swig_go_0; + + result = (bool)((btDbvntNode const *)arg1)->isinternal(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvntNode_childs_set_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0, btDbvntNode *(*_swig_go_1)[2]) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + btDbvntNode **arg2 = (btDbvntNode **) (btDbvntNode **)0 ; + + arg1 = *(btDbvntNode **)&_swig_go_0; + arg2 = *(btDbvntNode ***)&_swig_go_1; + + { + size_t ii; + btDbvntNode * *b = (btDbvntNode * *) arg1->childs; + for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((btDbvntNode * *) arg2 + ii); + } + +} + + +btDbvntNode *(*_wrap_btDbvntNode_childs_get_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0))[2] { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + btDbvntNode **result = 0 ; + btDbvntNode *(*_swig_go_result)[2]; + + arg1 = *(btDbvntNode **)&_swig_go_0; + + result = (btDbvntNode **)(btDbvntNode **) ((arg1)->childs); + *(btDbvntNode ***)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvntNode_data_set_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0, void *_swig_go_1) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btDbvntNode **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + if (arg1) (arg1)->data = arg2; + +} + + +void *_wrap_btDbvntNode_data_get_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btDbvntNode **)&_swig_go_0; + + result = (void *) ((arg1)->data); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +btDbvntNode *_wrap_new_btDbvntNode_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btDbvntNode *result = 0 ; + btDbvntNode *_swig_go_result; + + arg1 = *(btDbvtNode **)&_swig_go_0; + + result = (btDbvntNode *)new btDbvntNode((btDbvtNode const *)arg1); + *(btDbvntNode **)&_swig_go_result = (btDbvntNode *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDbvntNode_mbt_e879218550ba2e2b(btDbvntNode *_swig_go_0) { + btDbvntNode *arg1 = (btDbvntNode *) 0 ; + + arg1 = *(btDbvntNode **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_SIMPLE_STACKSIZE_btDbvt_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = btDbvt::SIMPLE_STACKSIZE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DOUBLE_STACKSIZE_btDbvt_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = btDbvt::DOUBLE_STACKSIZE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btDbvt_m_root_set_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + if (arg1) (arg1)->m_root = arg2; + +} + + +btDbvtNode *_wrap_btDbvt_m_root_get_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + + result = (btDbvtNode *) ((arg1)->m_root); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +void _wrap_btDbvt_m_free_set_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + if (arg1) (arg1)->m_free = arg2; + +} + + +btDbvtNode *_wrap_btDbvt_m_free_get_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + + result = (btDbvtNode *) ((arg1)->m_free); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +void _wrap_btDbvt_m_lkhd_set_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, intgo _swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + int arg2 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_lkhd = arg2; + +} + + +intgo _wrap_btDbvt_m_lkhd_get_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + + result = (int) ((arg1)->m_lkhd); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvt_m_leaves_set_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, intgo _swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + int arg2 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_leaves = arg2; + +} + + +intgo _wrap_btDbvt_m_leaves_get_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + + result = (int) ((arg1)->m_leaves); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvt_m_opath_set_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, intgo _swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + unsigned int arg2 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + + if (arg1) (arg1)->m_opath = arg2; + +} + + +intgo _wrap_btDbvt_m_opath_get_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + + result = (unsigned int) ((arg1)->m_opath); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvt_m_stkStack_set_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btAlignedObjectArray< btDbvt::sStkNN > *_swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + btAlignedObjectArray< btDbvt::sStkNN > *arg2 = (btAlignedObjectArray< btDbvt::sStkNN > *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btDbvt::sStkNN > **)&_swig_go_1; + + if (arg1) (arg1)->m_stkStack = *arg2; + +} + + +btAlignedObjectArray< btDbvt::sStkNN > *_wrap_btDbvt_m_stkStack_get_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + btAlignedObjectArray< btDbvt::sStkNN > *result = 0 ; + btAlignedObjectArray< btDbvt::sStkNN > *_swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + + result = (btAlignedObjectArray< btDbvt::sStkNN > *)& ((arg1)->m_stkStack); + *(btAlignedObjectArray< btDbvt::sStkNN > **)&_swig_go_result = (btAlignedObjectArray< btDbvt::sStkNN > *)result; + return _swig_go_result; +} + + +btDbvt *_wrap_new_btDbvt_mbt_e879218550ba2e2b() { + btDbvt *result = 0 ; + btDbvt *_swig_go_result; + + + result = (btDbvt *)new btDbvt(); + *(btDbvt **)&_swig_go_result = (btDbvt *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDbvt_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btDbvt_clear_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + + (arg1)->clear(); + +} + + +bool _wrap_btDbvt_empty_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + + result = (bool)((btDbvt const *)arg1)->empty(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvt_optimizeBottomUp_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + + (arg1)->optimizeBottomUp(); + +} + + +void _wrap_btDbvt_optimizeTopDown__SWIG_0_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, intgo _swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + int arg2 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->optimizeTopDown(arg2); + +} + + +void _wrap_btDbvt_optimizeTopDown__SWIG_1_mbt_e879218550ba2e2b(btDbvt *_swig_go_0) { + btDbvt *arg1 = (btDbvt *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + + (arg1)->optimizeTopDown(); + +} + + +void _wrap_btDbvt_optimizeIncremental_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, intgo _swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + int arg2 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->optimizeIncremental(arg2); + +} + + +btDbvtNode *_wrap_btDbvt_insert_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtAabbMm *_swig_go_1, void *_swig_go_2) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtVolume *arg2 = 0 ; + void *arg3 = (void *) 0 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtVolume **)&_swig_go_1; + arg3 = *(void **)&_swig_go_2; + + result = (btDbvtNode *)(arg1)->insert((btDbvtVolume const &)*arg2,arg3); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +void _wrap_btDbvt_update__SWIG_0_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, intgo _swig_go_2) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + int arg3 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->update(arg2,arg3); + +} + + +void _wrap_btDbvt_update__SWIG_1_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + (arg1)->update(arg2); + +} + + +void _wrap_btDbvt_update__SWIG_2_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtAabbMm *_swig_go_2) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtVolume *arg3 = 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtVolume **)&_swig_go_2; + + (arg1)->update(arg2,*arg3); + +} + + +bool _wrap_btDbvt_update__SWIG_3_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtAabbMm *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtVolume *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtVolume **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + + result = (bool)(arg1)->update(arg2,*arg3,(btVector3 const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvt_update__SWIG_4_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtAabbMm *_swig_go_2, btVector3 *_swig_go_3) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtVolume *arg3 = 0 ; + btVector3 *arg4 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtVolume **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = (bool)(arg1)->update(arg2,*arg3,(btVector3 const &)*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvt_update__SWIG_5_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtAabbMm *_swig_go_2, float _swig_go_3) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtVolume *arg3 = 0 ; + btScalar arg4 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtVolume **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + result = (bool)(arg1)->update(arg2,*arg3,arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvt_remove_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + (arg1)->remove(arg2); + +} + + +void _wrap_btDbvt_write_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvt::IWriter *_swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvt::IWriter *arg2 = (btDbvt::IWriter *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvt::IWriter **)&_swig_go_1; + + ((btDbvt const *)arg1)->write(arg2); + +} + + +void _wrap_btDbvt_clone__SWIG_0_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvt *_swig_go_1, btDbvt::IClone *_swig_go_2) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvt *arg2 = 0 ; + btDbvt::IClone *arg3 = (btDbvt::IClone *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvt **)&_swig_go_1; + arg3 = *(btDbvt::IClone **)&_swig_go_2; + + ((btDbvt const *)arg1)->clone(*arg2,arg3); + +} + + +void _wrap_btDbvt_clone__SWIG_1_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvt *_swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvt *arg2 = 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvt **)&_swig_go_1; + + ((btDbvt const *)arg1)->clone(*arg2); + +} + + +intgo _wrap_btDbvt_maxdepth_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtNode **)&_swig_go_0; + + result = (int)btDbvt::maxdepth((btDbvtNode const *)arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btDbvt_countLeaves_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtNode **)&_swig_go_0; + + result = (int)btDbvt::countLeaves((btDbvtNode const *)arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvt_extractLeaves_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btAlignedObjectArray< btDbvtNode const * > *_swig_go_1) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btAlignedObjectArray< btDbvtNode const * > *arg2 = 0 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btDbvtNode const * > **)&_swig_go_1; + + btDbvt::extractLeaves((btDbvtNode const *)arg1,*arg2); + +} + + +void _wrap_btDbvt_benchmark_mbt_e879218550ba2e2b() { + btDbvt::benchmark(); + +} + + +void _wrap_btDbvt_enumNodes_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btDbvt::ICollide *_swig_go_1) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btDbvt::ICollide *arg2 = 0 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btDbvt::ICollide **)&_swig_go_1; + + btDbvt::enumNodes((btDbvtNode const *)arg1,*arg2); + +} + + +void _wrap_btDbvt_enumLeaves_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btDbvt::ICollide *_swig_go_1) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btDbvt::ICollide *arg2 = 0 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btDbvt::ICollide **)&_swig_go_1; + + btDbvt::enumLeaves((btDbvtNode const *)arg1,*arg2); + +} + + +void _wrap_btDbvt_collideTT_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtNode *_swig_go_2, btDbvt::ICollide *_swig_go_3) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtNode *arg3 = (btDbvtNode *) 0 ; + btDbvt::ICollide *arg4 = 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtNode **)&_swig_go_2; + arg4 = *(btDbvt::ICollide **)&_swig_go_3; + + (arg1)->collideTT((btDbvtNode const *)arg2,(btDbvtNode const *)arg3,*arg4); + +} + + +void _wrap_btDbvt_selfCollideT_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvntNode *_swig_go_1, btDbvt::ICollide *_swig_go_2) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvntNode *arg2 = (btDbvntNode *) 0 ; + btDbvt::ICollide *arg3 = 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvntNode **)&_swig_go_1; + arg3 = *(btDbvt::ICollide **)&_swig_go_2; + + (arg1)->selfCollideT((btDbvntNode const *)arg2,*arg3); + +} + + +void _wrap_btDbvt_selfCollideTT_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvt::ICollide *_swig_go_2) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvt::ICollide *arg3 = 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvt::ICollide **)&_swig_go_2; + + (arg1)->selfCollideTT((btDbvtNode const *)arg2,*arg3); + +} + + +void _wrap_btDbvt_collideTTpersistentStack_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtNode *_swig_go_2, btDbvt::ICollide *_swig_go_3) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtNode *arg3 = (btDbvtNode *) 0 ; + btDbvt::ICollide *arg4 = 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtNode **)&_swig_go_2; + arg4 = *(btDbvt::ICollide **)&_swig_go_3; + + (arg1)->collideTTpersistentStack((btDbvtNode const *)arg2,(btDbvtNode const *)arg3,*arg4); + +} + + +void _wrap_btDbvt_collideTV_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtAabbMm *_swig_go_2, btDbvt::ICollide *_swig_go_3) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtVolume *arg3 = 0 ; + btDbvt::ICollide *arg4 = 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtVolume **)&_swig_go_2; + arg4 = *(btDbvt::ICollide **)&_swig_go_3; + + ((btDbvt const *)arg1)->collideTV((btDbvtNode const *)arg2,(btDbvtVolume const &)*arg3,*arg4); + +} + + +void _wrap_btDbvt_collideTVNoStackAlloc_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtAabbMm *_swig_go_2, btAlignedObjectArray< btDbvtNode const * > *_swig_go_3, btDbvt::ICollide *_swig_go_4) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtVolume *arg3 = 0 ; + btNodeStack *arg4 = 0 ; + btDbvt::ICollide *arg5 = 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtVolume **)&_swig_go_2; + arg4 = *(btNodeStack **)&_swig_go_3; + arg5 = *(btDbvt::ICollide **)&_swig_go_4; + + ((btDbvt const *)arg1)->collideTVNoStackAlloc((btDbvtNode const *)arg2,(btDbvtVolume const &)*arg3,*arg4,*arg5); + +} + + +void _wrap_btDbvt_rayTest_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btDbvt::ICollide *_swig_go_3) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btDbvt::ICollide *arg4 = 0 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btDbvt::ICollide **)&_swig_go_3; + + btDbvt::rayTest((btDbvtNode const *)arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); + +} + + +void _wrap_btDbvt_rayTestInternal_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, intgo *_swig_go_5, float _swig_go_6, btVector3 *_swig_go_7, btVector3 *_swig_go_8, btAlignedObjectArray< btDbvtNode const * > *_swig_go_9, btDbvt::ICollide *_swig_go_10) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + unsigned int *arg6 = (unsigned int *) (unsigned int *)0 ; + btScalar arg7 ; + btVector3 *arg8 = 0 ; + btVector3 *arg9 = 0 ; + btAlignedObjectArray< btDbvtNode const * > *arg10 = 0 ; + btDbvt::ICollide *arg11 = 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(unsigned int **)&_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = *(btVector3 **)&_swig_go_8; + arg10 = *(btAlignedObjectArray< btDbvtNode const * > **)&_swig_go_9; + arg11 = *(btDbvt::ICollide **)&_swig_go_10; + + ((btDbvt const *)arg1)->rayTestInternal((btDbvtNode const *)arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,arg6,arg7,(btVector3 const &)*arg8,(btVector3 const &)*arg9,*arg10,*arg11); + +} + + +void _wrap_btDbvt_collideKDOP_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2, intgo _swig_go_3, btDbvt::ICollide *_swig_go_4) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btScalar *arg3 = (btScalar *) 0 ; + int arg4 ; + btDbvt::ICollide *arg5 = 0 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btDbvt::ICollide **)&_swig_go_4; + + btDbvt::collideKDOP((btDbvtNode const *)arg1,(btVector3 const *)arg2,(float const *)arg3,arg4,*arg5); + +} + + +void _wrap_btDbvt_collideOCL__SWIG_0_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2, btVector3 *_swig_go_3, intgo _swig_go_4, btDbvt::ICollide *_swig_go_5, bool _swig_go_6) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btScalar *arg3 = (btScalar *) 0 ; + btVector3 *arg4 = 0 ; + int arg5 ; + btDbvt::ICollide *arg6 = 0 ; + bool arg7 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (int)_swig_go_4; + arg6 = *(btDbvt::ICollide **)&_swig_go_5; + arg7 = (bool)_swig_go_6; + + btDbvt::collideOCL((btDbvtNode const *)arg1,(btVector3 const *)arg2,(float const *)arg3,(btVector3 const &)*arg4,arg5,*arg6,arg7); + +} + + +void _wrap_btDbvt_collideOCL__SWIG_1_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2, btVector3 *_swig_go_3, intgo _swig_go_4, btDbvt::ICollide *_swig_go_5) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btScalar *arg3 = (btScalar *) 0 ; + btVector3 *arg4 = 0 ; + int arg5 ; + btDbvt::ICollide *arg6 = 0 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (int)_swig_go_4; + arg6 = *(btDbvt::ICollide **)&_swig_go_5; + + btDbvt::collideOCL((btDbvtNode const *)arg1,(btVector3 const *)arg2,(float const *)arg3,(btVector3 const &)*arg4,arg5,*arg6); + +} + + +void _wrap_btDbvt_collideTU_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btDbvt::ICollide *_swig_go_1) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btDbvt::ICollide *arg2 = 0 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btDbvt::ICollide **)&_swig_go_1; + + btDbvt::collideTU((btDbvtNode const *)arg1,*arg2); + +} + + +intgo _wrap_btDbvt_nearest_mbt_e879218550ba2e2b(intgo *_swig_go_0, btDbvt::sStkNPS *_swig_go_1, float _swig_go_2, intgo _swig_go_3, intgo _swig_go_4) { + int *arg1 = (int *) 0 ; + btDbvt::sStkNPS *arg2 = (btDbvt::sStkNPS *) 0 ; + btScalar arg3 ; + int arg4 ; + int arg5 ; + int result; + intgo _swig_go_result; + + arg1 = *(int **)&_swig_go_0; + arg2 = *(btDbvt::sStkNPS **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (int)_swig_go_4; + + result = (int)btDbvt::nearest((int const *)arg1,(btDbvt::sStkNPS const *)arg2,arg3,arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btDbvt_allocate_mbt_e879218550ba2e2b(btAlignedObjectArray< int > *_swig_go_0, btAlignedObjectArray< btDbvt::sStkNPS > *_swig_go_1, btDbvt::sStkNPS *_swig_go_2) { + btAlignedObjectArray< int > *arg1 = 0 ; + btAlignedObjectArray< btDbvt::sStkNPS > *arg2 = 0 ; + btDbvt::sStkNPS *arg3 = 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btAlignedObjectArray< int > **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btDbvt::sStkNPS > **)&_swig_go_1; + arg3 = *(btDbvt::sStkNPS **)&_swig_go_2; + + result = (int)btDbvt::allocate(*arg1,*arg2,(btDbvt::sStkNPS const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtNodeEnumerator_nodes_set_mbt_e879218550ba2e2b(btDbvtNodeEnumerator *_swig_go_0, btAlignedObjectArray< btDbvtNode const * > *_swig_go_1) { + btDbvtNodeEnumerator *arg1 = (btDbvtNodeEnumerator *) 0 ; + tConstNodeArray *arg2 = (tConstNodeArray *) 0 ; + + arg1 = *(btDbvtNodeEnumerator **)&_swig_go_0; + arg2 = *(tConstNodeArray **)&_swig_go_1; + + if (arg1) (arg1)->nodes = *arg2; + +} + + +btAlignedObjectArray< btDbvtNode const * > *_wrap_btDbvtNodeEnumerator_nodes_get_mbt_e879218550ba2e2b(btDbvtNodeEnumerator *_swig_go_0) { + btDbvtNodeEnumerator *arg1 = (btDbvtNodeEnumerator *) 0 ; + tConstNodeArray *result = 0 ; + btAlignedObjectArray< btDbvtNode const * > *_swig_go_result; + + arg1 = *(btDbvtNodeEnumerator **)&_swig_go_0; + + result = (tConstNodeArray *)& ((arg1)->nodes); + *(tConstNodeArray **)&_swig_go_result = (tConstNodeArray *)result; + return _swig_go_result; +} + + +void _wrap_btDbvtNodeEnumerator_Process_mbt_e879218550ba2e2b(btDbvtNodeEnumerator *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvtNodeEnumerator *arg1 = (btDbvtNodeEnumerator *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvtNodeEnumerator **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + (arg1)->Process((btDbvtNode const *)arg2); + +} + + +btDbvtNodeEnumerator *_wrap_new_btDbvtNodeEnumerator_mbt_e879218550ba2e2b() { + btDbvtNodeEnumerator *result = 0 ; + btDbvtNodeEnumerator *_swig_go_result; + + + result = (btDbvtNodeEnumerator *)new btDbvtNodeEnumerator(); + *(btDbvtNodeEnumerator **)&_swig_go_result = (btDbvtNodeEnumerator *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDbvtNodeEnumerator_mbt_e879218550ba2e2b(btDbvtNodeEnumerator *_swig_go_0) { + btDbvtNodeEnumerator *arg1 = (btDbvtNodeEnumerator *) 0 ; + + arg1 = *(btDbvtNodeEnumerator **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_indexof_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtNode **)&_swig_go_0; + + result = (int)indexof((btDbvtNode const *)arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_size_mbt_e879218550ba2e2b(btDbvtAabbMm *_swig_go_0) { + btDbvtVolume *arg1 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDbvtVolume **)&_swig_go_0; + + result = (btScalar)size((btDbvtAabbMm const &)*arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_getmaxdepth_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, intgo _swig_go_1, intgo *_swig_go_2) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + int arg2 ; + int *arg3 = 0 ; + int e3 ; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + e3 = (int)*_swig_go_2; + arg3 = &e3; + + + getmaxdepth((btDbvtNode const *)arg1,arg2,*arg3); + + *_swig_go_2 = (intgo)e3; +} + + +void _wrap_deletenode_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + deletenode(arg1,arg2); + +} + + +void _wrap_recursedeletenode_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + recursedeletenode(arg1,arg2); + +} + + +btDbvtNode *_wrap_createnode__SWIG_0_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, void *_swig_go_2) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + void *arg3 = (void *) 0 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(void **)&_swig_go_2; + + result = (btDbvtNode *)createnode(arg1,arg2,arg3); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +btDbvtNode *_wrap_createnode__SWIG_1_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtAabbMm *_swig_go_2, void *_swig_go_3) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtVolume *arg3 = 0 ; + void *arg4 = (void *) 0 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtVolume **)&_swig_go_2; + arg4 = *(void **)&_swig_go_3; + + result = (btDbvtNode *)createnode(arg1,arg2,(btDbvtAabbMm const &)*arg3,arg4); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +btDbvtNode *_wrap_createnode__SWIG_2_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtAabbMm *_swig_go_2, btDbvtAabbMm *_swig_go_3, void *_swig_go_4) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtVolume *arg3 = 0 ; + btDbvtVolume *arg4 = 0 ; + void *arg5 = (void *) 0 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtVolume **)&_swig_go_2; + arg4 = *(btDbvtVolume **)&_swig_go_3; + arg5 = *(void **)&_swig_go_4; + + result = (btDbvtNode *)createnode(arg1,arg2,(btDbvtAabbMm const &)*arg3,(btDbvtAabbMm const &)*arg4,arg5); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +void _wrap_insertleaf_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtNode *_swig_go_2) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtNode *arg3 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtNode **)&_swig_go_2; + + insertleaf(arg1,arg2,arg3); + +} + + +btDbvtNode *_wrap_removeleaf_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + result = (btDbvtNode *)removeleaf(arg1,arg2); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +void _wrap_fetchleaves__SWIG_0_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btAlignedObjectArray< btDbvtNode * > *_swig_go_2, intgo _swig_go_3) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + tNodeArray *arg3 = 0 ; + int arg4 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(tNodeArray **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + fetchleaves(arg1,arg2,*arg3,arg4); + +} + + +void _wrap_fetchleaves__SWIG_1_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode *_swig_go_1, btAlignedObjectArray< btDbvtNode * > *_swig_go_2) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + tNodeArray *arg3 = 0 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(tNodeArray **)&_swig_go_2; + + fetchleaves(arg1,arg2,*arg3); + +} + + +bool _wrap_leftOfAxis_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (bool)leftOfAxis((btDbvtNode const *)arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_split_mbt_e879218550ba2e2b(btDbvtNode **_swig_go_0, intgo _swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btDbvtNode **arg1 = (btDbvtNode **) 0 ; + int arg2 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtNode ***)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = (int)split(arg1,arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +btDbvtAabbMm *_wrap_bounds_mbt_e879218550ba2e2b(btDbvtNode **_swig_go_0, intgo _swig_go_1) { + btDbvtNode **arg1 = (btDbvtNode **) 0 ; + int arg2 ; + btDbvtVolume result; + btDbvtAabbMm *_swig_go_result; + + arg1 = *(btDbvtNode ***)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = bounds(arg1,arg2); + *(btDbvtVolume **)&_swig_go_result = new btDbvtVolume(result); + return _swig_go_result; +} + + +void _wrap_bottomup_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode **_swig_go_1, intgo _swig_go_2) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode **arg2 = (btDbvtNode **) 0 ; + int arg3 ; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode ***)&_swig_go_1; + arg3 = (int)_swig_go_2; + + bottomup(arg1,arg2,arg3); + +} + + +btDbvtNode *_wrap_topdown_mbt_e879218550ba2e2b(btDbvt *_swig_go_0, btDbvtNode **_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btDbvt *arg1 = (btDbvt *) 0 ; + btDbvtNode **arg2 = (btDbvtNode **) 0 ; + int arg3 ; + int arg4 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvt **)&_swig_go_0; + arg2 = *(btDbvtNode ***)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + result = (btDbvtNode *)topdown(arg1,arg2,arg3,arg4); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +btDbvtNode *_wrap_sort_mbt_e879218550ba2e2b(btDbvtNode *_swig_go_0, btDbvtNode **_swig_go_1) { + btDbvtNode *arg1 = (btDbvtNode *) 0 ; + btDbvtNode **arg2 = 0 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvtNode **)&_swig_go_0; + arg2 = *(btDbvtNode ***)&_swig_go_1; + + result = (btDbvtNode *)sort(arg1,*arg2); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +void _wrap_delete_btBroadphaseAabbCallback_mbt_e879218550ba2e2b(btBroadphaseAabbCallback *_swig_go_0) { + btBroadphaseAabbCallback *arg1 = (btBroadphaseAabbCallback *) 0 ; + + arg1 = *(btBroadphaseAabbCallback **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btBroadphaseAabbCallback_process_mbt_e879218550ba2e2b(btBroadphaseAabbCallback *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btBroadphaseAabbCallback *arg1 = (btBroadphaseAabbCallback *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBroadphaseAabbCallback **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + result = (bool)(arg1)->process((btBroadphaseProxy const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseRayCallback_m_rayDirectionInverse_set_mbt_e879218550ba2e2b(btBroadphaseRayCallback *_swig_go_0, btVector3 *_swig_go_1) { + btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btBroadphaseRayCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_rayDirectionInverse = *arg2; + +} + + +btVector3 *_wrap_btBroadphaseRayCallback_m_rayDirectionInverse_get_mbt_e879218550ba2e2b(btBroadphaseRayCallback *_swig_go_0) { + btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btBroadphaseRayCallback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_rayDirectionInverse); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseRayCallback_m_signs_set_mbt_e879218550ba2e2b(btBroadphaseRayCallback *_swig_go_0, intgo *_swig_go_1) { + btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; + unsigned int *arg2 = (unsigned int *) (unsigned int *)0 ; + + arg1 = *(btBroadphaseRayCallback **)&_swig_go_0; + arg2 = *(unsigned int **)&_swig_go_1; + + { + size_t ii; + unsigned int *b = (unsigned int *) arg1->m_signs; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned int *) arg2 + ii); + } + +} + + +intgo *_wrap_btBroadphaseRayCallback_m_signs_get_mbt_e879218550ba2e2b(btBroadphaseRayCallback *_swig_go_0) { + btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; + unsigned int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btBroadphaseRayCallback **)&_swig_go_0; + + result = (unsigned int *)(unsigned int *) ((arg1)->m_signs); + *(unsigned int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseRayCallback_m_lambda_max_set_mbt_e879218550ba2e2b(btBroadphaseRayCallback *_swig_go_0, float _swig_go_1) { + btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; + btScalar arg2 ; + + arg1 = *(btBroadphaseRayCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_lambda_max = arg2; + +} + + +float _wrap_btBroadphaseRayCallback_m_lambda_max_get_mbt_e879218550ba2e2b(btBroadphaseRayCallback *_swig_go_0) { + btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBroadphaseRayCallback **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_lambda_max); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btBroadphaseRayCallback_mbt_e879218550ba2e2b(btBroadphaseRayCallback *_swig_go_0) { + btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; + + arg1 = *(btBroadphaseRayCallback **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btBroadphaseRayCallback_process_mbt_e879218550ba2e2b(btBroadphaseRayCallback *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBroadphaseRayCallback **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + btBroadphaseAabbCallback *swig_b0 = (btBroadphaseAabbCallback *)arg1; + result = (bool)(swig_b0)->process((btBroadphaseProxy const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btBroadphaseInterface_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + + delete arg1; + +} + + +btBroadphaseProxy *_wrap_btBroadphaseInterface_createProxy_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3, void *_swig_go_4, intgo _swig_go_5, intgo _swig_go_6, btDispatcher *_swig_go_7) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + int arg4 ; + void *arg5 = (void *) 0 ; + int arg6 ; + int arg7 ; + btDispatcher *arg8 = (btDispatcher *) 0 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(void **)&_swig_go_4; + arg6 = (int)_swig_go_5; + arg7 = (int)_swig_go_6; + arg8 = *(btDispatcher **)&_swig_go_7; + + result = (btBroadphaseProxy *)(arg1)->createProxy((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5,arg6,arg7,arg8); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseInterface_destroyProxy_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->destroyProxy(arg2,arg3); + +} + + +void _wrap_btBroadphaseInterface_setAabb_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btBroadphaseProxy *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btDispatcher *_swig_go_4) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btDispatcher *arg5 = (btDispatcher *) 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btDispatcher **)&_swig_go_4; + + (arg1)->setAabb(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5); + +} + + +void _wrap_btBroadphaseInterface_getAabb_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btBroadphaseProxy *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btBroadphaseInterface const *)arg1)->getAabb(arg2,*arg3,*arg4); + +} + + +void _wrap_btBroadphaseInterface_rayTest__SWIG_0_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btBroadphaseRayCallback *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btBroadphaseRayCallback *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btBroadphaseRayCallback **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btBroadphaseInterface_rayTest__SWIG_1_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btBroadphaseRayCallback *_swig_go_3, btVector3 *_swig_go_4) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btBroadphaseRayCallback *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btBroadphaseRayCallback **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5); + +} + + +void _wrap_btBroadphaseInterface_rayTest__SWIG_2_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btBroadphaseRayCallback *_swig_go_3) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btBroadphaseRayCallback *arg4 = 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btBroadphaseRayCallback **)&_swig_go_3; + + (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); + +} + + +void _wrap_btBroadphaseInterface_aabbTest_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btBroadphaseAabbCallback *_swig_go_3) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btBroadphaseAabbCallback *arg4 = 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btBroadphaseAabbCallback **)&_swig_go_3; + + (arg1)->aabbTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); + +} + + +void _wrap_btBroadphaseInterface_calculateOverlappingPairs_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btDispatcher *_swig_go_1) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + (arg1)->calculateOverlappingPairs(arg2); + +} + + +btOverlappingPairCache *_wrap_btBroadphaseInterface_getOverlappingPairCache__SWIG_0_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btOverlappingPairCache *result = 0 ; + btOverlappingPairCache *_swig_go_result; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + + result = (btOverlappingPairCache *)(arg1)->getOverlappingPairCache(); + *(btOverlappingPairCache **)&_swig_go_result = (btOverlappingPairCache *)result; + return _swig_go_result; +} + + +btOverlappingPairCache *_wrap_btBroadphaseInterface_getOverlappingPairCache__SWIG_1_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btOverlappingPairCache *result = 0 ; + btOverlappingPairCache *_swig_go_result; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + + result = (btOverlappingPairCache *)((btBroadphaseInterface const *)arg1)->getOverlappingPairCache(); + *(btOverlappingPairCache **)&_swig_go_result = (btOverlappingPairCache *)result; + return _swig_go_result; +} + + +void _wrap_btBroadphaseInterface_getBroadphaseAabb_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btBroadphaseInterface const *)arg1)->getBroadphaseAabb(*arg2,*arg3); + +} + + +void _wrap_btBroadphaseInterface_resetPool_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0, btDispatcher *_swig_go_1) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + (arg1)->resetPool(arg2); + +} + + +void _wrap_btBroadphaseInterface_printStats_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + + (arg1)->printStats(); + +} + + +void _wrap_delete_btOverlappingPairCallback_mbt_e879218550ba2e2b(btOverlappingPairCallback *_swig_go_0) { + btOverlappingPairCallback *arg1 = (btOverlappingPairCallback *) 0 ; + + arg1 = *(btOverlappingPairCallback **)&_swig_go_0; + + delete arg1; + +} + + +btBroadphasePair *_wrap_btOverlappingPairCallback_addOverlappingPair_mbt_e879218550ba2e2b(btOverlappingPairCallback *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btOverlappingPairCallback *arg1 = (btOverlappingPairCallback *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btOverlappingPairCallback **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (btBroadphasePair *)(arg1)->addOverlappingPair(arg2,arg3); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +void *_wrap_btOverlappingPairCallback_removeOverlappingPair_mbt_e879218550ba2e2b(btOverlappingPairCallback *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2, btDispatcher *_swig_go_3) { + btOverlappingPairCallback *arg1 = (btOverlappingPairCallback *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg4 = (btDispatcher *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btOverlappingPairCallback **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + arg4 = *(btDispatcher **)&_swig_go_3; + + result = (void *)(arg1)->removeOverlappingPair(arg2,arg3,arg4); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btOverlappingPairCallback_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(btOverlappingPairCallback *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btOverlappingPairCallback *arg1 = (btOverlappingPairCallback *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btOverlappingPairCallback **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->removeOverlappingPairsContainingProxy(arg2,arg3); + +} + + +void _wrap_delete_btOverlapCallback_mbt_e879218550ba2e2b(btOverlapCallback *_swig_go_0) { + btOverlapCallback *arg1 = (btOverlapCallback *) 0 ; + + arg1 = *(btOverlapCallback **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btOverlapCallback_processOverlap_mbt_e879218550ba2e2b(btOverlapCallback *_swig_go_0, btBroadphasePair *_swig_go_1) { + btOverlapCallback *arg1 = (btOverlapCallback *) 0 ; + btBroadphasePair *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btOverlapCallback **)&_swig_go_0; + arg2 = *(btBroadphasePair **)&_swig_go_1; + + result = (bool)(arg1)->processOverlap(*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btOverlapFilterCallback_mbt_e879218550ba2e2b(btOverlapFilterCallback *_swig_go_0) { + btOverlapFilterCallback *arg1 = (btOverlapFilterCallback *) 0 ; + + arg1 = *(btOverlapFilterCallback **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btOverlapFilterCallback_needBroadphaseCollision_mbt_e879218550ba2e2b(btOverlapFilterCallback *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btOverlapFilterCallback *arg1 = (btOverlapFilterCallback *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btOverlapFilterCallback **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (bool)((btOverlapFilterCallback const *)arg1)->needBroadphaseCollision(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_BT_NULL_PAIR_get_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)(int)BT_NULL_PAIR; + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btOverlappingPairCache_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + + delete arg1; + +} + + +btBroadphasePair *_wrap_btOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePair *)(arg1)->getOverlappingPairArrayPtr(); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +btBroadphasePair *_wrap_btOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePair *)((btOverlappingPairCache const *)arg1)->getOverlappingPairArrayPtr(); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +btAlignedObjectArray< btBroadphasePair > *_wrap_btOverlappingPairCache_getOverlappingPairArray_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btBroadphasePairArray *result = 0 ; + btAlignedObjectArray< btBroadphasePair > *_swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePairArray *) &(arg1)->getOverlappingPairArray(); + *(btBroadphasePairArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOverlappingPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btBroadphasePair *_swig_go_1, btDispatcher *_swig_go_2) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btBroadphasePair *arg2 = 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphasePair **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->cleanOverlappingPair(*arg2,arg3); + +} + + +intgo _wrap_btOverlappingPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + + result = (int)((btOverlappingPairCache const *)arg1)->getNumOverlappingPairs(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btOverlappingPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (bool)((btOverlappingPairCache const *)arg1)->needsBroadphaseCollision(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +btOverlapFilterCallback *_wrap_btOverlappingPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btOverlapFilterCallback *result = 0 ; + btOverlapFilterCallback *_swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + + result = (btOverlapFilterCallback *)(arg1)->getOverlapFilterCallback(); + *(btOverlapFilterCallback **)&_swig_go_result = (btOverlapFilterCallback *)result; + return _swig_go_result; +} + + +void _wrap_btOverlappingPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->cleanProxyFromPairs(arg2,arg3); + +} + + +void _wrap_btOverlappingPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btOverlapFilterCallback *_swig_go_1) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btOverlapFilterCallback *arg2 = (btOverlapFilterCallback *) 0 ; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlapFilterCallback **)&_swig_go_1; + + (arg1)->setOverlapFilterCallback(arg2); + +} + + +void _wrap_btOverlappingPairCache_processAllOverlappingPairs__SWIG_0_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btOverlapCallback *_swig_go_1, btDispatcher *_swig_go_2) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btOverlapCallback *arg2 = (btOverlapCallback *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlapCallback **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->processAllOverlappingPairs(arg2,arg3); + +} + + +void _wrap_btOverlappingPairCache_processAllOverlappingPairs__SWIG_1_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btOverlapCallback *_swig_go_1, btDispatcher *_swig_go_2, btDispatcherInfo *_swig_go_3) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btOverlapCallback *arg2 = (btOverlapCallback *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + btDispatcherInfo *arg4 = 0 ; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlapCallback **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + + (arg1)->processAllOverlappingPairs(arg2,arg3,(btDispatcherInfo const &)*arg4); + +} + + +btBroadphasePair *_wrap_btOverlappingPairCache_findPair_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (btBroadphasePair *)(arg1)->findPair(arg2,arg3); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +bool _wrap_btOverlappingPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + + result = (bool)(arg1)->hasDeferredRemoval(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOverlappingPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btOverlappingPairCallback *_swig_go_1) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btOverlappingPairCallback *arg2 = (btOverlappingPairCallback *) 0 ; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlappingPairCallback **)&_swig_go_1; + + (arg1)->setInternalGhostPairCallback(arg2); + +} + + +void _wrap_btOverlappingPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btDispatcher *_swig_go_1) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + (arg1)->sortOverlappingPairs(arg2); + +} + + +btBroadphasePair *_wrap_btOverlappingPairCache_addOverlappingPair_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + btOverlappingPairCallback *swig_b0 = (btOverlappingPairCallback *)arg1; + result = (btBroadphasePair *)(swig_b0)->addOverlappingPair(arg2,arg3); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +void *_wrap_btOverlappingPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2, btDispatcher *_swig_go_3) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg4 = (btDispatcher *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + arg4 = *(btDispatcher **)&_swig_go_3; + + btOverlappingPairCallback *swig_b0 = (btOverlappingPairCallback *)arg1; + result = (void *)(swig_b0)->removeOverlappingPair(arg2,arg3,arg4); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btOverlappingPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + btOverlappingPairCallback *swig_b0 = (btOverlappingPairCallback *)arg1; + (swig_b0)->removeOverlappingPairsContainingProxy(arg2,arg3); + +} + + +btHashedOverlappingPairCache *_wrap_new_btHashedOverlappingPairCache_mbt_e879218550ba2e2b() { + btHashedOverlappingPairCache *result = 0 ; + btHashedOverlappingPairCache *_swig_go_result; + + + result = (btHashedOverlappingPairCache *)new btHashedOverlappingPairCache(); + *(btHashedOverlappingPairCache **)&_swig_go_result = (btHashedOverlappingPairCache *)result; + return _swig_go_result; +} + + +void _wrap_delete_btHashedOverlappingPairCache_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btHashedOverlappingPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->removeOverlappingPairsContainingProxy(arg2,arg3); + +} + + +void *_wrap_btHashedOverlappingPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2, btDispatcher *_swig_go_3) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg4 = (btDispatcher *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + arg4 = *(btDispatcher **)&_swig_go_3; + + result = (void *)(arg1)->removeOverlappingPair(arg2,arg3,arg4); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +bool _wrap_btHashedOverlappingPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (bool)((btHashedOverlappingPairCache const *)arg1)->needsBroadphaseCollision(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +btBroadphasePair *_wrap_btHashedOverlappingPairCache_addOverlappingPair_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (btBroadphasePair *)(arg1)->addOverlappingPair(arg2,arg3); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +void _wrap_btHashedOverlappingPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->cleanProxyFromPairs(arg2,arg3); + +} + + +void _wrap_btHashedOverlappingPairCache_processAllOverlappingPairs__SWIG_0_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btOverlapCallback *_swig_go_1, btDispatcher *_swig_go_2) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btOverlapCallback *arg2 = (btOverlapCallback *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlapCallback **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->processAllOverlappingPairs(arg2,arg3); + +} + + +void _wrap_btHashedOverlappingPairCache_processAllOverlappingPairs__SWIG_1_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btOverlapCallback *_swig_go_1, btDispatcher *_swig_go_2, btDispatcherInfo *_swig_go_3) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btOverlapCallback *arg2 = (btOverlapCallback *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + btDispatcherInfo *arg4 = 0 ; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlapCallback **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + + (arg1)->processAllOverlappingPairs(arg2,arg3,(btDispatcherInfo const &)*arg4); + +} + + +btBroadphasePair *_wrap_btHashedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePair *)(arg1)->getOverlappingPairArrayPtr(); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +btBroadphasePair *_wrap_btHashedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePair *)((btHashedOverlappingPairCache const *)arg1)->getOverlappingPairArrayPtr(); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +btAlignedObjectArray< btBroadphasePair > *_wrap_btHashedOverlappingPairCache_getOverlappingPairArray__SWIG_0_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphasePairArray *result = 0 ; + btAlignedObjectArray< btBroadphasePair > *_swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePairArray *) &(arg1)->getOverlappingPairArray(); + *(btBroadphasePairArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btBroadphasePair > *_wrap_btHashedOverlappingPairCache_getOverlappingPairArray__SWIG_1_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphasePairArray *result = 0 ; + btAlignedObjectArray< btBroadphasePair > *_swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePairArray *) &((btHashedOverlappingPairCache const *)arg1)->getOverlappingPairArray(); + *(btBroadphasePairArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btHashedOverlappingPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btBroadphasePair *_swig_go_1, btDispatcher *_swig_go_2) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphasePair *arg2 = 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphasePair **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->cleanOverlappingPair(*arg2,arg3); + +} + + +btBroadphasePair *_wrap_btHashedOverlappingPairCache_findPair_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (btBroadphasePair *)(arg1)->findPair(arg2,arg3); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +intgo _wrap_btHashedOverlappingPairCache_GetCount_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + + result = (int)((btHashedOverlappingPairCache const *)arg1)->GetCount(); + _swig_go_result = result; + return _swig_go_result; +} + + +btOverlapFilterCallback *_wrap_btHashedOverlappingPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btOverlapFilterCallback *result = 0 ; + btOverlapFilterCallback *_swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + + result = (btOverlapFilterCallback *)(arg1)->getOverlapFilterCallback(); + *(btOverlapFilterCallback **)&_swig_go_result = (btOverlapFilterCallback *)result; + return _swig_go_result; +} + + +void _wrap_btHashedOverlappingPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btOverlapFilterCallback *_swig_go_1) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btOverlapFilterCallback *arg2 = (btOverlapFilterCallback *) 0 ; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlapFilterCallback **)&_swig_go_1; + + (arg1)->setOverlapFilterCallback(arg2); + +} + + +intgo _wrap_btHashedOverlappingPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + + result = (int)((btHashedOverlappingPairCache const *)arg1)->getNumOverlappingPairs(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btHashedOverlappingPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + + btOverlappingPairCache *swig_b0 = (btOverlappingPairCache *)arg1; + result = (bool)(swig_b0)->hasDeferredRemoval(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btHashedOverlappingPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btOverlappingPairCallback *_swig_go_1) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btOverlappingPairCallback *arg2 = (btOverlappingPairCallback *) 0 ; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlappingPairCallback **)&_swig_go_1; + + btOverlappingPairCache *swig_b0 = (btOverlappingPairCache *)arg1; + (swig_b0)->setInternalGhostPairCallback(arg2); + +} + + +void _wrap_btHashedOverlappingPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(btHashedOverlappingPairCache *_swig_go_0, btDispatcher *_swig_go_1) { + btHashedOverlappingPairCache *arg1 = (btHashedOverlappingPairCache *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btHashedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + btOverlappingPairCache *swig_b0 = (btOverlappingPairCache *)arg1; + (swig_b0)->sortOverlappingPairs(arg2); + +} + + +btSortedOverlappingPairCache *_wrap_new_btSortedOverlappingPairCache_mbt_e879218550ba2e2b() { + btSortedOverlappingPairCache *result = 0 ; + btSortedOverlappingPairCache *_swig_go_result; + + + result = (btSortedOverlappingPairCache *)new btSortedOverlappingPairCache(); + *(btSortedOverlappingPairCache **)&_swig_go_result = (btSortedOverlappingPairCache *)result; + return _swig_go_result; +} + + +void _wrap_delete_btSortedOverlappingPairCache_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btSortedOverlappingPairCache_processAllOverlappingPairs_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btOverlapCallback *_swig_go_1, btDispatcher *_swig_go_2) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btOverlapCallback *arg2 = (btOverlapCallback *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlapCallback **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->processAllOverlappingPairs(arg2,arg3); + +} + + +void *_wrap_btSortedOverlappingPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2, btDispatcher *_swig_go_3) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg4 = (btDispatcher *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + arg4 = *(btDispatcher **)&_swig_go_3; + + result = (void *)(arg1)->removeOverlappingPair(arg2,arg3,arg4); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btSortedOverlappingPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btBroadphasePair *_swig_go_1, btDispatcher *_swig_go_2) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphasePair *arg2 = 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphasePair **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->cleanOverlappingPair(*arg2,arg3); + +} + + +btBroadphasePair *_wrap_btSortedOverlappingPairCache_addOverlappingPair_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (btBroadphasePair *)(arg1)->addOverlappingPair(arg2,arg3); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +btBroadphasePair *_wrap_btSortedOverlappingPairCache_findPair_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (btBroadphasePair *)(arg1)->findPair(arg2,arg3); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +void _wrap_btSortedOverlappingPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->cleanProxyFromPairs(arg2,arg3); + +} + + +void _wrap_btSortedOverlappingPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->removeOverlappingPairsContainingProxy(arg2,arg3); + +} + + +bool _wrap_btSortedOverlappingPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (bool)((btSortedOverlappingPairCache const *)arg1)->needsBroadphaseCollision(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btBroadphasePair > *_wrap_btSortedOverlappingPairCache_getOverlappingPairArray__SWIG_0_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphasePairArray *result = 0 ; + btAlignedObjectArray< btBroadphasePair > *_swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePairArray *) &(arg1)->getOverlappingPairArray(); + *(btBroadphasePairArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btBroadphasePair > *_wrap_btSortedOverlappingPairCache_getOverlappingPairArray__SWIG_1_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphasePairArray *result = 0 ; + btAlignedObjectArray< btBroadphasePair > *_swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePairArray *) &((btSortedOverlappingPairCache const *)arg1)->getOverlappingPairArray(); + *(btBroadphasePairArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +btBroadphasePair *_wrap_btSortedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePair *)(arg1)->getOverlappingPairArrayPtr(); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +btBroadphasePair *_wrap_btSortedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + + result = (btBroadphasePair *)((btSortedOverlappingPairCache const *)arg1)->getOverlappingPairArrayPtr(); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +intgo _wrap_btSortedOverlappingPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + + result = (int)((btSortedOverlappingPairCache const *)arg1)->getNumOverlappingPairs(); + _swig_go_result = result; + return _swig_go_result; +} + + +btOverlapFilterCallback *_wrap_btSortedOverlappingPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btOverlapFilterCallback *result = 0 ; + btOverlapFilterCallback *_swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + + result = (btOverlapFilterCallback *)(arg1)->getOverlapFilterCallback(); + *(btOverlapFilterCallback **)&_swig_go_result = (btOverlapFilterCallback *)result; + return _swig_go_result; +} + + +void _wrap_btSortedOverlappingPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btOverlapFilterCallback *_swig_go_1) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btOverlapFilterCallback *arg2 = (btOverlapFilterCallback *) 0 ; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlapFilterCallback **)&_swig_go_1; + + (arg1)->setOverlapFilterCallback(arg2); + +} + + +bool _wrap_btSortedOverlappingPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + + result = (bool)(arg1)->hasDeferredRemoval(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSortedOverlappingPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btOverlappingPairCallback *_swig_go_1) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btOverlappingPairCallback *arg2 = (btOverlappingPairCallback *) 0 ; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btOverlappingPairCallback **)&_swig_go_1; + + (arg1)->setInternalGhostPairCallback(arg2); + +} + + +void _wrap_btSortedOverlappingPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(btSortedOverlappingPairCache *_swig_go_0, btDispatcher *_swig_go_1) { + btSortedOverlappingPairCache *arg1 = (btSortedOverlappingPairCache *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btSortedOverlappingPairCache **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + (arg1)->sortOverlappingPairs(arg2); + +} + + +btBroadphasePair *_wrap_btNullPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btNullPairCache **)&_swig_go_0; + + result = (btBroadphasePair *)(arg1)->getOverlappingPairArrayPtr(); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +btBroadphasePair *_wrap_btNullPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btNullPairCache **)&_swig_go_0; + + result = (btBroadphasePair *)((btNullPairCache const *)arg1)->getOverlappingPairArrayPtr(); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +btAlignedObjectArray< btBroadphasePair > *_wrap_btNullPairCache_getOverlappingPairArray_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btBroadphasePairArray *result = 0 ; + btAlignedObjectArray< btBroadphasePair > *_swig_go_result; + + arg1 = *(btNullPairCache **)&_swig_go_0; + + result = (btBroadphasePairArray *) &(arg1)->getOverlappingPairArray(); + *(btBroadphasePairArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btNullPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btBroadphasePair *_swig_go_1, btDispatcher *_swig_go_2) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btBroadphasePair *arg2 = 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btBroadphasePair **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->cleanOverlappingPair(*arg2,arg3); + +} + + +intgo _wrap_btNullPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btNullPairCache **)&_swig_go_0; + + result = (int)((btNullPairCache const *)arg1)->getNumOverlappingPairs(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btNullPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->cleanProxyFromPairs(arg2,arg3); + +} + + +bool _wrap_btNullPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (bool)((btNullPairCache const *)arg1)->needsBroadphaseCollision(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +btOverlapFilterCallback *_wrap_btNullPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btOverlapFilterCallback *result = 0 ; + btOverlapFilterCallback *_swig_go_result; + + arg1 = *(btNullPairCache **)&_swig_go_0; + + result = (btOverlapFilterCallback *)(arg1)->getOverlapFilterCallback(); + *(btOverlapFilterCallback **)&_swig_go_result = (btOverlapFilterCallback *)result; + return _swig_go_result; +} + + +void _wrap_btNullPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btOverlapFilterCallback *_swig_go_1) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btOverlapFilterCallback *arg2 = (btOverlapFilterCallback *) 0 ; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btOverlapFilterCallback **)&_swig_go_1; + + (arg1)->setOverlapFilterCallback(arg2); + +} + + +void _wrap_btNullPairCache_processAllOverlappingPairs_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btOverlapCallback *_swig_go_1, btDispatcher *_swig_go_2) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btOverlapCallback *arg2 = (btOverlapCallback *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btOverlapCallback **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->processAllOverlappingPairs(arg2,arg3); + +} + + +btBroadphasePair *_wrap_btNullPairCache_findPair_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (btBroadphasePair *)(arg1)->findPair(arg2,arg3); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +bool _wrap_btNullPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btNullPairCache **)&_swig_go_0; + + result = (bool)(arg1)->hasDeferredRemoval(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btNullPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btOverlappingPairCallback *_swig_go_1) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btOverlappingPairCallback *arg2 = (btOverlappingPairCallback *) 0 ; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btOverlappingPairCallback **)&_swig_go_1; + + (arg1)->setInternalGhostPairCallback(arg2); + +} + + +btBroadphasePair *_wrap_btNullPairCache_addOverlappingPair_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btBroadphasePair *result = 0 ; + btBroadphasePair *_swig_go_result; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + + result = (btBroadphasePair *)(arg1)->addOverlappingPair(arg2,arg3); + *(btBroadphasePair **)&_swig_go_result = (btBroadphasePair *)result; + return _swig_go_result; +} + + +void *_wrap_btNullPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btBroadphaseProxy *_swig_go_2, btDispatcher *_swig_go_3) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg4 = (btDispatcher *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btBroadphaseProxy **)&_swig_go_2; + arg4 = *(btDispatcher **)&_swig_go_3; + + result = (void *)(arg1)->removeOverlappingPair(arg2,arg3,arg4); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btNullPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->removeOverlappingPairsContainingProxy(arg2,arg3); + +} + + +void _wrap_btNullPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0, btDispatcher *_swig_go_1) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btNullPairCache **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + (arg1)->sortOverlappingPairs(arg2); + +} + + +btNullPairCache *_wrap_new_btNullPairCache_mbt_e879218550ba2e2b() { + btNullPairCache *result = 0 ; + btNullPairCache *_swig_go_result; + + + result = (btNullPairCache *)new btNullPairCache(); + *(btNullPairCache **)&_swig_go_result = (btNullPairCache *)result; + return _swig_go_result; +} + + +void _wrap_delete_btNullPairCache_mbt_e879218550ba2e2b(btNullPairCache *_swig_go_0) { + btNullPairCache *arg1 = (btNullPairCache *) 0 ; + + arg1 = *(btNullPairCache **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_MyPairIndex_m_orgIndex_set_mbt_e879218550ba2e2b(MyPairIndex *_swig_go_0, intgo _swig_go_1) { + MyPairIndex *arg1 = (MyPairIndex *) 0 ; + int arg2 ; + + arg1 = *(MyPairIndex **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_orgIndex = arg2; + +} + + +intgo _wrap_MyPairIndex_m_orgIndex_get_mbt_e879218550ba2e2b(MyPairIndex *_swig_go_0) { + MyPairIndex *arg1 = (MyPairIndex *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(MyPairIndex **)&_swig_go_0; + + result = (int) ((arg1)->m_orgIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_MyPairIndex_m_uidA0_set_mbt_e879218550ba2e2b(MyPairIndex *_swig_go_0, intgo _swig_go_1) { + MyPairIndex *arg1 = (MyPairIndex *) 0 ; + int arg2 ; + + arg1 = *(MyPairIndex **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_uidA0 = arg2; + +} + + +intgo _wrap_MyPairIndex_m_uidA0_get_mbt_e879218550ba2e2b(MyPairIndex *_swig_go_0) { + MyPairIndex *arg1 = (MyPairIndex *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(MyPairIndex **)&_swig_go_0; + + result = (int) ((arg1)->m_uidA0); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_MyPairIndex_m_uidA1_set_mbt_e879218550ba2e2b(MyPairIndex *_swig_go_0, intgo _swig_go_1) { + MyPairIndex *arg1 = (MyPairIndex *) 0 ; + int arg2 ; + + arg1 = *(MyPairIndex **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_uidA1 = arg2; + +} + + +intgo _wrap_MyPairIndex_m_uidA1_get_mbt_e879218550ba2e2b(MyPairIndex *_swig_go_0) { + MyPairIndex *arg1 = (MyPairIndex *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(MyPairIndex **)&_swig_go_0; + + result = (int) ((arg1)->m_uidA1); + _swig_go_result = result; + return _swig_go_result; +} + + +MyPairIndex *_wrap_new_MyPairIndex_mbt_e879218550ba2e2b() { + MyPairIndex *result = 0 ; + MyPairIndex *_swig_go_result; + + + result = (MyPairIndex *)new MyPairIndex(); + *(MyPairIndex **)&_swig_go_result = (MyPairIndex *)result; + return _swig_go_result; +} + + +void _wrap_delete_MyPairIndex_mbt_e879218550ba2e2b(MyPairIndex *_swig_go_0) { + MyPairIndex *arg1 = (MyPairIndex *) 0 ; + + arg1 = *(MyPairIndex **)&_swig_go_0; + + delete arg1; + +} + + +MyPairIndeSortPredicate *_wrap_new_MyPairIndeSortPredicate_mbt_e879218550ba2e2b() { + MyPairIndeSortPredicate *result = 0 ; + MyPairIndeSortPredicate *_swig_go_result; + + + result = (MyPairIndeSortPredicate *)new MyPairIndeSortPredicate(); + *(MyPairIndeSortPredicate **)&_swig_go_result = (MyPairIndeSortPredicate *)result; + return _swig_go_result; +} + + +void _wrap_delete_MyPairIndeSortPredicate_mbt_e879218550ba2e2b(MyPairIndeSortPredicate *_swig_go_0) { + MyPairIndeSortPredicate *arg1 = (MyPairIndeSortPredicate *) 0 ; + + arg1 = *(MyPairIndeSortPredicate **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_gDbvtMargin_set_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + + arg1 = (btScalar)_swig_go_0; + + gDbvtMargin = arg1; + +} + + +float _wrap_gDbvtMargin_get_mbt_e879218550ba2e2b() { + btScalar result; + float _swig_go_result; + + + result = (btScalar)gDbvtMargin; + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtProxy_leaf_set_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + if (arg1) (arg1)->leaf = arg2; + +} + + +btDbvtNode *_wrap_btDbvtProxy_leaf_get_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + btDbvtNode *result = 0 ; + btDbvtNode *_swig_go_result; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + result = (btDbvtNode *) ((arg1)->leaf); + *(btDbvtNode **)&_swig_go_result = (btDbvtNode *)result; + return _swig_go_result; +} + + +void _wrap_btDbvtProxy_links_set_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0, btDbvtProxy *(*_swig_go_1)[2]) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + btDbvtProxy **arg2 = (btDbvtProxy **) (btDbvtProxy **)0 ; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + arg2 = *(btDbvtProxy ***)&_swig_go_1; + + { + size_t ii; + btDbvtProxy * *b = (btDbvtProxy * *) arg1->links; + for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((btDbvtProxy * *) arg2 + ii); + } + +} + + +btDbvtProxy *(*_wrap_btDbvtProxy_links_get_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0))[2] { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + btDbvtProxy **result = 0 ; + btDbvtProxy *(*_swig_go_result)[2]; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + result = (btDbvtProxy **)(btDbvtProxy **) ((arg1)->links); + *(btDbvtProxy ***)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtProxy_stage_set_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0, intgo _swig_go_1) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + int arg2 ; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->stage = arg2; + +} + + +intgo _wrap_btDbvtProxy_stage_get_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + result = (int) ((arg1)->stage); + _swig_go_result = result; + return _swig_go_result; +} + + +btDbvtProxy *_wrap_new_btDbvtProxy_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, void *_swig_go_2, intgo _swig_go_3, intgo _swig_go_4) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + void *arg3 = (void *) 0 ; + int arg4 ; + int arg5 ; + btDbvtProxy *result = 0 ; + btDbvtProxy *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(void **)&_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (int)_swig_go_4; + + result = (btDbvtProxy *)new btDbvtProxy((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5); + *(btDbvtProxy **)&_swig_go_result = (btDbvtProxy *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDbvtProxy_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_SetbtDbvtProxy_M_clientObject_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0, void *_swig_go_1) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + if (swig_b0) (swig_b0)->m_clientObject = arg2; + +} + + +void *_wrap_GetbtDbvtProxy_M_clientObject_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + result = (void *) ((swig_b0)->m_clientObject); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_SetbtDbvtProxy_M_collisionFilterGroup_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0, intgo _swig_go_1) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + int arg2 ; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + if (swig_b0) (swig_b0)->m_collisionFilterGroup = arg2; + +} + + +intgo _wrap_GetbtDbvtProxy_M_collisionFilterGroup_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + result = (int) ((swig_b0)->m_collisionFilterGroup); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtDbvtProxy_M_collisionFilterMask_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0, intgo _swig_go_1) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + int arg2 ; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + if (swig_b0) (swig_b0)->m_collisionFilterMask = arg2; + +} + + +intgo _wrap_GetbtDbvtProxy_M_collisionFilterMask_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + result = (int) ((swig_b0)->m_collisionFilterMask); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtDbvtProxy_M_uniqueId_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0, intgo _swig_go_1) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + int arg2 ; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + if (swig_b0) (swig_b0)->m_uniqueId = arg2; + +} + + +intgo _wrap_GetbtDbvtProxy_M_uniqueId_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + result = (int) ((swig_b0)->m_uniqueId); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtDbvtProxy_M_aabbMin_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0, btVector3 *_swig_go_1) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + if (swig_b0) (swig_b0)->m_aabbMin = *arg2; + +} + + +btVector3 *_wrap_GetbtDbvtProxy_M_aabbMin_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + result = (btVector3 *)& ((swig_b0)->m_aabbMin); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_SetbtDbvtProxy_M_aabbMax_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0, btVector3 *_swig_go_1) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + if (swig_b0) (swig_b0)->m_aabbMax = *arg2; + +} + + +btVector3 *_wrap_GetbtDbvtProxy_M_aabbMax_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + result = (btVector3 *)& ((swig_b0)->m_aabbMax); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +intgo _wrap_btDbvtProxy_getUid_mbt_e879218550ba2e2b(btDbvtProxy *_swig_go_0) { + btDbvtProxy *arg1 = (btDbvtProxy *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtProxy **)&_swig_go_0; + + btBroadphaseProxy *swig_b0 = (btBroadphaseProxy *)arg1; + result = (int)((btBroadphaseProxy const *)swig_b0)->getUid(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvtProxy_isPolyhedral_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isPolyhedral(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvtProxy_isConvex_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isConvex(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvtProxy_isNonMoving_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isNonMoving(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvtProxy_isConcave_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isConcave(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvtProxy_isCompound_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isCompound(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvtProxy_isSoftBody_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isSoftBody(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvtProxy_isInfinite_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isInfinite(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDbvtProxy_isConvex2d_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + bool result; + bool _swig_go_result; + + arg1 = (int)_swig_go_0; + + result = (bool)btBroadphaseProxy::isConvex2d(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_DYNAMIC_SET_btDbvtBroadphase_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = btDbvtBroadphase::DYNAMIC_SET; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_FIXED_SET_btDbvtBroadphase_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = btDbvtBroadphase::FIXED_SET; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_STAGECOUNT_btDbvtBroadphase_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = btDbvtBroadphase::STAGECOUNT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_sets_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btDbvt (*_swig_go_1)[2]) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btDbvt *arg2 = (btDbvt *) (btDbvt *)0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btDbvt **)&_swig_go_1; + + { + size_t ii; + btDbvt *b = (btDbvt *) arg1->m_sets; + for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((btDbvt *) arg2 + ii); + } + +} + + +btDbvt (*_wrap_btDbvtBroadphase_m_sets_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0))[2] { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btDbvt *result = 0 ; + btDbvt (*_swig_go_result)[2]; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (btDbvt *)(btDbvt *) ((arg1)->m_sets); + *(btDbvt **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_stageRoots_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btDbvtProxy *(*_swig_go_1)[btDbvtBroadphase::STAGECOUNT+1]) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btDbvtProxy **arg2 = (btDbvtProxy **) (btDbvtProxy **)0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btDbvtProxy ***)&_swig_go_1; + + { + size_t ii; + btDbvtProxy * *b = (btDbvtProxy * *) arg1->m_stageRoots; + for (ii = 0; ii < (size_t)btDbvtBroadphase::STAGECOUNT+1; ii++) b[ii] = *((btDbvtProxy * *) arg2 + ii); + } + +} + + +btDbvtProxy *(*_wrap_btDbvtBroadphase_m_stageRoots_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0))[btDbvtBroadphase::STAGECOUNT+1] { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btDbvtProxy **result = 0 ; + btDbvtProxy *(*_swig_go_result)[btDbvtBroadphase::STAGECOUNT+1]; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (btDbvtProxy **)(btDbvtProxy **) ((arg1)->m_stageRoots); + *(btDbvtProxy ***)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_paircache_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btOverlappingPairCache *_swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btOverlappingPairCache *arg2 = (btOverlappingPairCache *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btOverlappingPairCache **)&_swig_go_1; + + if (arg1) (arg1)->m_paircache = arg2; + +} + + +btOverlappingPairCache *_wrap_btDbvtBroadphase_m_paircache_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btOverlappingPairCache *result = 0 ; + btOverlappingPairCache *_swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (btOverlappingPairCache *) ((arg1)->m_paircache); + *(btOverlappingPairCache **)&_swig_go_result = (btOverlappingPairCache *)result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_prediction_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, float _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btScalar arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_prediction = arg2; + +} + + +float _wrap_btDbvtBroadphase_m_prediction_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_prediction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_stageCurrent_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_stageCurrent = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_stageCurrent_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (int) ((arg1)->m_stageCurrent); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_fupdates_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_fupdates = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_fupdates_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (int) ((arg1)->m_fupdates); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_dupdates_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_dupdates = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_dupdates_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (int) ((arg1)->m_dupdates); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_cupdates_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_cupdates = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_cupdates_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (int) ((arg1)->m_cupdates); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_newpairs_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_newpairs = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_newpairs_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (int) ((arg1)->m_newpairs); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_fixedleft_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_fixedleft = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_fixedleft_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (int) ((arg1)->m_fixedleft); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_updates_call_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + unsigned int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + + if (arg1) (arg1)->m_updates_call = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_updates_call_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (unsigned int) ((arg1)->m_updates_call); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_updates_done_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + unsigned int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + + if (arg1) (arg1)->m_updates_done = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_updates_done_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (unsigned int) ((arg1)->m_updates_done); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_updates_ratio_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, float _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btScalar arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_updates_ratio = arg2; + +} + + +float _wrap_btDbvtBroadphase_m_updates_ratio_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_updates_ratio); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_pid_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_pid = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_pid_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (int) ((arg1)->m_pid); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_cid_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_cid = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_cid_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (int) ((arg1)->m_cid); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_gid_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, intgo _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_gid = arg2; + +} + + +intgo _wrap_btDbvtBroadphase_m_gid_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (int) ((arg1)->m_gid); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_releasepaircache_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, bool _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + bool arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_releasepaircache = arg2; + +} + + +bool _wrap_btDbvtBroadphase_m_releasepaircache_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (bool) ((arg1)->m_releasepaircache); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_deferedcollide_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, bool _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + bool arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_deferedcollide = arg2; + +} + + +bool _wrap_btDbvtBroadphase_m_deferedcollide_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (bool) ((arg1)->m_deferedcollide); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_needcleanup_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, bool _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + bool arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_needcleanup = arg2; + +} + + +bool _wrap_btDbvtBroadphase_m_needcleanup_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (bool) ((arg1)->m_needcleanup); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_m_rayTestStacks_set_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btAlignedObjectArray< btAlignedObjectArray< btDbvtNode const * > > *_swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btAlignedObjectArray< btAlignedObjectArray< btDbvtNode const * > > *arg2 = (btAlignedObjectArray< btAlignedObjectArray< btDbvtNode const * > > *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btAlignedObjectArray< btDbvtNode const * > > **)&_swig_go_1; + + if (arg1) (arg1)->m_rayTestStacks = *arg2; + +} + + +btAlignedObjectArray< btAlignedObjectArray< btDbvtNode const * > > *_wrap_btDbvtBroadphase_m_rayTestStacks_get_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btAlignedObjectArray< btAlignedObjectArray< btDbvtNode const * > > *result = 0 ; + btAlignedObjectArray< btAlignedObjectArray< btDbvtNode const * > > *_swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (btAlignedObjectArray< btAlignedObjectArray< btDbvtNode const * > > *)& ((arg1)->m_rayTestStacks); + *(btAlignedObjectArray< btAlignedObjectArray< btDbvtNode const * > > **)&_swig_go_result = (btAlignedObjectArray< btAlignedObjectArray< btDbvtNode const * > > *)result; + return _swig_go_result; +} + + +btDbvtBroadphase *_wrap_new_btDbvtBroadphase__SWIG_0_mbt_e879218550ba2e2b(btOverlappingPairCache *_swig_go_0) { + btOverlappingPairCache *arg1 = (btOverlappingPairCache *) 0 ; + btDbvtBroadphase *result = 0 ; + btDbvtBroadphase *_swig_go_result; + + arg1 = *(btOverlappingPairCache **)&_swig_go_0; + + result = (btDbvtBroadphase *)new btDbvtBroadphase(arg1); + *(btDbvtBroadphase **)&_swig_go_result = (btDbvtBroadphase *)result; + return _swig_go_result; +} + + +btDbvtBroadphase *_wrap_new_btDbvtBroadphase__SWIG_1_mbt_e879218550ba2e2b() { + btDbvtBroadphase *result = 0 ; + btDbvtBroadphase *_swig_go_result; + + + result = (btDbvtBroadphase *)new btDbvtBroadphase(); + *(btDbvtBroadphase **)&_swig_go_result = (btDbvtBroadphase *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDbvtBroadphase_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btDbvtBroadphase_collide_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btDispatcher *_swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + (arg1)->collide(arg2); + +} + + +void _wrap_btDbvtBroadphase_optimize_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + (arg1)->optimize(); + +} + + +btBroadphaseProxy *_wrap_btDbvtBroadphase_createProxy_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3, void *_swig_go_4, intgo _swig_go_5, intgo _swig_go_6, btDispatcher *_swig_go_7) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + int arg4 ; + void *arg5 = (void *) 0 ; + int arg6 ; + int arg7 ; + btDispatcher *arg8 = (btDispatcher *) 0 ; + btBroadphaseProxy *result = 0 ; + btBroadphaseProxy *_swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(void **)&_swig_go_4; + arg6 = (int)_swig_go_5; + arg7 = (int)_swig_go_6; + arg8 = *(btDispatcher **)&_swig_go_7; + + result = (btBroadphaseProxy *)(arg1)->createProxy((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5,arg6,arg7,arg8); + *(btBroadphaseProxy **)&_swig_go_result = (btBroadphaseProxy *)result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_destroyProxy_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btBroadphaseProxy *_swig_go_1, btDispatcher *_swig_go_2) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->destroyProxy(arg2,arg3); + +} + + +void _wrap_btDbvtBroadphase_setAabb_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btBroadphaseProxy *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btDispatcher *_swig_go_4) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btDispatcher *arg5 = (btDispatcher *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btDispatcher **)&_swig_go_4; + + (arg1)->setAabb(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5); + +} + + +void _wrap_btDbvtBroadphase_rayTest__SWIG_0_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btBroadphaseRayCallback *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btBroadphaseRayCallback *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btBroadphaseRayCallback **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btDbvtBroadphase_rayTest__SWIG_1_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btBroadphaseRayCallback *_swig_go_3, btVector3 *_swig_go_4) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btBroadphaseRayCallback *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btBroadphaseRayCallback **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5); + +} + + +void _wrap_btDbvtBroadphase_rayTest__SWIG_2_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btBroadphaseRayCallback *_swig_go_3) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btBroadphaseRayCallback *arg4 = 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btBroadphaseRayCallback **)&_swig_go_3; + + (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); + +} + + +void _wrap_btDbvtBroadphase_aabbTest_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btBroadphaseAabbCallback *_swig_go_3) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btBroadphaseAabbCallback *arg4 = 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btBroadphaseAabbCallback **)&_swig_go_3; + + (arg1)->aabbTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); + +} + + +void _wrap_btDbvtBroadphase_getAabb_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btBroadphaseProxy *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btDbvtBroadphase const *)arg1)->getAabb(arg2,*arg3,*arg4); + +} + + +void _wrap_btDbvtBroadphase_calculateOverlappingPairs_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btDispatcher *_swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + (arg1)->calculateOverlappingPairs(arg2); + +} + + +btOverlappingPairCache *_wrap_btDbvtBroadphase_getOverlappingPairCache__SWIG_0_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btOverlappingPairCache *result = 0 ; + btOverlappingPairCache *_swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (btOverlappingPairCache *)(arg1)->getOverlappingPairCache(); + *(btOverlappingPairCache **)&_swig_go_result = (btOverlappingPairCache *)result; + return _swig_go_result; +} + + +btOverlappingPairCache *_wrap_btDbvtBroadphase_getOverlappingPairCache__SWIG_1_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btOverlappingPairCache *result = 0 ; + btOverlappingPairCache *_swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (btOverlappingPairCache *)((btDbvtBroadphase const *)arg1)->getOverlappingPairCache(); + *(btOverlappingPairCache **)&_swig_go_result = (btOverlappingPairCache *)result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_getBroadphaseAabb_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btDbvtBroadphase const *)arg1)->getBroadphaseAabb(*arg2,*arg3); + +} + + +void _wrap_btDbvtBroadphase_printStats_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + (arg1)->printStats(); + +} + + +void _wrap_btDbvtBroadphase_resetPool_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btDispatcher *_swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + (arg1)->resetPool(arg2); + +} + + +void _wrap_btDbvtBroadphase_performDeferredRemoval_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btDispatcher *_swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + (arg1)->performDeferredRemoval(arg2); + +} + + +void _wrap_btDbvtBroadphase_setVelocityPrediction_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, float _swig_go_1) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btScalar arg2 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setVelocityPrediction(arg2); + +} + + +float _wrap_btDbvtBroadphase_getVelocityPrediction_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (btScalar)((btDbvtBroadphase const *)arg1)->getVelocityPrediction(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDbvtBroadphase_setAabbForceUpdate_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0, btBroadphaseProxy *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btDispatcher *_swig_go_4) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btDispatcher *arg5 = (btDispatcher *) 0 ; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btDispatcher **)&_swig_go_4; + + (arg1)->setAabbForceUpdate(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5); + +} + + +void _wrap_btDbvtBroadphase_benchmark_mbt_e879218550ba2e2b(btBroadphaseInterface *_swig_go_0) { + btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; + + arg1 = *(btBroadphaseInterface **)&_swig_go_0; + + btDbvtBroadphase::benchmark(arg1); + +} + + +intgo _wrap_BT_MAX_THREAD_COUNT_get_mbt_e879218550ba2e2b() { + unsigned int result; + intgo _swig_go_result; + + + result = (unsigned int)(unsigned int)BT_MAX_THREAD_COUNT; + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btIsMainThread_mbt_e879218550ba2e2b() { + bool result; + bool _swig_go_result; + + + result = (bool)btIsMainThread(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btThreadsAreRunning_mbt_e879218550ba2e2b() { + bool result; + bool _swig_go_result; + + + result = (bool)btThreadsAreRunning(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGetCurrentThreadIndex_mbt_e879218550ba2e2b() { + unsigned int result; + intgo _swig_go_result; + + + result = (unsigned int)btGetCurrentThreadIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btResetThreadIndexCounter_mbt_e879218550ba2e2b() { + btResetThreadIndexCounter(); + +} + + +btSpinMutex *_wrap_new_btSpinMutex_mbt_e879218550ba2e2b() { + btSpinMutex *result = 0 ; + btSpinMutex *_swig_go_result; + + + result = (btSpinMutex *)new btSpinMutex(); + *(btSpinMutex **)&_swig_go_result = (btSpinMutex *)result; + return _swig_go_result; +} + + +void _wrap_btSpinMutex_lock_mbt_e879218550ba2e2b(btSpinMutex *_swig_go_0) { + btSpinMutex *arg1 = (btSpinMutex *) 0 ; + + arg1 = *(btSpinMutex **)&_swig_go_0; + + (arg1)->lock(); + +} + + +void _wrap_btSpinMutex_unlock_mbt_e879218550ba2e2b(btSpinMutex *_swig_go_0) { + btSpinMutex *arg1 = (btSpinMutex *) 0 ; + + arg1 = *(btSpinMutex **)&_swig_go_0; + + (arg1)->unlock(); + +} + + +bool _wrap_btSpinMutex_tryLock_mbt_e879218550ba2e2b(btSpinMutex *_swig_go_0) { + btSpinMutex *arg1 = (btSpinMutex *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSpinMutex **)&_swig_go_0; + + result = (bool)(arg1)->tryLock(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btSpinMutex_mbt_e879218550ba2e2b(btSpinMutex *_swig_go_0) { + btSpinMutex *arg1 = (btSpinMutex *) 0 ; + + arg1 = *(btSpinMutex **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btMutexLock_mbt_e879218550ba2e2b(btSpinMutex *_swig_go_0) { + btSpinMutex *arg1 = (btSpinMutex *) 0 ; + + arg1 = *(btSpinMutex **)&_swig_go_0; + + btMutexLock(arg1); + +} + + +void _wrap_btMutexUnlock_mbt_e879218550ba2e2b(btSpinMutex *_swig_go_0) { + btSpinMutex *arg1 = (btSpinMutex *) 0 ; + + arg1 = *(btSpinMutex **)&_swig_go_0; + + btMutexUnlock(arg1); + +} + + +bool _wrap_btMutexTryLock_mbt_e879218550ba2e2b(btSpinMutex *_swig_go_0) { + btSpinMutex *arg1 = (btSpinMutex *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSpinMutex **)&_swig_go_0; + + result = (bool)btMutexTryLock(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btIParallelForBody_mbt_e879218550ba2e2b(btIParallelForBody *_swig_go_0) { + btIParallelForBody *arg1 = (btIParallelForBody *) 0 ; + + arg1 = *(btIParallelForBody **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btIParallelForBody_forLoop_mbt_e879218550ba2e2b(btIParallelForBody *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btIParallelForBody *arg1 = (btIParallelForBody *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btIParallelForBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + ((btIParallelForBody const *)arg1)->forLoop(arg2,arg3); + +} + + +void _wrap_delete_btIParallelSumBody_mbt_e879218550ba2e2b(btIParallelSumBody *_swig_go_0) { + btIParallelSumBody *arg1 = (btIParallelSumBody *) 0 ; + + arg1 = *(btIParallelSumBody **)&_swig_go_0; + + delete arg1; + +} + + +float _wrap_btIParallelSumBody_sumLoop_mbt_e879218550ba2e2b(btIParallelSumBody *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btIParallelSumBody *arg1 = (btIParallelSumBody *) 0 ; + int arg2 ; + int arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btIParallelSumBody **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btScalar)((btIParallelSumBody const *)arg1)->sumLoop(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btITaskScheduler_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + + delete arg1; + +} + + +_gostring_ _wrap_btITaskScheduler_getName_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + + result = (char *)((btITaskScheduler const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btITaskScheduler_getMaxNumThreads_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + + result = (int)((btITaskScheduler const *)arg1)->getMaxNumThreads(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btITaskScheduler_getNumThreads_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + + result = (int)((btITaskScheduler const *)arg1)->getNumThreads(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btITaskScheduler_setNumThreads_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0, intgo _swig_go_1) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + int arg2 ; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setNumThreads(arg2); + +} + + +void _wrap_btITaskScheduler_parallelFor_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2, intgo _swig_go_3, btIParallelForBody *_swig_go_4) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + btIParallelForBody *arg5 = 0 ; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btIParallelForBody **)&_swig_go_4; + + (arg1)->parallelFor(arg2,arg3,arg4,(btIParallelForBody const &)*arg5); + +} + + +float _wrap_btITaskScheduler_parallelSum_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2, intgo _swig_go_3, btIParallelSumBody *_swig_go_4) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + btIParallelSumBody *arg5 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btIParallelSumBody **)&_swig_go_4; + + result = (btScalar)(arg1)->parallelSum(arg2,arg3,arg4,(btIParallelSumBody const &)*arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btITaskScheduler_sleepWorkerThreadsHint_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + + (arg1)->sleepWorkerThreadsHint(); + +} + + +void _wrap_btITaskScheduler_activate_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + + (arg1)->activate(); + +} + + +void _wrap_btITaskScheduler_deactivate_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + + (arg1)->deactivate(); + +} + + +void _wrap_btSetTaskScheduler_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + + btSetTaskScheduler(arg1); + +} + + +btITaskScheduler *_wrap_btGetTaskScheduler_mbt_e879218550ba2e2b() { + btITaskScheduler *result = 0 ; + btITaskScheduler *_swig_go_result; + + + result = (btITaskScheduler *)btGetTaskScheduler(); + *(btITaskScheduler **)&_swig_go_result = (btITaskScheduler *)result; + return _swig_go_result; +} + + +btITaskScheduler *_wrap_btGetSequentialTaskScheduler_mbt_e879218550ba2e2b() { + btITaskScheduler *result = 0 ; + btITaskScheduler *_swig_go_result; + + + result = (btITaskScheduler *)btGetSequentialTaskScheduler(); + *(btITaskScheduler **)&_swig_go_result = (btITaskScheduler *)result; + return _swig_go_result; +} + + +btITaskScheduler *_wrap_btGetOpenMPTaskScheduler_mbt_e879218550ba2e2b() { + btITaskScheduler *result = 0 ; + btITaskScheduler *_swig_go_result; + + + result = (btITaskScheduler *)btGetOpenMPTaskScheduler(); + *(btITaskScheduler **)&_swig_go_result = (btITaskScheduler *)result; + return _swig_go_result; +} + + +btITaskScheduler *_wrap_btGetTBBTaskScheduler_mbt_e879218550ba2e2b() { + btITaskScheduler *result = 0 ; + btITaskScheduler *_swig_go_result; + + + result = (btITaskScheduler *)btGetTBBTaskScheduler(); + *(btITaskScheduler **)&_swig_go_result = (btITaskScheduler *)result; + return _swig_go_result; +} + + +btITaskScheduler *_wrap_btGetPPLTaskScheduler_mbt_e879218550ba2e2b() { + btITaskScheduler *result = 0 ; + btITaskScheduler *_swig_go_result; + + + result = (btITaskScheduler *)btGetPPLTaskScheduler(); + *(btITaskScheduler **)&_swig_go_result = (btITaskScheduler *)result; + return _swig_go_result; +} + + +void _wrap_btParallelFor_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1, intgo _swig_go_2, btIParallelForBody *_swig_go_3) { + int arg1 ; + int arg2 ; + int arg3 ; + btIParallelForBody *arg4 = 0 ; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = *(btIParallelForBody **)&_swig_go_3; + + btParallelFor(arg1,arg2,arg3,(btIParallelForBody const &)*arg4); + +} + + +float _wrap_btParallelSum_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1, intgo _swig_go_2, btIParallelSumBody *_swig_go_3) { + int arg1 ; + int arg2 ; + int arg3 ; + btIParallelSumBody *arg4 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = *(btIParallelSumBody **)&_swig_go_3; + + result = (btScalar)btParallelSum(arg1,arg2,arg3,(btIParallelSumBody const &)*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_ThreadsafeCounter_mCounter_set_mbt_e879218550ba2e2b(ThreadsafeCounter *_swig_go_0, intgo _swig_go_1) { + ThreadsafeCounter *arg1 = (ThreadsafeCounter *) 0 ; + unsigned int arg2 ; + + arg1 = *(ThreadsafeCounter **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + + if (arg1) (arg1)->mCounter = arg2; + +} + + +intgo _wrap_ThreadsafeCounter_mCounter_get_mbt_e879218550ba2e2b(ThreadsafeCounter *_swig_go_0) { + ThreadsafeCounter *arg1 = (ThreadsafeCounter *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(ThreadsafeCounter **)&_swig_go_0; + + result = (unsigned int) ((arg1)->mCounter); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_ThreadsafeCounter_mMutex_set_mbt_e879218550ba2e2b(ThreadsafeCounter *_swig_go_0, btSpinMutex *_swig_go_1) { + ThreadsafeCounter *arg1 = (ThreadsafeCounter *) 0 ; + btSpinMutex *arg2 = (btSpinMutex *) 0 ; + + arg1 = *(ThreadsafeCounter **)&_swig_go_0; + arg2 = *(btSpinMutex **)&_swig_go_1; + + if (arg1) (arg1)->mMutex = *arg2; + +} + + +btSpinMutex *_wrap_ThreadsafeCounter_mMutex_get_mbt_e879218550ba2e2b(ThreadsafeCounter *_swig_go_0) { + ThreadsafeCounter *arg1 = (ThreadsafeCounter *) 0 ; + btSpinMutex *result = 0 ; + btSpinMutex *_swig_go_result; + + arg1 = *(ThreadsafeCounter **)&_swig_go_0; + + result = (btSpinMutex *)& ((arg1)->mMutex); + *(btSpinMutex **)&_swig_go_result = (btSpinMutex *)result; + return _swig_go_result; +} + + +ThreadsafeCounter *_wrap_new_ThreadsafeCounter_mbt_e879218550ba2e2b() { + ThreadsafeCounter *result = 0 ; + ThreadsafeCounter *_swig_go_result; + + + result = (ThreadsafeCounter *)new ThreadsafeCounter(); + *(ThreadsafeCounter **)&_swig_go_result = (ThreadsafeCounter *)result; + return _swig_go_result; +} + + +intgo _wrap_ThreadsafeCounter_getNext_mbt_e879218550ba2e2b(ThreadsafeCounter *_swig_go_0) { + ThreadsafeCounter *arg1 = (ThreadsafeCounter *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(ThreadsafeCounter **)&_swig_go_0; + + result = (unsigned int)(arg1)->getNext(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_ThreadsafeCounter_mbt_e879218550ba2e2b(ThreadsafeCounter *_swig_go_0) { + ThreadsafeCounter *arg1 = (ThreadsafeCounter *) 0 ; + + arg1 = *(ThreadsafeCounter **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_gBtTaskScheduler_set_mbt_e879218550ba2e2b(btITaskScheduler *_swig_go_0) { + btITaskScheduler *arg1 = (btITaskScheduler *) 0 ; + + arg1 = *(btITaskScheduler **)&_swig_go_0; + + gBtTaskScheduler = arg1; + +} + + +btITaskScheduler *_wrap_gBtTaskScheduler_get_mbt_e879218550ba2e2b() { + btITaskScheduler *result = 0 ; + btITaskScheduler *_swig_go_result; + + + result = (btITaskScheduler *)gBtTaskScheduler; + *(btITaskScheduler **)&_swig_go_result = (btITaskScheduler *)result; + return _swig_go_result; +} + + +void _wrap_gThreadsRunningCounter_set_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + + arg1 = (int)_swig_go_0; + + gThreadsRunningCounter = arg1; + +} + + +intgo _wrap_gThreadsRunningCounter_get_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)gThreadsRunningCounter; + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_gThreadsRunningCounterMutex_set_mbt_e879218550ba2e2b(btSpinMutex *_swig_go_0) { + btSpinMutex *arg1 = (btSpinMutex *) 0 ; + + arg1 = *(btSpinMutex **)&_swig_go_0; + + gThreadsRunningCounterMutex = *arg1; + +} + + +btSpinMutex *_wrap_gThreadsRunningCounterMutex_get_mbt_e879218550ba2e2b() { + btSpinMutex *result = 0 ; + btSpinMutex *_swig_go_result; + + + result = (btSpinMutex *)&gThreadsRunningCounterMutex; + *(btSpinMutex **)&_swig_go_result = (btSpinMutex *)result; + return _swig_go_result; +} + + +void _wrap_gThreadCounter_set_mbt_e879218550ba2e2b(ThreadsafeCounter *_swig_go_0) { + ThreadsafeCounter *arg1 = (ThreadsafeCounter *) 0 ; + + arg1 = *(ThreadsafeCounter **)&_swig_go_0; + + gThreadCounter = *arg1; + +} + + +ThreadsafeCounter *_wrap_gThreadCounter_get_mbt_e879218550ba2e2b() { + ThreadsafeCounter *result = 0 ; + ThreadsafeCounter *_swig_go_result; + + + result = (ThreadsafeCounter *)&gThreadCounter; + *(ThreadsafeCounter **)&_swig_go_result = (ThreadsafeCounter *)result; + return _swig_go_result; +} + + +void _wrap_btPushThreadsAreRunning_mbt_e879218550ba2e2b() { + btPushThreadsAreRunning(); + +} + + +void _wrap_btPopThreadsAreRunning_mbt_e879218550ba2e2b() { + btPopThreadsAreRunning(); + +} + + +btTaskSchedulerSequential *_wrap_new_btTaskSchedulerSequential_mbt_e879218550ba2e2b() { + btTaskSchedulerSequential *result = 0 ; + btTaskSchedulerSequential *_swig_go_result; + + + result = (btTaskSchedulerSequential *)new btTaskSchedulerSequential(); + *(btTaskSchedulerSequential **)&_swig_go_result = (btTaskSchedulerSequential *)result; + return _swig_go_result; +} + + +intgo _wrap_btTaskSchedulerSequential_getMaxNumThreads_mbt_e879218550ba2e2b(btTaskSchedulerSequential *_swig_go_0) { + btTaskSchedulerSequential *arg1 = (btTaskSchedulerSequential *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTaskSchedulerSequential **)&_swig_go_0; + + result = (int)((btTaskSchedulerSequential const *)arg1)->getMaxNumThreads(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btTaskSchedulerSequential_getNumThreads_mbt_e879218550ba2e2b(btTaskSchedulerSequential *_swig_go_0) { + btTaskSchedulerSequential *arg1 = (btTaskSchedulerSequential *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTaskSchedulerSequential **)&_swig_go_0; + + result = (int)((btTaskSchedulerSequential const *)arg1)->getNumThreads(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTaskSchedulerSequential_setNumThreads_mbt_e879218550ba2e2b(btTaskSchedulerSequential *_swig_go_0, intgo _swig_go_1) { + btTaskSchedulerSequential *arg1 = (btTaskSchedulerSequential *) 0 ; + int arg2 ; + + arg1 = *(btTaskSchedulerSequential **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setNumThreads(arg2); + +} + + +void _wrap_btTaskSchedulerSequential_parallelFor_mbt_e879218550ba2e2b(btTaskSchedulerSequential *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2, intgo _swig_go_3, btIParallelForBody *_swig_go_4) { + btTaskSchedulerSequential *arg1 = (btTaskSchedulerSequential *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + btIParallelForBody *arg5 = 0 ; + + arg1 = *(btTaskSchedulerSequential **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btIParallelForBody **)&_swig_go_4; + + (arg1)->parallelFor(arg2,arg3,arg4,(btIParallelForBody const &)*arg5); + +} + + +float _wrap_btTaskSchedulerSequential_parallelSum_mbt_e879218550ba2e2b(btTaskSchedulerSequential *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2, intgo _swig_go_3, btIParallelSumBody *_swig_go_4) { + btTaskSchedulerSequential *arg1 = (btTaskSchedulerSequential *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + btIParallelSumBody *arg5 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTaskSchedulerSequential **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btIParallelSumBody **)&_swig_go_4; + + result = (btScalar)(arg1)->parallelSum(arg2,arg3,arg4,(btIParallelSumBody const &)*arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btTaskSchedulerSequential_mbt_e879218550ba2e2b(btTaskSchedulerSequential *_swig_go_0) { + btTaskSchedulerSequential *arg1 = (btTaskSchedulerSequential *) 0 ; + + arg1 = *(btTaskSchedulerSequential **)&_swig_go_0; + + delete arg1; + +} + + +_gostring_ _wrap_btTaskSchedulerSequential_getName_mbt_e879218550ba2e2b(btTaskSchedulerSequential *_swig_go_0) { + btTaskSchedulerSequential *arg1 = (btTaskSchedulerSequential *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTaskSchedulerSequential **)&_swig_go_0; + + btITaskScheduler *swig_b0 = (btITaskScheduler *)arg1; + result = (char *)((btITaskScheduler const *)swig_b0)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btTaskSchedulerSequential_sleepWorkerThreadsHint_mbt_e879218550ba2e2b(btTaskSchedulerSequential *_swig_go_0) { + btTaskSchedulerSequential *arg1 = (btTaskSchedulerSequential *) 0 ; + + arg1 = *(btTaskSchedulerSequential **)&_swig_go_0; + + btITaskScheduler *swig_b0 = (btITaskScheduler *)arg1; + (swig_b0)->sleepWorkerThreadsHint(); + +} + + +void _wrap_btTaskSchedulerSequential_activate_mbt_e879218550ba2e2b(btTaskSchedulerSequential *_swig_go_0) { + btTaskSchedulerSequential *arg1 = (btTaskSchedulerSequential *) 0 ; + + arg1 = *(btTaskSchedulerSequential **)&_swig_go_0; + + btITaskScheduler *swig_b0 = (btITaskScheduler *)arg1; + (swig_b0)->activate(); + +} + + +void _wrap_btTaskSchedulerSequential_deactivate_mbt_e879218550ba2e2b(btTaskSchedulerSequential *_swig_go_0) { + btTaskSchedulerSequential *arg1 = (btTaskSchedulerSequential *) 0 ; + + arg1 = *(btTaskSchedulerSequential **)&_swig_go_0; + + btITaskScheduler *swig_b0 = (btITaskScheduler *)arg1; + (swig_b0)->deactivate(); + +} + + +void _wrap_btDbvtTreeCollider_pbp_set_mbt_e879218550ba2e2b(btDbvtTreeCollider *_swig_go_0, btDbvtBroadphase *_swig_go_1) { + btDbvtTreeCollider *arg1 = (btDbvtTreeCollider *) 0 ; + btDbvtBroadphase *arg2 = (btDbvtBroadphase *) 0 ; + + arg1 = *(btDbvtTreeCollider **)&_swig_go_0; + arg2 = *(btDbvtBroadphase **)&_swig_go_1; + + if (arg1) (arg1)->pbp = arg2; + +} + + +btDbvtBroadphase *_wrap_btDbvtTreeCollider_pbp_get_mbt_e879218550ba2e2b(btDbvtTreeCollider *_swig_go_0) { + btDbvtTreeCollider *arg1 = (btDbvtTreeCollider *) 0 ; + btDbvtBroadphase *result = 0 ; + btDbvtBroadphase *_swig_go_result; + + arg1 = *(btDbvtTreeCollider **)&_swig_go_0; + + result = (btDbvtBroadphase *) ((arg1)->pbp); + *(btDbvtBroadphase **)&_swig_go_result = (btDbvtBroadphase *)result; + return _swig_go_result; +} + + +void _wrap_btDbvtTreeCollider_proxy_set_mbt_e879218550ba2e2b(btDbvtTreeCollider *_swig_go_0, btDbvtProxy *_swig_go_1) { + btDbvtTreeCollider *arg1 = (btDbvtTreeCollider *) 0 ; + btDbvtProxy *arg2 = (btDbvtProxy *) 0 ; + + arg1 = *(btDbvtTreeCollider **)&_swig_go_0; + arg2 = *(btDbvtProxy **)&_swig_go_1; + + if (arg1) (arg1)->proxy = arg2; + +} + + +btDbvtProxy *_wrap_btDbvtTreeCollider_proxy_get_mbt_e879218550ba2e2b(btDbvtTreeCollider *_swig_go_0) { + btDbvtTreeCollider *arg1 = (btDbvtTreeCollider *) 0 ; + btDbvtProxy *result = 0 ; + btDbvtProxy *_swig_go_result; + + arg1 = *(btDbvtTreeCollider **)&_swig_go_0; + + result = (btDbvtProxy *) ((arg1)->proxy); + *(btDbvtProxy **)&_swig_go_result = (btDbvtProxy *)result; + return _swig_go_result; +} + + +btDbvtTreeCollider *_wrap_new_btDbvtTreeCollider_mbt_e879218550ba2e2b(btDbvtBroadphase *_swig_go_0) { + btDbvtBroadphase *arg1 = (btDbvtBroadphase *) 0 ; + btDbvtTreeCollider *result = 0 ; + btDbvtTreeCollider *_swig_go_result; + + arg1 = *(btDbvtBroadphase **)&_swig_go_0; + + result = (btDbvtTreeCollider *)new btDbvtTreeCollider(arg1); + *(btDbvtTreeCollider **)&_swig_go_result = (btDbvtTreeCollider *)result; + return _swig_go_result; +} + + +void _wrap_btDbvtTreeCollider_Process__SWIG_0_mbt_e879218550ba2e2b(btDbvtTreeCollider *_swig_go_0, btDbvtNode *_swig_go_1, btDbvtNode *_swig_go_2) { + btDbvtTreeCollider *arg1 = (btDbvtTreeCollider *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + btDbvtNode *arg3 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvtTreeCollider **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + arg3 = *(btDbvtNode **)&_swig_go_2; + + (arg1)->Process((btDbvtNode const *)arg2,(btDbvtNode const *)arg3); + +} + + +void _wrap_btDbvtTreeCollider_Process__SWIG_1_mbt_e879218550ba2e2b(btDbvtTreeCollider *_swig_go_0, btDbvtNode *_swig_go_1) { + btDbvtTreeCollider *arg1 = (btDbvtTreeCollider *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(btDbvtTreeCollider **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + (arg1)->Process((btDbvtNode const *)arg2); + +} + + +void _wrap_delete_btDbvtTreeCollider_mbt_e879218550ba2e2b(btDbvtTreeCollider *_swig_go_0) { + btDbvtTreeCollider *arg1 = (btDbvtTreeCollider *) 0 ; + + arg1 = *(btDbvtTreeCollider **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_BroadphaseRayTester_m_rayCallback_set_mbt_e879218550ba2e2b(BroadphaseRayTester *_swig_go_0, btBroadphaseRayCallback *_swig_go_1) { + BroadphaseRayTester *arg1 = (BroadphaseRayTester *) 0 ; + btBroadphaseRayCallback *arg2 = 0 ; + + arg1 = *(BroadphaseRayTester **)&_swig_go_0; + arg2 = *(btBroadphaseRayCallback **)&_swig_go_1; + + if (arg1) (arg1)->m_rayCallback = *arg2; + +} + + +btBroadphaseRayCallback *_wrap_BroadphaseRayTester_m_rayCallback_get_mbt_e879218550ba2e2b(BroadphaseRayTester *_swig_go_0) { + BroadphaseRayTester *arg1 = (BroadphaseRayTester *) 0 ; + btBroadphaseRayCallback *result = 0 ; + btBroadphaseRayCallback *_swig_go_result; + + arg1 = *(BroadphaseRayTester **)&_swig_go_0; + + result = (btBroadphaseRayCallback *) &(btBroadphaseRayCallback &) ((arg1)->m_rayCallback); + *(btBroadphaseRayCallback **)&_swig_go_result = result; + return _swig_go_result; +} + + +BroadphaseRayTester *_wrap_new_BroadphaseRayTester_mbt_e879218550ba2e2b(btBroadphaseRayCallback *_swig_go_0) { + btBroadphaseRayCallback *arg1 = 0 ; + BroadphaseRayTester *result = 0 ; + BroadphaseRayTester *_swig_go_result; + + arg1 = *(btBroadphaseRayCallback **)&_swig_go_0; + + result = (BroadphaseRayTester *)new BroadphaseRayTester(*arg1); + *(BroadphaseRayTester **)&_swig_go_result = (BroadphaseRayTester *)result; + return _swig_go_result; +} + + +void _wrap_BroadphaseRayTester_Process_mbt_e879218550ba2e2b(BroadphaseRayTester *_swig_go_0, btDbvtNode *_swig_go_1) { + BroadphaseRayTester *arg1 = (BroadphaseRayTester *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(BroadphaseRayTester **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + (arg1)->Process((btDbvtNode const *)arg2); + +} + + +void _wrap_delete_BroadphaseRayTester_mbt_e879218550ba2e2b(BroadphaseRayTester *_swig_go_0) { + BroadphaseRayTester *arg1 = (BroadphaseRayTester *) 0 ; + + arg1 = *(BroadphaseRayTester **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_BroadphaseAabbTester_m_aabbCallback_set_mbt_e879218550ba2e2b(BroadphaseAabbTester *_swig_go_0, btBroadphaseAabbCallback *_swig_go_1) { + BroadphaseAabbTester *arg1 = (BroadphaseAabbTester *) 0 ; + btBroadphaseAabbCallback *arg2 = 0 ; + + arg1 = *(BroadphaseAabbTester **)&_swig_go_0; + arg2 = *(btBroadphaseAabbCallback **)&_swig_go_1; + + if (arg1) (arg1)->m_aabbCallback = *arg2; + +} + + +btBroadphaseAabbCallback *_wrap_BroadphaseAabbTester_m_aabbCallback_get_mbt_e879218550ba2e2b(BroadphaseAabbTester *_swig_go_0) { + BroadphaseAabbTester *arg1 = (BroadphaseAabbTester *) 0 ; + btBroadphaseAabbCallback *result = 0 ; + btBroadphaseAabbCallback *_swig_go_result; + + arg1 = *(BroadphaseAabbTester **)&_swig_go_0; + + result = (btBroadphaseAabbCallback *) &(btBroadphaseAabbCallback &) ((arg1)->m_aabbCallback); + *(btBroadphaseAabbCallback **)&_swig_go_result = result; + return _swig_go_result; +} + + +BroadphaseAabbTester *_wrap_new_BroadphaseAabbTester_mbt_e879218550ba2e2b(btBroadphaseAabbCallback *_swig_go_0) { + btBroadphaseAabbCallback *arg1 = 0 ; + BroadphaseAabbTester *result = 0 ; + BroadphaseAabbTester *_swig_go_result; + + arg1 = *(btBroadphaseAabbCallback **)&_swig_go_0; + + result = (BroadphaseAabbTester *)new BroadphaseAabbTester(*arg1); + *(BroadphaseAabbTester **)&_swig_go_result = (BroadphaseAabbTester *)result; + return _swig_go_result; +} + + +void _wrap_BroadphaseAabbTester_Process_mbt_e879218550ba2e2b(BroadphaseAabbTester *_swig_go_0, btDbvtNode *_swig_go_1) { + BroadphaseAabbTester *arg1 = (BroadphaseAabbTester *) 0 ; + btDbvtNode *arg2 = (btDbvtNode *) 0 ; + + arg1 = *(BroadphaseAabbTester **)&_swig_go_0; + arg2 = *(btDbvtNode **)&_swig_go_1; + + (arg1)->Process((btDbvtNode const *)arg2); + +} + + +void _wrap_delete_BroadphaseAabbTester_mbt_e879218550ba2e2b(BroadphaseAabbTester *_swig_go_0) { + BroadphaseAabbTester *arg1 = (BroadphaseAabbTester *) 0 ; + + arg1 = *(BroadphaseAabbTester **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_DISPATCH_DISCRETE_btDispatcherInfo_mbt_e879218550ba2e2b() { + btDispatcherInfo::DispatchFunc result; + intgo _swig_go_result; + + + result = btDispatcherInfo::DISPATCH_DISCRETE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DISPATCH_CONTINUOUS_btDispatcherInfo_mbt_e879218550ba2e2b() { + btDispatcherInfo::DispatchFunc result; + intgo _swig_go_result; + + + result = btDispatcherInfo::DISPATCH_CONTINUOUS; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +btDispatcherInfo *_wrap_new_btDispatcherInfo_mbt_e879218550ba2e2b() { + btDispatcherInfo *result = 0 ; + btDispatcherInfo *_swig_go_result; + + + result = (btDispatcherInfo *)new btDispatcherInfo(); + *(btDispatcherInfo **)&_swig_go_result = (btDispatcherInfo *)result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_timeStep_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, float _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_timeStep = arg2; + +} + + +float _wrap_btDispatcherInfo_m_timeStep_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_timeStep); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_stepCount_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, intgo _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + int arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_stepCount = arg2; + +} + + +intgo _wrap_btDispatcherInfo_m_stepCount_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (int) ((arg1)->m_stepCount); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_dispatchFunc_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, intgo _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + int arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_dispatchFunc = arg2; + +} + + +intgo _wrap_btDispatcherInfo_m_dispatchFunc_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (int) ((arg1)->m_dispatchFunc); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_timeOfImpact_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, float _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_timeOfImpact = arg2; + +} + + +float _wrap_btDispatcherInfo_m_timeOfImpact_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_timeOfImpact); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_useContinuous_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, bool _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_useContinuous = arg2; + +} + + +bool _wrap_btDispatcherInfo_m_useContinuous_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (bool) ((arg1)->m_useContinuous); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_debugDraw_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, btIDebugDraw *_swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + btIDebugDraw *arg2 = (btIDebugDraw *) 0 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = *(btIDebugDraw **)&_swig_go_1; + + if (arg1) (arg1)->m_debugDraw = arg2; + +} + + +btIDebugDraw *_wrap_btDispatcherInfo_m_debugDraw_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + btIDebugDraw *result = 0 ; + btIDebugDraw *_swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (btIDebugDraw *) ((arg1)->m_debugDraw); + *(btIDebugDraw **)&_swig_go_result = (btIDebugDraw *)result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_enableSatConvex_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, bool _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_enableSatConvex = arg2; + +} + + +bool _wrap_btDispatcherInfo_m_enableSatConvex_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (bool) ((arg1)->m_enableSatConvex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_enableSPU_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, bool _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_enableSPU = arg2; + +} + + +bool _wrap_btDispatcherInfo_m_enableSPU_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (bool) ((arg1)->m_enableSPU); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_useEpa_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, bool _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_useEpa = arg2; + +} + + +bool _wrap_btDispatcherInfo_m_useEpa_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (bool) ((arg1)->m_useEpa); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_allowedCcdPenetration_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, float _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_allowedCcdPenetration = arg2; + +} + + +float _wrap_btDispatcherInfo_m_allowedCcdPenetration_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_allowedCcdPenetration); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_useConvexConservativeDistanceUtil_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, bool _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_useConvexConservativeDistanceUtil = arg2; + +} + + +bool _wrap_btDispatcherInfo_m_useConvexConservativeDistanceUtil_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (bool) ((arg1)->m_useConvexConservativeDistanceUtil); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_convexConservativeDistanceThreshold_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, float _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_convexConservativeDistanceThreshold = arg2; + +} + + +float _wrap_btDispatcherInfo_m_convexConservativeDistanceThreshold_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_convexConservativeDistanceThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcherInfo_m_deterministicOverlappingPairs_set_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, bool _swig_go_1) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool arg2 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_deterministicOverlappingPairs = arg2; + +} + + +bool _wrap_btDispatcherInfo_m_deterministicOverlappingPairs_get_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + result = (bool) ((arg1)->m_deterministicOverlappingPairs); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btDispatcherInfo_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0) { + btDispatcherInfo *arg1 = (btDispatcherInfo *) 0 ; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_BT_CONTACT_POINT_ALGORITHMS_mbt_e879218550ba2e2b() { + ebtDispatcherQueryType result; + intgo _swig_go_result; + + + result = BT_CONTACT_POINT_ALGORITHMS; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CLOSEST_POINT_ALGORITHMS_mbt_e879218550ba2e2b() { + ebtDispatcherQueryType result; + intgo _swig_go_result; + + + result = BT_CLOSEST_POINT_ALGORITHMS; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_delete_btDispatcher_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + + arg1 = *(btDispatcher **)&_swig_go_0; + + delete arg1; + +} + + +btCollisionAlgorithm *_wrap_btDispatcher_findAlgorithm_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btPersistentManifold *_swig_go_3, intgo _swig_go_4) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btPersistentManifold *arg4 = (btPersistentManifold *) 0 ; + ebtDispatcherQueryType arg5 ; + btCollisionAlgorithm *result = 0 ; + btCollisionAlgorithm *_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btPersistentManifold **)&_swig_go_3; + arg5 = (ebtDispatcherQueryType)_swig_go_4; + + result = (btCollisionAlgorithm *)(arg1)->findAlgorithm((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,arg4,arg5); + *(btCollisionAlgorithm **)&_swig_go_result = (btCollisionAlgorithm *)result; + return _swig_go_result; +} + + +btPersistentManifold *_wrap_btDispatcher_getNewManifold_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + + result = (btPersistentManifold *)(arg1)->getNewManifold((btCollisionObject const *)arg2,(btCollisionObject const *)arg3); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +void _wrap_btDispatcher_releaseManifold_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, btPersistentManifold *_swig_go_1) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btPersistentManifold *arg2 = (btPersistentManifold *) 0 ; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(btPersistentManifold **)&_swig_go_1; + + (arg1)->releaseManifold(arg2); + +} + + +void _wrap_btDispatcher_clearManifold_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, btPersistentManifold *_swig_go_1) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btPersistentManifold *arg2 = (btPersistentManifold *) 0 ; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(btPersistentManifold **)&_swig_go_1; + + (arg1)->clearManifold(arg2); + +} + + +bool _wrap_btDispatcher_needsCollision_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + + result = (bool)(arg1)->needsCollision((btCollisionObject const *)arg2,(btCollisionObject const *)arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDispatcher_needsResponse_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + + result = (bool)(arg1)->needsResponse((btCollisionObject const *)arg2,(btCollisionObject const *)arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDispatcher_dispatchAllCollisionPairs_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, btOverlappingPairCache *_swig_go_1, btDispatcherInfo *_swig_go_2, btDispatcher *_swig_go_3) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btOverlappingPairCache *arg2 = (btOverlappingPairCache *) 0 ; + btDispatcherInfo *arg3 = 0 ; + btDispatcher *arg4 = (btDispatcher *) 0 ; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(btOverlappingPairCache **)&_swig_go_1; + arg3 = *(btDispatcherInfo **)&_swig_go_2; + arg4 = *(btDispatcher **)&_swig_go_3; + + (arg1)->dispatchAllCollisionPairs(arg2,(btDispatcherInfo const &)*arg3,arg4); + +} + + +intgo _wrap_btDispatcher_getNumManifolds_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + + result = (int)((btDispatcher const *)arg1)->getNumManifolds(); + _swig_go_result = result; + return _swig_go_result; +} + + +btPersistentManifold *_wrap_btDispatcher_getManifoldByIndexInternal_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, intgo _swig_go_1) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + int arg2 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btPersistentManifold *)(arg1)->getManifoldByIndexInternal(arg2); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +btPersistentManifold **_wrap_btDispatcher_getInternalManifoldPointer_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btPersistentManifold **result = 0 ; + btPersistentManifold **_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + + result = (btPersistentManifold **)(arg1)->getInternalManifoldPointer(); + *(btPersistentManifold ***)&_swig_go_result = (btPersistentManifold **)result; + return _swig_go_result; +} + + +btPoolAllocator *_wrap_btDispatcher_getInternalManifoldPool__SWIG_0_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + + result = (btPoolAllocator *)(arg1)->getInternalManifoldPool(); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +btPoolAllocator *_wrap_btDispatcher_getInternalManifoldPool__SWIG_1_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + + result = (btPoolAllocator *)((btDispatcher const *)arg1)->getInternalManifoldPool(); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +void *_wrap_btDispatcher_allocateCollisionAlgorithm_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, intgo _swig_go_1) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + int arg2 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (void *)(arg1)->allocateCollisionAlgorithm(arg2); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btDispatcher_freeCollisionAlgorithm_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, void *_swig_go_1) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + (arg1)->freeCollisionAlgorithm(arg2); + +} + + +void _wrap_btConstraintRow_m_normal_set_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0, float *_swig_go_1) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar *arg2 = (btScalar *) (btScalar *)0 ; + + arg1 = *(btConstraintRow **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + { + size_t ii; + btScalar *b = (btScalar *) arg1->m_normal; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((btScalar *) arg2 + ii); + } + +} + + +float *_wrap_btConstraintRow_m_normal_get_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar *result = 0 ; + float *_swig_go_result; + + arg1 = *(btConstraintRow **)&_swig_go_0; + + result = (btScalar *)(btScalar *) ((arg1)->m_normal); + *(btScalar **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConstraintRow_m_rhs_set_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0, float _swig_go_1) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar arg2 ; + + arg1 = *(btConstraintRow **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_rhs = arg2; + +} + + +float _wrap_btConstraintRow_m_rhs_get_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConstraintRow **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_rhs); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConstraintRow_m_jacDiagInv_set_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0, float _swig_go_1) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar arg2 ; + + arg1 = *(btConstraintRow **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_jacDiagInv = arg2; + +} + + +float _wrap_btConstraintRow_m_jacDiagInv_get_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConstraintRow **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_jacDiagInv); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConstraintRow_m_lowerLimit_set_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0, float _swig_go_1) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar arg2 ; + + arg1 = *(btConstraintRow **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_lowerLimit = arg2; + +} + + +float _wrap_btConstraintRow_m_lowerLimit_get_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConstraintRow **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_lowerLimit); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConstraintRow_m_upperLimit_set_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0, float _swig_go_1) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar arg2 ; + + arg1 = *(btConstraintRow **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_upperLimit = arg2; + +} + + +float _wrap_btConstraintRow_m_upperLimit_get_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConstraintRow **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_upperLimit); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConstraintRow_m_accumImpulse_set_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0, float _swig_go_1) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar arg2 ; + + arg1 = *(btConstraintRow **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_accumImpulse = arg2; + +} + + +float _wrap_btConstraintRow_m_accumImpulse_get_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConstraintRow **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_accumImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +btConstraintRow *_wrap_new_btConstraintRow_mbt_e879218550ba2e2b() { + btConstraintRow *result = 0 ; + btConstraintRow *_swig_go_result; + + + result = (btConstraintRow *)new btConstraintRow(); + *(btConstraintRow **)&_swig_go_result = (btConstraintRow *)result; + return _swig_go_result; +} + + +void _wrap_delete_btConstraintRow_mbt_e879218550ba2e2b(btConstraintRow *_swig_go_0) { + btConstraintRow *arg1 = (btConstraintRow *) 0 ; + + arg1 = *(btConstraintRow **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED_mbt_e879218550ba2e2b() { + btContactPointFlags result; + intgo _swig_go_result; + + + result = BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONTACT_FLAG_HAS_CONTACT_CFM_mbt_e879218550ba2e2b() { + btContactPointFlags result; + intgo _swig_go_result; + + + result = BT_CONTACT_FLAG_HAS_CONTACT_CFM; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONTACT_FLAG_HAS_CONTACT_ERP_mbt_e879218550ba2e2b() { + btContactPointFlags result; + intgo _swig_go_result; + + + result = BT_CONTACT_FLAG_HAS_CONTACT_ERP; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING_mbt_e879218550ba2e2b() { + btContactPointFlags result; + intgo _swig_go_result; + + + result = BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONTACT_FLAG_FRICTION_ANCHOR_mbt_e879218550ba2e2b() { + btContactPointFlags result; + intgo _swig_go_result; + + + result = BT_CONTACT_FLAG_FRICTION_ANCHOR; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +btManifoldPoint *_wrap_new_btManifoldPoint__SWIG_0_mbt_e879218550ba2e2b() { + btManifoldPoint *result = 0 ; + btManifoldPoint *_swig_go_result; + + + result = (btManifoldPoint *)new btManifoldPoint(); + *(btManifoldPoint **)&_swig_go_result = (btManifoldPoint *)result; + return _swig_go_result; +} + + +btManifoldPoint *_wrap_new_btManifoldPoint__SWIG_1_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + btManifoldPoint *result = 0 ; + btManifoldPoint *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + result = (btManifoldPoint *)new btManifoldPoint((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + *(btManifoldPoint **)&_swig_go_result = (btManifoldPoint *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_localPointA_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, btVector3 *_swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_localPointA = *arg2; + +} + + +btVector3 *_wrap_btManifoldPoint_m_localPointA_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_localPointA); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_localPointB_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, btVector3 *_swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_localPointB = *arg2; + +} + + +btVector3 *_wrap_btManifoldPoint_m_localPointB_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_localPointB); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_positionWorldOnB_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, btVector3 *_swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_positionWorldOnB = *arg2; + +} + + +btVector3 *_wrap_btManifoldPoint_m_positionWorldOnB_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_positionWorldOnB); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_positionWorldOnA_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, btVector3 *_swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_positionWorldOnA = *arg2; + +} + + +btVector3 *_wrap_btManifoldPoint_m_positionWorldOnA_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_positionWorldOnA); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_normalWorldOnB_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, btVector3 *_swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_normalWorldOnB = *arg2; + +} + + +btVector3 *_wrap_btManifoldPoint_m_normalWorldOnB_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_normalWorldOnB); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_distance1_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_distance1 = arg2; + +} + + +float _wrap_btManifoldPoint_m_distance1_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_distance1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_combinedFriction_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_combinedFriction = arg2; + +} + + +float _wrap_btManifoldPoint_m_combinedFriction_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_combinedFriction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_combinedRollingFriction_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_combinedRollingFriction = arg2; + +} + + +float _wrap_btManifoldPoint_m_combinedRollingFriction_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_combinedRollingFriction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_combinedSpinningFriction_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_combinedSpinningFriction = arg2; + +} + + +float _wrap_btManifoldPoint_m_combinedSpinningFriction_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_combinedSpinningFriction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_combinedRestitution_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_combinedRestitution = arg2; + +} + + +float _wrap_btManifoldPoint_m_combinedRestitution_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_combinedRestitution); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_partId0_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, intgo _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_partId0 = arg2; + +} + + +intgo _wrap_btManifoldPoint_m_partId0_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (int) ((arg1)->m_partId0); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_partId1_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, intgo _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_partId1 = arg2; + +} + + +intgo _wrap_btManifoldPoint_m_partId1_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (int) ((arg1)->m_partId1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_index0_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, intgo _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_index0 = arg2; + +} + + +intgo _wrap_btManifoldPoint_m_index0_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (int) ((arg1)->m_index0); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_index1_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, intgo _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_index1 = arg2; + +} + + +intgo _wrap_btManifoldPoint_m_index1_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (int) ((arg1)->m_index1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_userPersistentData_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, void *_swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + if (arg1) (arg1)->m_userPersistentData = arg2; + +} + + +void *_wrap_btManifoldPoint_m_userPersistentData_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (void *) ((arg1)->m_userPersistentData); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_contactPointFlags_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, intgo _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_contactPointFlags = arg2; + +} + + +intgo _wrap_btManifoldPoint_m_contactPointFlags_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (int) ((arg1)->m_contactPointFlags); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_appliedImpulse_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_appliedImpulse = arg2; + +} + + +float _wrap_btManifoldPoint_m_appliedImpulse_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_appliedImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_prevRHS_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_prevRHS = arg2; + +} + + +float _wrap_btManifoldPoint_m_prevRHS_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_prevRHS); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_appliedImpulseLateral1_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_appliedImpulseLateral1 = arg2; + +} + + +float _wrap_btManifoldPoint_m_appliedImpulseLateral1_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_appliedImpulseLateral1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_appliedImpulseLateral2_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_appliedImpulseLateral2 = arg2; + +} + + +float _wrap_btManifoldPoint_m_appliedImpulseLateral2_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_appliedImpulseLateral2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_contactMotion1_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_contactMotion1 = arg2; + +} + + +float _wrap_btManifoldPoint_m_contactMotion1_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_contactMotion1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_contactMotion2_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_contactMotion2 = arg2; + +} + + +float _wrap_btManifoldPoint_m_contactMotion2_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_contactMotion2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_frictionCFM_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_frictionCFM = arg2; + +} + + +float _wrap_btManifoldPoint_m_frictionCFM_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_frictionCFM); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_lifeTime_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, intgo _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_lifeTime = arg2; + +} + + +intgo _wrap_btManifoldPoint_m_lifeTime_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (int) ((arg1)->m_lifeTime); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_lateralFrictionDir1_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, btVector3 *_swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_lateralFrictionDir1 = *arg2; + +} + + +btVector3 *_wrap_btManifoldPoint_m_lateralFrictionDir1_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_lateralFrictionDir1); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_m_lateralFrictionDir2_set_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, btVector3 *_swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_lateralFrictionDir2 = *arg2; + +} + + +btVector3 *_wrap_btManifoldPoint_m_lateralFrictionDir2_get_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_lateralFrictionDir2); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +float _wrap_btManifoldPoint_getDistance_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar)((btManifoldPoint const *)arg1)->getDistance(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btManifoldPoint_getLifeTime_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (int)((btManifoldPoint const *)arg1)->getLifeTime(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btManifoldPoint_getPositionWorldOnA_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btVector3 *) &((btManifoldPoint const *)arg1)->getPositionWorldOnA(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btManifoldPoint_getPositionWorldOnB_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btVector3 *) &((btManifoldPoint const *)arg1)->getPositionWorldOnB(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btManifoldPoint_setDistance_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0, float _swig_go_1) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setDistance(arg2); + +} + + +float _wrap_btManifoldPoint_getAppliedImpulse_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + result = (btScalar)((btManifoldPoint const *)arg1)->getAppliedImpulse(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btManifoldPoint_mbt_e879218550ba2e2b(btManifoldPoint *_swig_go_0) { + btManifoldPoint *arg1 = (btManifoldPoint *) 0 ; + + arg1 = *(btManifoldPoint **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_gContactBreakingThreshold_set_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + + arg1 = (btScalar)_swig_go_0; + + gContactBreakingThreshold = arg1; + +} + + +float _wrap_gContactBreakingThreshold_get_mbt_e879218550ba2e2b() { + btScalar result; + float _swig_go_result; + + + result = (btScalar)gContactBreakingThreshold; + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_MIN_CONTACT_MANIFOLD_TYPE_mbt_e879218550ba2e2b() { + btContactManifoldTypes result; + intgo _swig_go_result; + + + result = MIN_CONTACT_MANIFOLD_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_PERSISTENT_MANIFOLD_TYPE_mbt_e879218550ba2e2b() { + btContactManifoldTypes result; + intgo _swig_go_result; + + + result = BT_PERSISTENT_MANIFOLD_TYPE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifold_m_companionIdA_set_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, intgo _swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_companionIdA = arg2; + +} + + +intgo _wrap_btPersistentManifold_m_companionIdA_get_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + result = (int) ((arg1)->m_companionIdA); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifold_m_companionIdB_set_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, intgo _swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_companionIdB = arg2; + +} + + +intgo _wrap_btPersistentManifold_m_companionIdB_get_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + result = (int) ((arg1)->m_companionIdB); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifold_m_index1a_set_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, intgo _swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_index1a = arg2; + +} + + +intgo _wrap_btPersistentManifold_m_index1a_get_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + result = (int) ((arg1)->m_index1a); + _swig_go_result = result; + return _swig_go_result; +} + + +btPersistentManifold *_wrap_new_btPersistentManifold__SWIG_0_mbt_e879218550ba2e2b() { + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + + result = (btPersistentManifold *)new btPersistentManifold(); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +btPersistentManifold *_wrap_new_btPersistentManifold__SWIG_1_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1, intgo _swig_go_2, float _swig_go_3, float _swig_go_4) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + int arg3 ; + btScalar arg4 ; + btScalar arg5 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + + result = (btPersistentManifold *)new btPersistentManifold((btCollisionObject const *)arg1,(btCollisionObject const *)arg2,arg3,arg4,arg5); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +btCollisionObject *_wrap_btPersistentManifold_getBody0_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + result = (btCollisionObject *)((btPersistentManifold const *)arg1)->getBody0(); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +btCollisionObject *_wrap_btPersistentManifold_getBody1_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + result = (btCollisionObject *)((btPersistentManifold const *)arg1)->getBody1(); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifold_setBodies_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + + (arg1)->setBodies((btCollisionObject const *)arg2,(btCollisionObject const *)arg3); + +} + + +void _wrap_btPersistentManifold_clearUserCache_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btManifoldPoint *_swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btManifoldPoint *arg2 = 0 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btManifoldPoint **)&_swig_go_1; + + (arg1)->clearUserCache(*arg2); + +} + + +intgo _wrap_btPersistentManifold_getNumContacts_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + result = (int)((btPersistentManifold const *)arg1)->getNumContacts(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifold_setNumContacts_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, intgo _swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setNumContacts(arg2); + +} + + +btManifoldPoint *_wrap_btPersistentManifold_getContactPoint__SWIG_0_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, intgo _swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int arg2 ; + btManifoldPoint *result = 0 ; + btManifoldPoint *_swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btManifoldPoint *) &((btPersistentManifold const *)arg1)->getContactPoint(arg2); + *(btManifoldPoint **)&_swig_go_result = result; + return _swig_go_result; +} + + +btManifoldPoint *_wrap_btPersistentManifold_getContactPoint__SWIG_1_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, intgo _swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int arg2 ; + btManifoldPoint *result = 0 ; + btManifoldPoint *_swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btManifoldPoint *) &(arg1)->getContactPoint(arg2); + *(btManifoldPoint **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btPersistentManifold_getContactBreakingThreshold_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + result = (btScalar)((btPersistentManifold const *)arg1)->getContactBreakingThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btPersistentManifold_getContactProcessingThreshold_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + result = (btScalar)((btPersistentManifold const *)arg1)->getContactProcessingThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifold_setContactBreakingThreshold_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, float _swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btScalar arg2 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setContactBreakingThreshold(arg2); + +} + + +void _wrap_btPersistentManifold_setContactProcessingThreshold_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, float _swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btScalar arg2 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setContactProcessingThreshold(arg2); + +} + + +intgo _wrap_btPersistentManifold_getCacheEntry_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btManifoldPoint *_swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btManifoldPoint *arg2 = 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btManifoldPoint **)&_swig_go_1; + + result = (int)((btPersistentManifold const *)arg1)->getCacheEntry((btManifoldPoint const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btPersistentManifold_addManifoldPoint__SWIG_0_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btManifoldPoint *_swig_go_1, bool _swig_go_2) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btManifoldPoint *arg2 = 0 ; + bool arg3 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btManifoldPoint **)&_swig_go_1; + arg3 = (bool)_swig_go_2; + + result = (int)(arg1)->addManifoldPoint((btManifoldPoint const &)*arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btPersistentManifold_addManifoldPoint__SWIG_1_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btManifoldPoint *_swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btManifoldPoint *arg2 = 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btManifoldPoint **)&_swig_go_1; + + result = (int)(arg1)->addManifoldPoint((btManifoldPoint const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifold_removeContactPoint_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, intgo _swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->removeContactPoint(arg2); + +} + + +void _wrap_btPersistentManifold_replaceContactPoint_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btManifoldPoint *_swig_go_1, intgo _swig_go_2) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btManifoldPoint *arg2 = 0 ; + int arg3 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btManifoldPoint **)&_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->replaceContactPoint((btManifoldPoint const &)*arg2,arg3); + +} + + +bool _wrap_btPersistentManifold_validContactDistance_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btManifoldPoint *_swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btManifoldPoint *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btManifoldPoint **)&_swig_go_1; + + result = (bool)((btPersistentManifold const *)arg1)->validContactDistance((btManifoldPoint const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifold_refreshContactPoints_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + + (arg1)->refreshContactPoints((btTransform const &)*arg2,(btTransform const &)*arg3); + +} + + +void _wrap_btPersistentManifold_clearManifold_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + (arg1)->clearManifold(); + +} + + +intgo _wrap_btPersistentManifold_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + result = (int)((btPersistentManifold const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btPersistentManifold_serialize_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btPersistentManifold *_swig_go_1, void *_swig_go_2, btSerializer *_swig_go_3) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btPersistentManifold *arg2 = (btPersistentManifold *) 0 ; + void *arg3 = (void *) 0 ; + btSerializer *arg4 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btPersistentManifold **)&_swig_go_1; + arg3 = *(void **)&_swig_go_2; + arg4 = *(btSerializer **)&_swig_go_3; + + result = (char *)((btPersistentManifold const *)arg1)->serialize((btPersistentManifold const *)arg2,arg3,arg4); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btPersistentManifold_deSerialize__SWIG_0_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btPersistentManifoldDoubleData *_swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btPersistentManifoldDoubleData *arg2 = (btPersistentManifoldDoubleData *) 0 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btPersistentManifoldDoubleData **)&_swig_go_1; + + (arg1)->deSerialize((btPersistentManifoldDoubleData const *)arg2); + +} + + +void _wrap_btPersistentManifold_deSerialize__SWIG_1_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btPersistentManifoldFloatData *_swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btPersistentManifoldFloatData *arg2 = (btPersistentManifoldFloatData *) 0 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btPersistentManifoldFloatData **)&_swig_go_1; + + (arg1)->deSerialize((btPersistentManifoldFloatData const *)arg2); + +} + + +void _wrap_delete_btPersistentManifold_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_SetbtPersistentManifold_M_objectType_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, intgo _swig_go_1) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTypedObject *swig_b0 = (btTypedObject *)arg1; + if (swig_b0) (swig_b0)->m_objectType = arg2; + +} + + +intgo _wrap_GetbtPersistentManifold_M_objectType_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + btTypedObject *swig_b0 = (btTypedObject *)arg1; + result = (int) ((swig_b0)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btPersistentManifold_getObjectType_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + btTypedObject *swig_b0 = (btTypedObject *)arg1; + result = (int)((btTypedObject const *)swig_b0)->getObjectType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointA_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, btVector3DoubleData (*_swig_go_1)[4]) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) (btVector3DoubleData *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + { + size_t ii; + btVector3DoubleData *b = (btVector3DoubleData *) arg1->m_pointCacheLocalPointA; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3DoubleData *) arg2 + ii); + } + +} + + +btVector3DoubleData (*_wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointA_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0))[4] { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)(btVector3DoubleData *) ((arg1)->m_pointCacheLocalPointA); + *(btVector3DoubleData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointB_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, btVector3DoubleData (*_swig_go_1)[4]) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) (btVector3DoubleData *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + { + size_t ii; + btVector3DoubleData *b = (btVector3DoubleData *) arg1->m_pointCacheLocalPointB; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3DoubleData *) arg2 + ii); + } + +} + + +btVector3DoubleData (*_wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointB_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0))[4] { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)(btVector3DoubleData *) ((arg1)->m_pointCacheLocalPointB); + *(btVector3DoubleData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnA_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, btVector3DoubleData (*_swig_go_1)[4]) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) (btVector3DoubleData *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + { + size_t ii; + btVector3DoubleData *b = (btVector3DoubleData *) arg1->m_pointCachePositionWorldOnA; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3DoubleData *) arg2 + ii); + } + +} + + +btVector3DoubleData (*_wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnA_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0))[4] { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)(btVector3DoubleData *) ((arg1)->m_pointCachePositionWorldOnA); + *(btVector3DoubleData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnB_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, btVector3DoubleData (*_swig_go_1)[4]) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) (btVector3DoubleData *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + { + size_t ii; + btVector3DoubleData *b = (btVector3DoubleData *) arg1->m_pointCachePositionWorldOnB; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3DoubleData *) arg2 + ii); + } + +} + + +btVector3DoubleData (*_wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnB_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0))[4] { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)(btVector3DoubleData *) ((arg1)->m_pointCachePositionWorldOnB); + *(btVector3DoubleData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheNormalWorldOnB_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, btVector3DoubleData (*_swig_go_1)[4]) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) (btVector3DoubleData *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + { + size_t ii; + btVector3DoubleData *b = (btVector3DoubleData *) arg1->m_pointCacheNormalWorldOnB; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3DoubleData *) arg2 + ii); + } + +} + + +btVector3DoubleData (*_wrap_btPersistentManifoldDoubleData_m_pointCacheNormalWorldOnB_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0))[4] { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)(btVector3DoubleData *) ((arg1)->m_pointCacheNormalWorldOnB); + *(btVector3DoubleData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir1_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, btVector3DoubleData (*_swig_go_1)[4]) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) (btVector3DoubleData *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + { + size_t ii; + btVector3DoubleData *b = (btVector3DoubleData *) arg1->m_pointCacheLateralFrictionDir1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3DoubleData *) arg2 + ii); + } + +} + + +btVector3DoubleData (*_wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir1_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0))[4] { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)(btVector3DoubleData *) ((arg1)->m_pointCacheLateralFrictionDir1); + *(btVector3DoubleData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir2_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, btVector3DoubleData (*_swig_go_1)[4]) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) (btVector3DoubleData *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + { + size_t ii; + btVector3DoubleData *b = (btVector3DoubleData *) arg1->m_pointCacheLateralFrictionDir2; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3DoubleData *) arg2 + ii); + } + +} + + +btVector3DoubleData (*_wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir2_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0))[4] { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)(btVector3DoubleData *) ((arg1)->m_pointCacheLateralFrictionDir2); + *(btVector3DoubleData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheDistance_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheDistance; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheDistance_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheDistance); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulse_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheAppliedImpulse; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulse_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheAppliedImpulse); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCachePrevRHS_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCachePrevRHS; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCachePrevRHS_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCachePrevRHS); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedFriction_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheCombinedFriction; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedFriction_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheCombinedFriction); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRollingFriction_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheCombinedRollingFriction; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRollingFriction_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheCombinedRollingFriction); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedSpinningFriction_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheCombinedSpinningFriction; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedSpinningFriction_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheCombinedSpinningFriction); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRestitution_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheCombinedRestitution; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRestitution_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheCombinedRestitution); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCachePartId0_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCachePartId0; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldDoubleData_m_pointCachePartId0_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCachePartId0); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCachePartId1_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCachePartId1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldDoubleData_m_pointCachePartId1_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCachePartId1); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheIndex0_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCacheIndex0; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldDoubleData_m_pointCacheIndex0_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCacheIndex0); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheIndex1_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCacheIndex1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldDoubleData_m_pointCacheIndex1_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCacheIndex1); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheContactPointFlags_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCacheContactPointFlags; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldDoubleData_m_pointCacheContactPointFlags_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCacheContactPointFlags); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral1_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheAppliedImpulseLateral1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral1_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheAppliedImpulseLateral1); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral2_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheAppliedImpulseLateral2; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral2_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheAppliedImpulseLateral2); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion1_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheContactMotion1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion1_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheContactMotion1); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion2_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheContactMotion2; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion2_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheContactMotion2); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheContactCFM_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheContactCFM; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheContactCFM_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheContactCFM); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactStiffness1_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheCombinedContactStiffness1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactStiffness1_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheCombinedContactStiffness1); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheContactERP_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheContactERP; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheContactERP_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheContactERP); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactDamping1_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheCombinedContactDamping1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactDamping1_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheCombinedContactDamping1); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheFrictionCFM_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_pointCacheFrictionCFM; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btPersistentManifoldDoubleData_m_pointCacheFrictionCFM_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_pointCacheFrictionCFM); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_pointCacheLifeTime_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCacheLifeTime; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldDoubleData_m_pointCacheLifeTime_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCacheLifeTime); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_numCachedPoints_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numCachedPoints = arg2; + +} + + +intgo _wrap_btPersistentManifoldDoubleData_m_numCachedPoints_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_numCachedPoints); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_companionIdA_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_companionIdA = arg2; + +} + + +intgo _wrap_btPersistentManifoldDoubleData_m_companionIdA_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_companionIdA); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_companionIdB_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_companionIdB = arg2; + +} + + +intgo _wrap_btPersistentManifoldDoubleData_m_companionIdB_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_companionIdB); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_index1a_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_index1a = arg2; + +} + + +intgo _wrap_btPersistentManifoldDoubleData_m_index1a_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_index1a); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_objectType_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_objectType = arg2; + +} + + +intgo _wrap_btPersistentManifoldDoubleData_m_objectType_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_contactBreakingThreshold_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double _swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_contactBreakingThreshold = arg2; + +} + + +double _wrap_btPersistentManifoldDoubleData_m_contactBreakingThreshold_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_contactBreakingThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, double _swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_contactProcessingThreshold = arg2; + +} + + +double _wrap_btPersistentManifoldDoubleData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_contactProcessingThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_padding_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_padding = arg2; + +} + + +intgo _wrap_btPersistentManifoldDoubleData_m_padding_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_padding); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_body0_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, btCollisionObjectDoubleData *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btCollisionObjectDoubleData *arg2 = (btCollisionObjectDoubleData *) 0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(btCollisionObjectDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_body0 = arg2; + +} + + +btCollisionObjectDoubleData *_wrap_btPersistentManifoldDoubleData_m_body0_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btCollisionObjectDoubleData *result = 0 ; + btCollisionObjectDoubleData *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (btCollisionObjectDoubleData *) ((arg1)->m_body0); + *(btCollisionObjectDoubleData **)&_swig_go_result = (btCollisionObjectDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldDoubleData_m_body1_set_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0, btCollisionObjectDoubleData *_swig_go_1) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btCollisionObjectDoubleData *arg2 = (btCollisionObjectDoubleData *) 0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + arg2 = *(btCollisionObjectDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_body1 = arg2; + +} + + +btCollisionObjectDoubleData *_wrap_btPersistentManifoldDoubleData_m_body1_get_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + btCollisionObjectDoubleData *result = 0 ; + btCollisionObjectDoubleData *_swig_go_result; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + result = (btCollisionObjectDoubleData *) ((arg1)->m_body1); + *(btCollisionObjectDoubleData **)&_swig_go_result = (btCollisionObjectDoubleData *)result; + return _swig_go_result; +} + + +btPersistentManifoldDoubleData *_wrap_new_btPersistentManifoldDoubleData_mbt_e879218550ba2e2b() { + btPersistentManifoldDoubleData *result = 0 ; + btPersistentManifoldDoubleData *_swig_go_result; + + + result = (btPersistentManifoldDoubleData *)new btPersistentManifoldDoubleData(); + *(btPersistentManifoldDoubleData **)&_swig_go_result = (btPersistentManifoldDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btPersistentManifoldDoubleData_mbt_e879218550ba2e2b(btPersistentManifoldDoubleData *_swig_go_0) { + btPersistentManifoldDoubleData *arg1 = (btPersistentManifoldDoubleData *) 0 ; + + arg1 = *(btPersistentManifoldDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointA_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, btVector3FloatData (*_swig_go_1)[4]) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) (btVector3FloatData *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + { + size_t ii; + btVector3FloatData *b = (btVector3FloatData *) arg1->m_pointCacheLocalPointA; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3FloatData *) arg2 + ii); + } + +} + + +btVector3FloatData (*_wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointA_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0))[4] { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)(btVector3FloatData *) ((arg1)->m_pointCacheLocalPointA); + *(btVector3FloatData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointB_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, btVector3FloatData (*_swig_go_1)[4]) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) (btVector3FloatData *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + { + size_t ii; + btVector3FloatData *b = (btVector3FloatData *) arg1->m_pointCacheLocalPointB; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3FloatData *) arg2 + ii); + } + +} + + +btVector3FloatData (*_wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointB_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0))[4] { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)(btVector3FloatData *) ((arg1)->m_pointCacheLocalPointB); + *(btVector3FloatData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnA_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, btVector3FloatData (*_swig_go_1)[4]) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) (btVector3FloatData *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + { + size_t ii; + btVector3FloatData *b = (btVector3FloatData *) arg1->m_pointCachePositionWorldOnA; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3FloatData *) arg2 + ii); + } + +} + + +btVector3FloatData (*_wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnA_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0))[4] { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)(btVector3FloatData *) ((arg1)->m_pointCachePositionWorldOnA); + *(btVector3FloatData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnB_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, btVector3FloatData (*_swig_go_1)[4]) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) (btVector3FloatData *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + { + size_t ii; + btVector3FloatData *b = (btVector3FloatData *) arg1->m_pointCachePositionWorldOnB; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3FloatData *) arg2 + ii); + } + +} + + +btVector3FloatData (*_wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnB_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0))[4] { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)(btVector3FloatData *) ((arg1)->m_pointCachePositionWorldOnB); + *(btVector3FloatData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheNormalWorldOnB_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, btVector3FloatData (*_swig_go_1)[4]) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) (btVector3FloatData *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + { + size_t ii; + btVector3FloatData *b = (btVector3FloatData *) arg1->m_pointCacheNormalWorldOnB; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3FloatData *) arg2 + ii); + } + +} + + +btVector3FloatData (*_wrap_btPersistentManifoldFloatData_m_pointCacheNormalWorldOnB_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0))[4] { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)(btVector3FloatData *) ((arg1)->m_pointCacheNormalWorldOnB); + *(btVector3FloatData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir1_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, btVector3FloatData (*_swig_go_1)[4]) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) (btVector3FloatData *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + { + size_t ii; + btVector3FloatData *b = (btVector3FloatData *) arg1->m_pointCacheLateralFrictionDir1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3FloatData *) arg2 + ii); + } + +} + + +btVector3FloatData (*_wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir1_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0))[4] { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)(btVector3FloatData *) ((arg1)->m_pointCacheLateralFrictionDir1); + *(btVector3FloatData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir2_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, btVector3FloatData (*_swig_go_1)[4]) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) (btVector3FloatData *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + { + size_t ii; + btVector3FloatData *b = (btVector3FloatData *) arg1->m_pointCacheLateralFrictionDir2; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btVector3FloatData *) arg2 + ii); + } + +} + + +btVector3FloatData (*_wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir2_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0))[4] { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData (*_swig_go_result)[4]; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)(btVector3FloatData *) ((arg1)->m_pointCacheLateralFrictionDir2); + *(btVector3FloatData **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheDistance_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheDistance; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheDistance_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheDistance); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulse_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheAppliedImpulse; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulse_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheAppliedImpulse); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCachePrevRHS_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCachePrevRHS; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCachePrevRHS_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCachePrevRHS); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedFriction_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheCombinedFriction; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheCombinedFriction_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheCombinedFriction); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRollingFriction_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheCombinedRollingFriction; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRollingFriction_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheCombinedRollingFriction); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedSpinningFriction_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheCombinedSpinningFriction; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheCombinedSpinningFriction_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheCombinedSpinningFriction); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRestitution_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheCombinedRestitution; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRestitution_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheCombinedRestitution); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCachePartId0_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCachePartId0; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldFloatData_m_pointCachePartId0_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCachePartId0); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCachePartId1_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCachePartId1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldFloatData_m_pointCachePartId1_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCachePartId1); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheIndex0_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCacheIndex0; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldFloatData_m_pointCacheIndex0_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCacheIndex0); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheIndex1_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCacheIndex1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldFloatData_m_pointCacheIndex1_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCacheIndex1); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheContactPointFlags_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCacheContactPointFlags; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldFloatData_m_pointCacheContactPointFlags_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCacheContactPointFlags); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral1_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheAppliedImpulseLateral1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral1_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheAppliedImpulseLateral1); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral2_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheAppliedImpulseLateral2; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral2_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheAppliedImpulseLateral2); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion1_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheContactMotion1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion1_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheContactMotion1); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion2_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheContactMotion2; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion2_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheContactMotion2); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheContactCFM_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheContactCFM; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheContactCFM_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheContactCFM); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactStiffness1_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheCombinedContactStiffness1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactStiffness1_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheCombinedContactStiffness1); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheContactERP_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheContactERP; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheContactERP_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheContactERP); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactDamping1_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheCombinedContactDamping1; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactDamping1_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheCombinedContactDamping1); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheFrictionCFM_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_pointCacheFrictionCFM; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btPersistentManifoldFloatData_m_pointCacheFrictionCFM_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_pointCacheFrictionCFM); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_pointCacheLifeTime_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_pointCacheLifeTime; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btPersistentManifoldFloatData_m_pointCacheLifeTime_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_pointCacheLifeTime); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_numCachedPoints_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numCachedPoints = arg2; + +} + + +intgo _wrap_btPersistentManifoldFloatData_m_numCachedPoints_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_numCachedPoints); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_companionIdA_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_companionIdA = arg2; + +} + + +intgo _wrap_btPersistentManifoldFloatData_m_companionIdA_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_companionIdA); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_companionIdB_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_companionIdB = arg2; + +} + + +intgo _wrap_btPersistentManifoldFloatData_m_companionIdB_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_companionIdB); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_index1a_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_index1a = arg2; + +} + + +intgo _wrap_btPersistentManifoldFloatData_m_index1a_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_index1a); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_objectType_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_objectType = arg2; + +} + + +intgo _wrap_btPersistentManifoldFloatData_m_objectType_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_contactBreakingThreshold_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float _swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float arg2 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_contactBreakingThreshold = arg2; + +} + + +float _wrap_btPersistentManifoldFloatData_m_contactBreakingThreshold_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_contactBreakingThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, float _swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float arg2 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_contactProcessingThreshold = arg2; + +} + + +float _wrap_btPersistentManifoldFloatData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_contactProcessingThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_padding_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, intgo _swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int arg2 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_padding = arg2; + +} + + +intgo _wrap_btPersistentManifoldFloatData_m_padding_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_padding); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_body0_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, btCollisionObjectFloatData *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btCollisionObjectFloatData *arg2 = (btCollisionObjectFloatData *) 0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(btCollisionObjectFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_body0 = arg2; + +} + + +btCollisionObjectFloatData *_wrap_btPersistentManifoldFloatData_m_body0_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btCollisionObjectFloatData *result = 0 ; + btCollisionObjectFloatData *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (btCollisionObjectFloatData *) ((arg1)->m_body0); + *(btCollisionObjectFloatData **)&_swig_go_result = (btCollisionObjectFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btPersistentManifoldFloatData_m_body1_set_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0, btCollisionObjectFloatData *_swig_go_1) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btCollisionObjectFloatData *arg2 = (btCollisionObjectFloatData *) 0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + arg2 = *(btCollisionObjectFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_body1 = arg2; + +} + + +btCollisionObjectFloatData *_wrap_btPersistentManifoldFloatData_m_body1_get_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + btCollisionObjectFloatData *result = 0 ; + btCollisionObjectFloatData *_swig_go_result; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + result = (btCollisionObjectFloatData *) ((arg1)->m_body1); + *(btCollisionObjectFloatData **)&_swig_go_result = (btCollisionObjectFloatData *)result; + return _swig_go_result; +} + + +btPersistentManifoldFloatData *_wrap_new_btPersistentManifoldFloatData_mbt_e879218550ba2e2b() { + btPersistentManifoldFloatData *result = 0 ; + btPersistentManifoldFloatData *_swig_go_result; + + + result = (btPersistentManifoldFloatData *)new btPersistentManifoldFloatData(); + *(btPersistentManifoldFloatData **)&_swig_go_result = (btPersistentManifoldFloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btPersistentManifoldFloatData_mbt_e879218550ba2e2b(btPersistentManifoldFloatData *_swig_go_0) { + btPersistentManifoldFloatData *arg1 = (btPersistentManifoldFloatData *) 0 ; + + arg1 = *(btPersistentManifoldFloatData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_delete_btDiscreteCollisionDetectorInterface_mbt_e879218550ba2e2b(btDiscreteCollisionDetectorInterface *_swig_go_0) { + btDiscreteCollisionDetectorInterface *arg1 = (btDiscreteCollisionDetectorInterface *) 0 ; + + arg1 = *(btDiscreteCollisionDetectorInterface **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btDiscreteCollisionDetectorInterface_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(btDiscreteCollisionDetectorInterface *_swig_go_0, btDiscreteCollisionDetectorInterface::ClosestPointInput *_swig_go_1, btDiscreteCollisionDetectorInterface::Result *_swig_go_2, btIDebugDraw *_swig_go_3, bool _swig_go_4) { + btDiscreteCollisionDetectorInterface *arg1 = (btDiscreteCollisionDetectorInterface *) 0 ; + btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; + btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; + bool arg5 ; + + arg1 = *(btDiscreteCollisionDetectorInterface **)&_swig_go_0; + arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&_swig_go_1; + arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_2; + arg4 = *(btIDebugDraw **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + + (arg1)->getClosestPoints((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4,arg5); + +} + + +void _wrap_btDiscreteCollisionDetectorInterface_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(btDiscreteCollisionDetectorInterface *_swig_go_0, btDiscreteCollisionDetectorInterface::ClosestPointInput *_swig_go_1, btDiscreteCollisionDetectorInterface::Result *_swig_go_2, btIDebugDraw *_swig_go_3) { + btDiscreteCollisionDetectorInterface *arg1 = (btDiscreteCollisionDetectorInterface *) 0 ; + btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; + btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; + + arg1 = *(btDiscreteCollisionDetectorInterface **)&_swig_go_0; + arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&_swig_go_1; + arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_2; + arg4 = *(btIDebugDraw **)&_swig_go_3; + + (arg1)->getClosestPoints((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4); + +} + + +void _wrap_btStorageResult_m_normalOnSurfaceB_set_mbt_e879218550ba2e2b(btStorageResult *_swig_go_0, btVector3 *_swig_go_1) { + btStorageResult *arg1 = (btStorageResult *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btStorageResult **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_normalOnSurfaceB = *arg2; + +} + + +btVector3 *_wrap_btStorageResult_m_normalOnSurfaceB_get_mbt_e879218550ba2e2b(btStorageResult *_swig_go_0) { + btStorageResult *arg1 = (btStorageResult *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btStorageResult **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_normalOnSurfaceB); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btStorageResult_m_closestPointInB_set_mbt_e879218550ba2e2b(btStorageResult *_swig_go_0, btVector3 *_swig_go_1) { + btStorageResult *arg1 = (btStorageResult *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btStorageResult **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_closestPointInB = *arg2; + +} + + +btVector3 *_wrap_btStorageResult_m_closestPointInB_get_mbt_e879218550ba2e2b(btStorageResult *_swig_go_0) { + btStorageResult *arg1 = (btStorageResult *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btStorageResult **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_closestPointInB); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btStorageResult_m_distance_set_mbt_e879218550ba2e2b(btStorageResult *_swig_go_0, float _swig_go_1) { + btStorageResult *arg1 = (btStorageResult *) 0 ; + btScalar arg2 ; + + arg1 = *(btStorageResult **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_distance = arg2; + +} + + +float _wrap_btStorageResult_m_distance_get_mbt_e879218550ba2e2b(btStorageResult *_swig_go_0) { + btStorageResult *arg1 = (btStorageResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btStorageResult **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_distance); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btStorageResult_mbt_e879218550ba2e2b(btStorageResult *_swig_go_0) { + btStorageResult *arg1 = (btStorageResult *) 0 ; + + arg1 = *(btStorageResult **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btStorageResult_addContactPoint_mbt_e879218550ba2e2b(btStorageResult *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btStorageResult *arg1 = (btStorageResult *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btStorageResult **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->addContactPoint((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +void _wrap_gContactAddedCallback_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + ContactAddedCallback arg1 = (ContactAddedCallback) 0 ; + + arg1 = *(ContactAddedCallback *)&_swig_go_0; + + gContactAddedCallback = arg1; + +} + + +void* _wrap_gContactAddedCallback_get_mbt_e879218550ba2e2b() { + ContactAddedCallback result; + void* _swig_go_result; + + + result = (ContactAddedCallback)gContactAddedCallback; + *(ContactAddedCallback *)&_swig_go_result = (ContactAddedCallback)result; + return _swig_go_result; +} + + +void _wrap_gCalculateCombinedRestitutionCallback_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + CalculateCombinedCallback arg1 = (CalculateCombinedCallback) 0 ; + + arg1 = *(CalculateCombinedCallback *)&_swig_go_0; + + gCalculateCombinedRestitutionCallback = arg1; + +} + + +void* _wrap_gCalculateCombinedRestitutionCallback_get_mbt_e879218550ba2e2b() { + CalculateCombinedCallback result; + void* _swig_go_result; + + + result = (CalculateCombinedCallback)gCalculateCombinedRestitutionCallback; + *(CalculateCombinedCallback *)&_swig_go_result = (CalculateCombinedCallback)result; + return _swig_go_result; +} + + +void _wrap_gCalculateCombinedFrictionCallback_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + CalculateCombinedCallback arg1 = (CalculateCombinedCallback) 0 ; + + arg1 = *(CalculateCombinedCallback *)&_swig_go_0; + + gCalculateCombinedFrictionCallback = arg1; + +} + + +void* _wrap_gCalculateCombinedFrictionCallback_get_mbt_e879218550ba2e2b() { + CalculateCombinedCallback result; + void* _swig_go_result; + + + result = (CalculateCombinedCallback)gCalculateCombinedFrictionCallback; + *(CalculateCombinedCallback *)&_swig_go_result = (CalculateCombinedCallback)result; + return _swig_go_result; +} + + +void _wrap_gCalculateCombinedRollingFrictionCallback_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + CalculateCombinedCallback arg1 = (CalculateCombinedCallback) 0 ; + + arg1 = *(CalculateCombinedCallback *)&_swig_go_0; + + gCalculateCombinedRollingFrictionCallback = arg1; + +} + + +void* _wrap_gCalculateCombinedRollingFrictionCallback_get_mbt_e879218550ba2e2b() { + CalculateCombinedCallback result; + void* _swig_go_result; + + + result = (CalculateCombinedCallback)gCalculateCombinedRollingFrictionCallback; + *(CalculateCombinedCallback *)&_swig_go_result = (CalculateCombinedCallback)result; + return _swig_go_result; +} + + +void _wrap_gCalculateCombinedSpinningFrictionCallback_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + CalculateCombinedCallback arg1 = (CalculateCombinedCallback) 0 ; + + arg1 = *(CalculateCombinedCallback *)&_swig_go_0; + + gCalculateCombinedSpinningFrictionCallback = arg1; + +} + + +void* _wrap_gCalculateCombinedSpinningFrictionCallback_get_mbt_e879218550ba2e2b() { + CalculateCombinedCallback result; + void* _swig_go_result; + + + result = (CalculateCombinedCallback)gCalculateCombinedSpinningFrictionCallback; + *(CalculateCombinedCallback *)&_swig_go_result = (CalculateCombinedCallback)result; + return _swig_go_result; +} + + +void _wrap_gCalculateCombinedContactDampingCallback_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + CalculateCombinedCallback arg1 = (CalculateCombinedCallback) 0 ; + + arg1 = *(CalculateCombinedCallback *)&_swig_go_0; + + gCalculateCombinedContactDampingCallback = arg1; + +} + + +void* _wrap_gCalculateCombinedContactDampingCallback_get_mbt_e879218550ba2e2b() { + CalculateCombinedCallback result; + void* _swig_go_result; + + + result = (CalculateCombinedCallback)gCalculateCombinedContactDampingCallback; + *(CalculateCombinedCallback *)&_swig_go_result = (CalculateCombinedCallback)result; + return _swig_go_result; +} + + +void _wrap_gCalculateCombinedContactStiffnessCallback_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + CalculateCombinedCallback arg1 = (CalculateCombinedCallback) 0 ; + + arg1 = *(CalculateCombinedCallback *)&_swig_go_0; + + gCalculateCombinedContactStiffnessCallback = arg1; + +} + + +void* _wrap_gCalculateCombinedContactStiffnessCallback_get_mbt_e879218550ba2e2b() { + CalculateCombinedCallback result; + void* _swig_go_result; + + + result = (CalculateCombinedCallback)gCalculateCombinedContactStiffnessCallback; + *(CalculateCombinedCallback *)&_swig_go_result = (CalculateCombinedCallback)result; + return _swig_go_result; +} + + +btManifoldResult *_wrap_new_btManifoldResult__SWIG_0_mbt_e879218550ba2e2b() { + btManifoldResult *result = 0 ; + btManifoldResult *_swig_go_result; + + + result = (btManifoldResult *)new btManifoldResult(); + *(btManifoldResult **)&_swig_go_result = (btManifoldResult *)result; + return _swig_go_result; +} + + +btManifoldResult *_wrap_new_btManifoldResult__SWIG_1_mbt_e879218550ba2e2b(btCollisionObjectWrapper *_swig_go_0, btCollisionObjectWrapper *_swig_go_1) { + btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btManifoldResult *result = 0 ; + btManifoldResult *_swig_go_result; + + arg1 = *(btCollisionObjectWrapper **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + + result = (btManifoldResult *)new btManifoldResult((btCollisionObjectWrapper const *)arg1,(btCollisionObjectWrapper const *)arg2); + *(btManifoldResult **)&_swig_go_result = (btManifoldResult *)result; + return _swig_go_result; +} + + +void _wrap_delete_btManifoldResult_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + + arg1 = *(btManifoldResult **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btManifoldResult_setPersistentManifold_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0, btPersistentManifold *_swig_go_1) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btPersistentManifold *arg2 = (btPersistentManifold *) 0 ; + + arg1 = *(btManifoldResult **)&_swig_go_0; + arg2 = *(btPersistentManifold **)&_swig_go_1; + + (arg1)->setPersistentManifold(arg2); + +} + + +btPersistentManifold *_wrap_btManifoldResult_getPersistentManifold__SWIG_0_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btManifoldResult **)&_swig_go_0; + + result = (btPersistentManifold *)((btManifoldResult const *)arg1)->getPersistentManifold(); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +btPersistentManifold *_wrap_btManifoldResult_getPersistentManifold__SWIG_1_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btManifoldResult **)&_swig_go_0; + + result = (btPersistentManifold *)(arg1)->getPersistentManifold(); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldResult_setShapeIdentifiersA_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btManifoldResult **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->setShapeIdentifiersA(arg2,arg3); + +} + + +void _wrap_btManifoldResult_setShapeIdentifiersB_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btManifoldResult **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->setShapeIdentifiersB(arg2,arg3); + +} + + +void _wrap_btManifoldResult_addContactPoint_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btManifoldResult **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->addContactPoint((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +void _wrap_btManifoldResult_refreshContactPoints_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + + arg1 = *(btManifoldResult **)&_swig_go_0; + + (arg1)->refreshContactPoints(); + +} + + +btCollisionObjectWrapper *_wrap_btManifoldResult_getBody0Wrap_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btCollisionObjectWrapper *result = 0 ; + btCollisionObjectWrapper *_swig_go_result; + + arg1 = *(btManifoldResult **)&_swig_go_0; + + result = (btCollisionObjectWrapper *)((btManifoldResult const *)arg1)->getBody0Wrap(); + *(btCollisionObjectWrapper **)&_swig_go_result = (btCollisionObjectWrapper *)result; + return _swig_go_result; +} + + +btCollisionObjectWrapper *_wrap_btManifoldResult_getBody1Wrap_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btCollisionObjectWrapper *result = 0 ; + btCollisionObjectWrapper *_swig_go_result; + + arg1 = *(btManifoldResult **)&_swig_go_0; + + result = (btCollisionObjectWrapper *)((btManifoldResult const *)arg1)->getBody1Wrap(); + *(btCollisionObjectWrapper **)&_swig_go_result = (btCollisionObjectWrapper *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldResult_setBody0Wrap_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0, btCollisionObjectWrapper *_swig_go_1) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + + arg1 = *(btManifoldResult **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + + (arg1)->setBody0Wrap((btCollisionObjectWrapper const *)arg2); + +} + + +void _wrap_btManifoldResult_setBody1Wrap_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0, btCollisionObjectWrapper *_swig_go_1) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + + arg1 = *(btManifoldResult **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + + (arg1)->setBody1Wrap((btCollisionObjectWrapper const *)arg2); + +} + + +btCollisionObject *_wrap_btManifoldResult_getBody0Internal_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + arg1 = *(btManifoldResult **)&_swig_go_0; + + result = (btCollisionObject *)((btManifoldResult const *)arg1)->getBody0Internal(); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +btCollisionObject *_wrap_btManifoldResult_getBody1Internal_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + arg1 = *(btManifoldResult **)&_swig_go_0; + + result = (btCollisionObject *)((btManifoldResult const *)arg1)->getBody1Internal(); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +void _wrap_btManifoldResult_m_closestPointDistanceThreshold_set_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0, float _swig_go_1) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btScalar arg2 ; + + arg1 = *(btManifoldResult **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_closestPointDistanceThreshold = arg2; + +} + + +float _wrap_btManifoldResult_m_closestPointDistanceThreshold_get_mbt_e879218550ba2e2b(btManifoldResult *_swig_go_0) { + btManifoldResult *arg1 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btManifoldResult **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_closestPointDistanceThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btManifoldResult_calculateCombinedRestitution_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedRestitution((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btManifoldResult_calculateCombinedFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedFriction((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btManifoldResult_calculateCombinedRollingFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedRollingFriction((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btManifoldResult_calculateCombinedSpinningFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedSpinningFriction((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btManifoldResult_calculateCombinedContactDamping_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedContactDamping((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btManifoldResult_calculateCombinedContactStiffness_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedContactStiffness((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionAlgorithmCreateFunc_m_swapped_set_mbt_e879218550ba2e2b(btCollisionAlgorithmCreateFunc *_swig_go_0, bool _swig_go_1) { + btCollisionAlgorithmCreateFunc *arg1 = (btCollisionAlgorithmCreateFunc *) 0 ; + bool arg2 ; + + arg1 = *(btCollisionAlgorithmCreateFunc **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_swapped = arg2; + +} + + +bool _wrap_btCollisionAlgorithmCreateFunc_m_swapped_get_mbt_e879218550ba2e2b(btCollisionAlgorithmCreateFunc *_swig_go_0) { + btCollisionAlgorithmCreateFunc *arg1 = (btCollisionAlgorithmCreateFunc *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionAlgorithmCreateFunc **)&_swig_go_0; + + result = (bool) ((arg1)->m_swapped); + _swig_go_result = result; + return _swig_go_result; +} + + +btCollisionAlgorithmCreateFunc *_wrap_new_btCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b() { + btCollisionAlgorithmCreateFunc *result = 0 ; + btCollisionAlgorithmCreateFunc *_swig_go_result; + + + result = (btCollisionAlgorithmCreateFunc *)new btCollisionAlgorithmCreateFunc(); + *(btCollisionAlgorithmCreateFunc **)&_swig_go_result = (btCollisionAlgorithmCreateFunc *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b(btCollisionAlgorithmCreateFunc *_swig_go_0) { + btCollisionAlgorithmCreateFunc *arg1 = (btCollisionAlgorithmCreateFunc *) 0 ; + + arg1 = *(btCollisionAlgorithmCreateFunc **)&_swig_go_0; + + delete arg1; + +} + + +btCollisionAlgorithm *_wrap_btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm_mbt_e879218550ba2e2b(btCollisionAlgorithmCreateFunc *_swig_go_0, btCollisionAlgorithmConstructionInfo *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionObjectWrapper *_swig_go_3) { + btCollisionAlgorithmCreateFunc *arg1 = (btCollisionAlgorithmCreateFunc *) 0 ; + btCollisionAlgorithmConstructionInfo *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + btCollisionAlgorithm *result = 0 ; + btCollisionAlgorithm *_swig_go_result; + + arg1 = *(btCollisionAlgorithmCreateFunc **)&_swig_go_0; + arg2 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + + result = (btCollisionAlgorithm *)(arg1)->CreateCollisionAlgorithm(*arg2,(btCollisionObjectWrapper const *)arg3,(btCollisionObjectWrapper const *)arg4); + *(btCollisionAlgorithm **)&_swig_go_result = (btCollisionAlgorithm *)result; + return _swig_go_result; +} + + +intgo _wrap_CD_STATIC_STATIC_REPORTED_btCollisionDispatcher_mbt_e879218550ba2e2b() { + btCollisionDispatcher::DispatcherFlags result; + intgo _swig_go_result; + + + result = btCollisionDispatcher::CD_STATIC_STATIC_REPORTED; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD_btCollisionDispatcher_mbt_e879218550ba2e2b() { + btCollisionDispatcher::DispatcherFlags result; + intgo _swig_go_result; + + + result = btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION_btCollisionDispatcher_mbt_e879218550ba2e2b() { + btCollisionDispatcher::DispatcherFlags result; + intgo _swig_go_result; + + + result = btCollisionDispatcher::CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_btCollisionDispatcher_getDispatcherFlags_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + + result = (int)((btCollisionDispatcher const *)arg1)->getDispatcherFlags(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionDispatcher_setDispatcherFlags_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, intgo _swig_go_1) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + int arg2 ; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setDispatcherFlags(arg2); + +} + + +void _wrap_btCollisionDispatcher_registerCollisionCreateFunc_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2, btCollisionAlgorithmCreateFunc *_swig_go_3) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + int arg2 ; + int arg3 ; + btCollisionAlgorithmCreateFunc *arg4 = (btCollisionAlgorithmCreateFunc *) 0 ; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = *(btCollisionAlgorithmCreateFunc **)&_swig_go_3; + + (arg1)->registerCollisionCreateFunc(arg2,arg3,arg4); + +} + + +void _wrap_btCollisionDispatcher_registerClosestPointsCreateFunc_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2, btCollisionAlgorithmCreateFunc *_swig_go_3) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + int arg2 ; + int arg3 ; + btCollisionAlgorithmCreateFunc *arg4 = (btCollisionAlgorithmCreateFunc *) 0 ; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = *(btCollisionAlgorithmCreateFunc **)&_swig_go_3; + + (arg1)->registerClosestPointsCreateFunc(arg2,arg3,arg4); + +} + + +intgo _wrap_btCollisionDispatcher_getNumManifolds_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + + result = (int)((btCollisionDispatcher const *)arg1)->getNumManifolds(); + _swig_go_result = result; + return _swig_go_result; +} + + +btPersistentManifold **_wrap_btCollisionDispatcher_getInternalManifoldPointer_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btPersistentManifold **result = 0 ; + btPersistentManifold **_swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + + result = (btPersistentManifold **)(arg1)->getInternalManifoldPointer(); + *(btPersistentManifold ***)&_swig_go_result = (btPersistentManifold **)result; + return _swig_go_result; +} + + +btPersistentManifold *_wrap_btCollisionDispatcher_getManifoldByIndexInternal_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, intgo _swig_go_1) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + int arg2 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btPersistentManifold *)(arg1)->getManifoldByIndexInternal(arg2); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +btCollisionDispatcher *_wrap_new_btCollisionDispatcher_mbt_e879218550ba2e2b(btCollisionConfiguration *_swig_go_0) { + btCollisionConfiguration *arg1 = (btCollisionConfiguration *) 0 ; + btCollisionDispatcher *result = 0 ; + btCollisionDispatcher *_swig_go_result; + + arg1 = *(btCollisionConfiguration **)&_swig_go_0; + + result = (btCollisionDispatcher *)new btCollisionDispatcher(arg1); + *(btCollisionDispatcher **)&_swig_go_result = (btCollisionDispatcher *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCollisionDispatcher_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + + delete arg1; + +} + + +btPersistentManifold *_wrap_btCollisionDispatcher_getNewManifold_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + + result = (btPersistentManifold *)(arg1)->getNewManifold((btCollisionObject const *)arg2,(btCollisionObject const *)arg3); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionDispatcher_releaseManifold_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, btPersistentManifold *_swig_go_1) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btPersistentManifold *arg2 = (btPersistentManifold *) 0 ; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = *(btPersistentManifold **)&_swig_go_1; + + (arg1)->releaseManifold(arg2); + +} + + +void _wrap_btCollisionDispatcher_clearManifold_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, btPersistentManifold *_swig_go_1) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btPersistentManifold *arg2 = (btPersistentManifold *) 0 ; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = *(btPersistentManifold **)&_swig_go_1; + + (arg1)->clearManifold(arg2); + +} + + +btCollisionAlgorithm *_wrap_btCollisionDispatcher_findAlgorithm_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btPersistentManifold *_swig_go_3, intgo _swig_go_4) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btPersistentManifold *arg4 = (btPersistentManifold *) 0 ; + ebtDispatcherQueryType arg5 ; + btCollisionAlgorithm *result = 0 ; + btCollisionAlgorithm *_swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btPersistentManifold **)&_swig_go_3; + arg5 = (ebtDispatcherQueryType)_swig_go_4; + + result = (btCollisionAlgorithm *)(arg1)->findAlgorithm((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,arg4,arg5); + *(btCollisionAlgorithm **)&_swig_go_result = (btCollisionAlgorithm *)result; + return _swig_go_result; +} + + +bool _wrap_btCollisionDispatcher_needsCollision_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + + result = (bool)(arg1)->needsCollision((btCollisionObject const *)arg2,(btCollisionObject const *)arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionDispatcher_needsResponse_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + + result = (bool)(arg1)->needsResponse((btCollisionObject const *)arg2,(btCollisionObject const *)arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionDispatcher_dispatchAllCollisionPairs_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, btOverlappingPairCache *_swig_go_1, btDispatcherInfo *_swig_go_2, btDispatcher *_swig_go_3) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btOverlappingPairCache *arg2 = (btOverlappingPairCache *) 0 ; + btDispatcherInfo *arg3 = 0 ; + btDispatcher *arg4 = (btDispatcher *) 0 ; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = *(btOverlappingPairCache **)&_swig_go_1; + arg3 = *(btDispatcherInfo **)&_swig_go_2; + arg4 = *(btDispatcher **)&_swig_go_3; + + (arg1)->dispatchAllCollisionPairs(arg2,(btDispatcherInfo const &)*arg3,arg4); + +} + + +void _wrap_btCollisionDispatcher_setNearCallback_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, void* _swig_go_1) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btNearCallback arg2 = (btNearCallback) 0 ; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = *(btNearCallback *)&_swig_go_1; + + (arg1)->setNearCallback(arg2); + +} + + +void* _wrap_btCollisionDispatcher_getNearCallback_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btNearCallback result; + void* _swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + + result = (btNearCallback)((btCollisionDispatcher const *)arg1)->getNearCallback(); + *(btNearCallback *)&_swig_go_result = (btNearCallback)result; + return _swig_go_result; +} + + +void _wrap_btCollisionDispatcher_defaultNearCallback_mbt_e879218550ba2e2b(btBroadphasePair *_swig_go_0, btCollisionDispatcher *_swig_go_1, btDispatcherInfo *_swig_go_2) { + btBroadphasePair *arg1 = 0 ; + btCollisionDispatcher *arg2 = 0 ; + btDispatcherInfo *arg3 = 0 ; + + arg1 = *(btBroadphasePair **)&_swig_go_0; + arg2 = *(btCollisionDispatcher **)&_swig_go_1; + arg3 = *(btDispatcherInfo **)&_swig_go_2; + + btCollisionDispatcher::defaultNearCallback(*arg1,*arg2,(btDispatcherInfo const &)*arg3); + +} + + +void *_wrap_btCollisionDispatcher_allocateCollisionAlgorithm_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, intgo _swig_go_1) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + int arg2 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (void *)(arg1)->allocateCollisionAlgorithm(arg2); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionDispatcher_freeCollisionAlgorithm_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, void *_swig_go_1) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + (arg1)->freeCollisionAlgorithm(arg2); + +} + + +btCollisionConfiguration *_wrap_btCollisionDispatcher_getCollisionConfiguration__SWIG_0_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btCollisionConfiguration *result = 0 ; + btCollisionConfiguration *_swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + + result = (btCollisionConfiguration *)(arg1)->getCollisionConfiguration(); + *(btCollisionConfiguration **)&_swig_go_result = (btCollisionConfiguration *)result; + return _swig_go_result; +} + + +btCollisionConfiguration *_wrap_btCollisionDispatcher_getCollisionConfiguration__SWIG_1_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btCollisionConfiguration *result = 0 ; + btCollisionConfiguration *_swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + + result = (btCollisionConfiguration *)((btCollisionDispatcher const *)arg1)->getCollisionConfiguration(); + *(btCollisionConfiguration **)&_swig_go_result = (btCollisionConfiguration *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionDispatcher_setCollisionConfiguration_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0, btCollisionConfiguration *_swig_go_1) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btCollisionConfiguration *arg2 = (btCollisionConfiguration *) 0 ; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + arg2 = *(btCollisionConfiguration **)&_swig_go_1; + + (arg1)->setCollisionConfiguration(arg2); + +} + + +btPoolAllocator *_wrap_btCollisionDispatcher_getInternalManifoldPool__SWIG_0_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + + result = (btPoolAllocator *)(arg1)->getInternalManifoldPool(); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +btPoolAllocator *_wrap_btCollisionDispatcher_getInternalManifoldPool__SWIG_1_mbt_e879218550ba2e2b(btCollisionDispatcher *_swig_go_0) { + btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = *(btCollisionDispatcher **)&_swig_go_0; + + result = (btPoolAllocator *)((btCollisionDispatcher const *)arg1)->getInternalManifoldPool(); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +btCollisionPairCallback *_wrap_new_btCollisionPairCallback_mbt_e879218550ba2e2b(btDispatcherInfo *_swig_go_0, btCollisionDispatcher *_swig_go_1) { + btDispatcherInfo *arg1 = 0 ; + btCollisionDispatcher *arg2 = (btCollisionDispatcher *) 0 ; + btCollisionPairCallback *result = 0 ; + btCollisionPairCallback *_swig_go_result; + + arg1 = *(btDispatcherInfo **)&_swig_go_0; + arg2 = *(btCollisionDispatcher **)&_swig_go_1; + + result = (btCollisionPairCallback *)new btCollisionPairCallback((btDispatcherInfo const &)*arg1,arg2); + *(btCollisionPairCallback **)&_swig_go_result = (btCollisionPairCallback *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCollisionPairCallback_mbt_e879218550ba2e2b(btCollisionPairCallback *_swig_go_0) { + btCollisionPairCallback *arg1 = (btCollisionPairCallback *) 0 ; + + arg1 = *(btCollisionPairCallback **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btCollisionPairCallback_processOverlap_mbt_e879218550ba2e2b(btCollisionPairCallback *_swig_go_0, btBroadphasePair *_swig_go_1) { + btCollisionPairCallback *arg1 = (btCollisionPairCallback *) 0 ; + btBroadphasePair *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionPairCallback **)&_swig_go_0; + arg2 = *(btBroadphasePair **)&_swig_go_1; + + result = (bool)(arg1)->processOverlap(*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btCollisionWorld *_wrap_new_btCollisionWorld_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, btBroadphaseInterface *_swig_go_1, btCollisionConfiguration *_swig_go_2) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btBroadphaseInterface *arg2 = (btBroadphaseInterface *) 0 ; + btCollisionConfiguration *arg3 = (btCollisionConfiguration *) 0 ; + btCollisionWorld *result = 0 ; + btCollisionWorld *_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(btBroadphaseInterface **)&_swig_go_1; + arg3 = *(btCollisionConfiguration **)&_swig_go_2; + + result = (btCollisionWorld *)new btCollisionWorld(arg1,arg2,arg3); + *(btCollisionWorld **)&_swig_go_result = (btCollisionWorld *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCollisionWorld_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btCollisionWorld_setBroadphase_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btBroadphaseInterface *_swig_go_1) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btBroadphaseInterface *arg2 = (btBroadphaseInterface *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btBroadphaseInterface **)&_swig_go_1; + + (arg1)->setBroadphase(arg2); + +} + + +btBroadphaseInterface *_wrap_btCollisionWorld_getBroadphase__SWIG_0_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btBroadphaseInterface *result = 0 ; + btBroadphaseInterface *_swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (btBroadphaseInterface *)((btCollisionWorld const *)arg1)->getBroadphase(); + *(btBroadphaseInterface **)&_swig_go_result = (btBroadphaseInterface *)result; + return _swig_go_result; +} + + +btBroadphaseInterface *_wrap_btCollisionWorld_getBroadphase__SWIG_1_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btBroadphaseInterface *result = 0 ; + btBroadphaseInterface *_swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (btBroadphaseInterface *)(arg1)->getBroadphase(); + *(btBroadphaseInterface **)&_swig_go_result = (btBroadphaseInterface *)result; + return _swig_go_result; +} + + +btOverlappingPairCache *_wrap_btCollisionWorld_getPairCache_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btOverlappingPairCache *result = 0 ; + btOverlappingPairCache *_swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (btOverlappingPairCache *)(arg1)->getPairCache(); + *(btOverlappingPairCache **)&_swig_go_result = (btOverlappingPairCache *)result; + return _swig_go_result; +} + + +btDispatcher *_wrap_btCollisionWorld_getDispatcher__SWIG_0_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btDispatcher *result = 0 ; + btDispatcher *_swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (btDispatcher *)(arg1)->getDispatcher(); + *(btDispatcher **)&_swig_go_result = (btDispatcher *)result; + return _swig_go_result; +} + + +btDispatcher *_wrap_btCollisionWorld_getDispatcher__SWIG_1_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btDispatcher *result = 0 ; + btDispatcher *_swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (btDispatcher *)((btCollisionWorld const *)arg1)->getDispatcher(); + *(btDispatcher **)&_swig_go_result = (btDispatcher *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionWorld_updateSingleAabb_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + (arg1)->updateSingleAabb(arg2); + +} + + +void _wrap_btCollisionWorld_updateAabbs_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + (arg1)->updateAabbs(); + +} + + +void _wrap_btCollisionWorld_computeOverlappingPairs_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + (arg1)->computeOverlappingPairs(); + +} + + +void _wrap_btCollisionWorld_setDebugDrawer_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btIDebugDraw *_swig_go_1) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btIDebugDraw *arg2 = (btIDebugDraw *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btIDebugDraw **)&_swig_go_1; + + (arg1)->setDebugDrawer(arg2); + +} + + +btIDebugDraw *_wrap_btCollisionWorld_getDebugDrawer_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btIDebugDraw *result = 0 ; + btIDebugDraw *_swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (btIDebugDraw *)(arg1)->getDebugDrawer(); + *(btIDebugDraw **)&_swig_go_result = (btIDebugDraw *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionWorld_debugDrawWorld_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + (arg1)->debugDrawWorld(); + +} + + +void _wrap_btCollisionWorld_debugDrawObject_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btTransform *_swig_go_1, btCollisionShape *_swig_go_2, btVector3 *_swig_go_3) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btTransform *arg2 = 0 ; + btCollisionShape *arg3 = (btCollisionShape *) 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btCollisionShape **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->debugDrawObject((btTransform const &)*arg2,(btCollisionShape const *)arg3,(btVector3 const &)*arg4); + +} + + +intgo _wrap_btCollisionWorld_getNumCollisionObjects_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (int)((btCollisionWorld const *)arg1)->getNumCollisionObjects(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionWorld_rayTest_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btCollisionWorld::RayResultCallback *_swig_go_3) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btCollisionWorld::RayResultCallback *arg4 = 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btCollisionWorld::RayResultCallback **)&_swig_go_3; + + ((btCollisionWorld const *)arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); + +} + + +void _wrap_btCollisionWorld_convexSweepTest__SWIG_0_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btConvexShape *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btCollisionWorld::ConvexResultCallback *_swig_go_4, float _swig_go_5) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btCollisionWorld::ConvexResultCallback *arg5 = 0 ; + btScalar arg6 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + ((btCollisionWorld const *)arg1)->convexSweepTest((btConvexShape const *)arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,*arg5,arg6); + +} + + +void _wrap_btCollisionWorld_convexSweepTest__SWIG_1_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btConvexShape *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btCollisionWorld::ConvexResultCallback *_swig_go_4) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btCollisionWorld::ConvexResultCallback *arg5 = 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_4; + + ((btCollisionWorld const *)arg1)->convexSweepTest((btConvexShape const *)arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,*arg5); + +} + + +void _wrap_btCollisionWorld_contactTest_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionWorld::ContactResultCallback *_swig_go_2) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionWorld::ContactResultCallback *arg3 = 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionWorld::ContactResultCallback **)&_swig_go_2; + + (arg1)->contactTest(arg2,*arg3); + +} + + +void _wrap_btCollisionWorld_contactPairTest_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btCollisionWorld::ContactResultCallback *_swig_go_3) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btCollisionWorld::ContactResultCallback *arg4 = 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btCollisionWorld::ContactResultCallback **)&_swig_go_3; + + (arg1)->contactPairTest(arg2,arg3,*arg4); + +} + + +void _wrap_btCollisionWorld_rayTestSingle_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1, btCollisionObject *_swig_go_2, btCollisionShape *_swig_go_3, btTransform *_swig_go_4, btCollisionWorld::RayResultCallback *_swig_go_5) { + btTransform *arg1 = 0 ; + btTransform *arg2 = 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btCollisionShape *arg4 = (btCollisionShape *) 0 ; + btTransform *arg5 = 0 ; + btCollisionWorld::RayResultCallback *arg6 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btCollisionShape **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btCollisionWorld::RayResultCallback **)&_swig_go_5; + + btCollisionWorld::rayTestSingle((btTransform const &)*arg1,(btTransform const &)*arg2,arg3,(btCollisionShape const *)arg4,(btTransform const &)*arg5,*arg6); + +} + + +void _wrap_btCollisionWorld_rayTestSingleInternal_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionWorld::RayResultCallback *_swig_go_3) { + btTransform *arg1 = 0 ; + btTransform *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionWorld::RayResultCallback *arg4 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionWorld::RayResultCallback **)&_swig_go_3; + + btCollisionWorld::rayTestSingleInternal((btTransform const &)*arg1,(btTransform const &)*arg2,(btCollisionObjectWrapper const *)arg3,*arg4); + +} + + +void _wrap_btCollisionWorld_objectQuerySingle_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btCollisionObject *_swig_go_3, btCollisionShape *_swig_go_4, btTransform *_swig_go_5, btCollisionWorld::ConvexResultCallback *_swig_go_6, float _swig_go_7) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btCollisionObject *arg4 = (btCollisionObject *) 0 ; + btCollisionShape *arg5 = (btCollisionShape *) 0 ; + btTransform *arg6 = 0 ; + btCollisionWorld::ConvexResultCallback *arg7 = 0 ; + btScalar arg8 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btCollisionObject **)&_swig_go_3; + arg5 = *(btCollisionShape **)&_swig_go_4; + arg6 = *(btTransform **)&_swig_go_5; + arg7 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_6; + arg8 = (btScalar)_swig_go_7; + + btCollisionWorld::objectQuerySingle((btConvexShape const *)arg1,(btTransform const &)*arg2,(btTransform const &)*arg3,arg4,(btCollisionShape const *)arg5,(btTransform const &)*arg6,*arg7,arg8); + +} + + +void _wrap_btCollisionWorld_objectQuerySingleInternal_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btCollisionObjectWrapper *_swig_go_3, btCollisionWorld::ConvexResultCallback *_swig_go_4, float _swig_go_5) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + btCollisionWorld::ConvexResultCallback *arg5 = 0 ; + btScalar arg6 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + arg5 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + btCollisionWorld::objectQuerySingleInternal((btConvexShape const *)arg1,(btTransform const &)*arg2,(btTransform const &)*arg3,(btCollisionObjectWrapper const *)arg4,*arg5,arg6); + +} + + +void _wrap_btCollisionWorld_addCollisionObject__SWIG_0_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btCollisionObject *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->addCollisionObject(arg2,arg3,arg4); + +} + + +void _wrap_btCollisionWorld_addCollisionObject__SWIG_1_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btCollisionObject *_swig_go_1, intgo _swig_go_2) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + int arg3 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->addCollisionObject(arg2,arg3); + +} + + +void _wrap_btCollisionWorld_addCollisionObject__SWIG_2_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + (arg1)->addCollisionObject(arg2); + +} + + +void _wrap_btCollisionWorld_refreshBroadphaseProxy_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + (arg1)->refreshBroadphaseProxy(arg2); + +} + + +btAlignedObjectArray< btCollisionObject * > *_wrap_btCollisionWorld_getCollisionObjectArray__SWIG_0_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btCollisionObjectArray *result = 0 ; + btAlignedObjectArray< btCollisionObject * > *_swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (btCollisionObjectArray *) &(arg1)->getCollisionObjectArray(); + *(btCollisionObjectArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btCollisionObject * > *_wrap_btCollisionWorld_getCollisionObjectArray__SWIG_1_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btCollisionObjectArray *result = 0 ; + btAlignedObjectArray< btCollisionObject * > *_swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (btCollisionObjectArray *) &((btCollisionWorld const *)arg1)->getCollisionObjectArray(); + *(btCollisionObjectArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionWorld_removeCollisionObject_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + (arg1)->removeCollisionObject(arg2); + +} + + +void _wrap_btCollisionWorld_performDiscreteCollisionDetection_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + (arg1)->performDiscreteCollisionDetection(); + +} + + +btDispatcherInfo *_wrap_btCollisionWorld_getDispatchInfo__SWIG_0_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btDispatcherInfo *result = 0 ; + btDispatcherInfo *_swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (btDispatcherInfo *) &(arg1)->getDispatchInfo(); + *(btDispatcherInfo **)&_swig_go_result = result; + return _swig_go_result; +} + + +btDispatcherInfo *_wrap_btCollisionWorld_getDispatchInfo__SWIG_1_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btDispatcherInfo *result = 0 ; + btDispatcherInfo *_swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (btDispatcherInfo *) &((btCollisionWorld const *)arg1)->getDispatchInfo(); + *(btDispatcherInfo **)&_swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btCollisionWorld_getForceUpdateAllAabbs_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + + result = (bool)((btCollisionWorld const *)arg1)->getForceUpdateAllAabbs(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionWorld_setForceUpdateAllAabbs_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, bool _swig_go_1) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + bool arg2 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setForceUpdateAllAabbs(arg2); + +} + + +void _wrap_btCollisionWorld_serialize_mbt_e879218550ba2e2b(btCollisionWorld *_swig_go_0, btSerializer *_swig_go_1) { + btCollisionWorld *arg1 = (btCollisionWorld *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btCollisionWorld **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + (arg1)->serialize(arg2); + +} + + +btUsageBitfield *_wrap_new_btUsageBitfield_mbt_e879218550ba2e2b() { + btUsageBitfield *result = 0 ; + btUsageBitfield *_swig_go_result; + + + result = (btUsageBitfield *)new btUsageBitfield(); + *(btUsageBitfield **)&_swig_go_result = (btUsageBitfield *)result; + return _swig_go_result; +} + + +void _wrap_btUsageBitfield_reset_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + + (arg1)->reset(); + +} + + +void _wrap_btUsageBitfield_usedVertexA_set_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0, short _swig_go_1) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short arg2 ; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + arg2 = (unsigned short)_swig_go_1; + + if (arg1) (arg1)->usedVertexA = arg2; + +} + + +short _wrap_btUsageBitfield_usedVertexA_get_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short result; + short _swig_go_result; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + + result = (unsigned short) ((arg1)->usedVertexA); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btUsageBitfield_usedVertexB_set_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0, short _swig_go_1) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short arg2 ; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + arg2 = (unsigned short)_swig_go_1; + + if (arg1) (arg1)->usedVertexB = arg2; + +} + + +short _wrap_btUsageBitfield_usedVertexB_get_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short result; + short _swig_go_result; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + + result = (unsigned short) ((arg1)->usedVertexB); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btUsageBitfield_usedVertexC_set_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0, short _swig_go_1) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short arg2 ; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + arg2 = (unsigned short)_swig_go_1; + + if (arg1) (arg1)->usedVertexC = arg2; + +} + + +short _wrap_btUsageBitfield_usedVertexC_get_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short result; + short _swig_go_result; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + + result = (unsigned short) ((arg1)->usedVertexC); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btUsageBitfield_usedVertexD_set_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0, short _swig_go_1) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short arg2 ; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + arg2 = (unsigned short)_swig_go_1; + + if (arg1) (arg1)->usedVertexD = arg2; + +} + + +short _wrap_btUsageBitfield_usedVertexD_get_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short result; + short _swig_go_result; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + + result = (unsigned short) ((arg1)->usedVertexD); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btUsageBitfield_unused1_set_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0, short _swig_go_1) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short arg2 ; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + arg2 = (unsigned short)_swig_go_1; + + if (arg1) (arg1)->unused1 = arg2; + +} + + +short _wrap_btUsageBitfield_unused1_get_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short result; + short _swig_go_result; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + + result = (unsigned short) ((arg1)->unused1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btUsageBitfield_unused2_set_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0, short _swig_go_1) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short arg2 ; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + arg2 = (unsigned short)_swig_go_1; + + if (arg1) (arg1)->unused2 = arg2; + +} + + +short _wrap_btUsageBitfield_unused2_get_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short result; + short _swig_go_result; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + + result = (unsigned short) ((arg1)->unused2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btUsageBitfield_unused3_set_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0, short _swig_go_1) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short arg2 ; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + arg2 = (unsigned short)_swig_go_1; + + if (arg1) (arg1)->unused3 = arg2; + +} + + +short _wrap_btUsageBitfield_unused3_get_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short result; + short _swig_go_result; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + + result = (unsigned short) ((arg1)->unused3); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btUsageBitfield_unused4_set_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0, short _swig_go_1) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short arg2 ; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + arg2 = (unsigned short)_swig_go_1; + + if (arg1) (arg1)->unused4 = arg2; + +} + + +short _wrap_btUsageBitfield_unused4_get_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + unsigned short result; + short _swig_go_result; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + + result = (unsigned short) ((arg1)->unused4); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btUsageBitfield_mbt_e879218550ba2e2b(btUsageBitfield *_swig_go_0) { + btUsageBitfield *arg1 = (btUsageBitfield *) 0 ; + + arg1 = *(btUsageBitfield **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btSubSimplexClosestResult_m_closestPointOnSimplex_set_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0, btVector3 *_swig_go_1) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_closestPointOnSimplex = *arg2; + +} + + +btVector3 *_wrap_btSubSimplexClosestResult_m_closestPointOnSimplex_get_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_closestPointOnSimplex); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSubSimplexClosestResult_m_usedVertices_set_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0, btUsageBitfield *_swig_go_1) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + btUsageBitfield *arg2 = (btUsageBitfield *) 0 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + arg2 = *(btUsageBitfield **)&_swig_go_1; + + if (arg1) (arg1)->m_usedVertices = *arg2; + +} + + +btUsageBitfield *_wrap_btSubSimplexClosestResult_m_usedVertices_get_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + btUsageBitfield *result = 0 ; + btUsageBitfield *_swig_go_result; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + + result = (btUsageBitfield *)& ((arg1)->m_usedVertices); + *(btUsageBitfield **)&_swig_go_result = (btUsageBitfield *)result; + return _swig_go_result; +} + + +void _wrap_btSubSimplexClosestResult_m_barycentricCoords_set_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0, float *_swig_go_1) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + btScalar *arg2 = (btScalar *) (btScalar *)0 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + { + size_t ii; + btScalar *b = (btScalar *) arg1->m_barycentricCoords; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btScalar *) arg2 + ii); + } + +} + + +float *_wrap_btSubSimplexClosestResult_m_barycentricCoords_get_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + btScalar *result = 0 ; + float *_swig_go_result; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + + result = (btScalar *)(btScalar *) ((arg1)->m_barycentricCoords); + *(btScalar **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSubSimplexClosestResult_m_degenerate_set_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0, bool _swig_go_1) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + bool arg2 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_degenerate = arg2; + +} + + +bool _wrap_btSubSimplexClosestResult_m_degenerate_get_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + + result = (bool) ((arg1)->m_degenerate); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSubSimplexClosestResult_reset_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + + (arg1)->reset(); + +} + + +bool _wrap_btSubSimplexClosestResult_isValid_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + + result = (bool)(arg1)->isValid(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_0_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar arg4 ; + btScalar arg5 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + + (arg1)->setBarycentricCoordinates(arg2,arg3,arg4,arg5); + +} + + +void _wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_1_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar arg4 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->setBarycentricCoordinates(arg2,arg3,arg4); + +} + + +void _wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_2_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setBarycentricCoordinates(arg2,arg3); + +} + + +void _wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_3_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0, float _swig_go_1) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + btScalar arg2 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setBarycentricCoordinates(arg2); + +} + + +void _wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_4_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + + (arg1)->setBarycentricCoordinates(); + +} + + +btSubSimplexClosestResult *_wrap_new_btSubSimplexClosestResult_mbt_e879218550ba2e2b() { + btSubSimplexClosestResult *result = 0 ; + btSubSimplexClosestResult *_swig_go_result; + + + result = (btSubSimplexClosestResult *)new btSubSimplexClosestResult(); + *(btSubSimplexClosestResult **)&_swig_go_result = (btSubSimplexClosestResult *)result; + return _swig_go_result; +} + + +void _wrap_delete_btSubSimplexClosestResult_mbt_e879218550ba2e2b(btSubSimplexClosestResult *_swig_go_0) { + btSubSimplexClosestResult *arg1 = (btSubSimplexClosestResult *) 0 ; + + arg1 = *(btSubSimplexClosestResult **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btVoronoiSimplexSolver_m_numVertices_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, intgo _swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + int arg2 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numVertices = arg2; + +} + + +intgo _wrap_btVoronoiSimplexSolver_m_numVertices_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (int) ((arg1)->m_numVertices); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_simplexVectorW_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 (*_swig_go_1)[5]) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = (btVector3 *) (btVector3 *)0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + { + size_t ii; + btVector3 *b = (btVector3 *) arg1->m_simplexVectorW; + for (ii = 0; ii < (size_t)5; ii++) b[ii] = *((btVector3 *) arg2 + ii); + } + +} + + +btVector3 (*_wrap_btVoronoiSimplexSolver_m_simplexVectorW_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0))[5] { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *result = 0 ; + btVector3 (*_swig_go_result)[5]; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btVector3 *)(btVector3 *) ((arg1)->m_simplexVectorW); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_simplexPointsP_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 (*_swig_go_1)[5]) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = (btVector3 *) (btVector3 *)0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + { + size_t ii; + btVector3 *b = (btVector3 *) arg1->m_simplexPointsP; + for (ii = 0; ii < (size_t)5; ii++) b[ii] = *((btVector3 *) arg2 + ii); + } + +} + + +btVector3 (*_wrap_btVoronoiSimplexSolver_m_simplexPointsP_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0))[5] { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *result = 0 ; + btVector3 (*_swig_go_result)[5]; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btVector3 *)(btVector3 *) ((arg1)->m_simplexPointsP); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_simplexPointsQ_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 (*_swig_go_1)[5]) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = (btVector3 *) (btVector3 *)0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + { + size_t ii; + btVector3 *b = (btVector3 *) arg1->m_simplexPointsQ; + for (ii = 0; ii < (size_t)5; ii++) b[ii] = *((btVector3 *) arg2 + ii); + } + +} + + +btVector3 (*_wrap_btVoronoiSimplexSolver_m_simplexPointsQ_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0))[5] { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *result = 0 ; + btVector3 (*_swig_go_result)[5]; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btVector3 *)(btVector3 *) ((arg1)->m_simplexPointsQ); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_cachedP1_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_cachedP1 = *arg2; + +} + + +btVector3 *_wrap_btVoronoiSimplexSolver_m_cachedP1_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_cachedP1); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_cachedP2_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_cachedP2 = *arg2; + +} + + +btVector3 *_wrap_btVoronoiSimplexSolver_m_cachedP2_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_cachedP2); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_cachedV_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_cachedV = *arg2; + +} + + +btVector3 *_wrap_btVoronoiSimplexSolver_m_cachedV_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_cachedV); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_lastW_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_lastW = *arg2; + +} + + +btVector3 *_wrap_btVoronoiSimplexSolver_m_lastW_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_lastW); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_equalVertexThreshold_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, float _swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btScalar arg2 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_equalVertexThreshold = arg2; + +} + + +float _wrap_btVoronoiSimplexSolver_m_equalVertexThreshold_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_equalVertexThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_cachedValidClosest_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, bool _swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + bool arg2 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_cachedValidClosest = arg2; + +} + + +bool _wrap_btVoronoiSimplexSolver_m_cachedValidClosest_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (bool) ((arg1)->m_cachedValidClosest); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_cachedBC_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btSubSimplexClosestResult *_swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btSubSimplexClosestResult *arg2 = (btSubSimplexClosestResult *) 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btSubSimplexClosestResult **)&_swig_go_1; + + if (arg1) (arg1)->m_cachedBC = *arg2; + +} + + +btSubSimplexClosestResult *_wrap_btVoronoiSimplexSolver_m_cachedBC_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btSubSimplexClosestResult *result = 0 ; + btSubSimplexClosestResult *_swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btSubSimplexClosestResult *)& ((arg1)->m_cachedBC); + *(btSubSimplexClosestResult **)&_swig_go_result = (btSubSimplexClosestResult *)result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_m_needsUpdate_set_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, bool _swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + bool arg2 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_needsUpdate = arg2; + +} + + +bool _wrap_btVoronoiSimplexSolver_m_needsUpdate_get_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (bool) ((arg1)->m_needsUpdate); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_removeVertex_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, intgo _swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + int arg2 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->removeVertex(arg2); + +} + + +void _wrap_btVoronoiSimplexSolver_reduceVertices_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btUsageBitfield *_swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btUsageBitfield *arg2 = 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btUsageBitfield **)&_swig_go_1; + + (arg1)->reduceVertices((btUsageBitfield const &)*arg2); + +} + + +bool _wrap_btVoronoiSimplexSolver_updateClosestVectorAndPoints_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (bool)(arg1)->updateClosestVectorAndPoints(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btVoronoiSimplexSolver_closestPtPointTetrahedron_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, btSubSimplexClosestResult *_swig_go_6) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btSubSimplexClosestResult *arg7 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btSubSimplexClosestResult **)&_swig_go_6; + + result = (bool)(arg1)->closestPtPointTetrahedron((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,*arg7); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVoronoiSimplexSolver_pointOutsideOfPlane_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + result = (int)(arg1)->pointOutsideOfPlane((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btVoronoiSimplexSolver_closestPtPointTriangle_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, btSubSimplexClosestResult *_swig_go_5) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btSubSimplexClosestResult *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btSubSimplexClosestResult **)&_swig_go_5; + + result = (bool)(arg1)->closestPtPointTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +btVoronoiSimplexSolver *_wrap_new_btVoronoiSimplexSolver_mbt_e879218550ba2e2b() { + btVoronoiSimplexSolver *result = 0 ; + btVoronoiSimplexSolver *_swig_go_result; + + + result = (btVoronoiSimplexSolver *)new btVoronoiSimplexSolver(); + *(btVoronoiSimplexSolver **)&_swig_go_result = (btVoronoiSimplexSolver *)result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_reset_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + (arg1)->reset(); + +} + + +void _wrap_btVoronoiSimplexSolver_addVertex_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->addVertex((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btVoronoiSimplexSolver_setEqualVertexThreshold_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, float _swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btScalar arg2 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setEqualVertexThreshold(arg2); + +} + + +float _wrap_btVoronoiSimplexSolver_getEqualVertexThreshold_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btScalar)((btVoronoiSimplexSolver const *)arg1)->getEqualVertexThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btVoronoiSimplexSolver_closest_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (bool)(arg1)->closest(*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btVoronoiSimplexSolver_maxVertex_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (btScalar)(arg1)->maxVertex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btVoronoiSimplexSolver_fullSimplex_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (bool)((btVoronoiSimplexSolver const *)arg1)->fullSimplex(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btVoronoiSimplexSolver_getSimplex_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + btVector3 *arg4 = (btVector3 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = (int)((btVoronoiSimplexSolver const *)arg1)->getSimplex(arg2,arg3,arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btVoronoiSimplexSolver_inSimplex_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (bool)(arg1)->inSimplex((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_backup_closest_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->backup_closest(*arg2); + +} + + +bool _wrap_btVoronoiSimplexSolver_emptySimplex_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (bool)((btVoronoiSimplexSolver const *)arg1)->emptySimplex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btVoronoiSimplexSolver_compute_points_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->compute_points(*arg2,*arg3); + +} + + +intgo _wrap_btVoronoiSimplexSolver_numVertices_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + result = (int)((btVoronoiSimplexSolver const *)arg1)->numVertices(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btVoronoiSimplexSolver_mbt_e879218550ba2e2b(btVoronoiSimplexSolver *_swig_go_0) { + btVoronoiSimplexSolver *arg1 = (btVoronoiSimplexSolver *) 0 ; + + arg1 = *(btVoronoiSimplexSolver **)&_swig_go_0; + + delete arg1; + +} + + +btGjkEpaPenetrationDepthSolver *_wrap_new_btGjkEpaPenetrationDepthSolver_mbt_e879218550ba2e2b() { + btGjkEpaPenetrationDepthSolver *result = 0 ; + btGjkEpaPenetrationDepthSolver *_swig_go_result; + + + result = (btGjkEpaPenetrationDepthSolver *)new btGjkEpaPenetrationDepthSolver(); + *(btGjkEpaPenetrationDepthSolver **)&_swig_go_result = (btGjkEpaPenetrationDepthSolver *)result; + return _swig_go_result; +} + + +bool _wrap_btGjkEpaPenetrationDepthSolver_calcPenDepth_mbt_e879218550ba2e2b(btGjkEpaPenetrationDepthSolver *_swig_go_0, btVoronoiSimplexSolver *_swig_go_1, btConvexShape *_swig_go_2, btConvexShape *_swig_go_3, btTransform *_swig_go_4, btTransform *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7, btVector3 *_swig_go_8, btIDebugDraw *_swig_go_9) { + btGjkEpaPenetrationDepthSolver *arg1 = (btGjkEpaPenetrationDepthSolver *) 0 ; + btVoronoiSimplexSolver *arg2 = 0 ; + btConvexShape *arg3 = (btConvexShape *) 0 ; + btConvexShape *arg4 = (btConvexShape *) 0 ; + btTransform *arg5 = 0 ; + btTransform *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + btVector3 *arg9 = 0 ; + btIDebugDraw *arg10 = (btIDebugDraw *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGjkEpaPenetrationDepthSolver **)&_swig_go_0; + arg2 = *(btVoronoiSimplexSolver **)&_swig_go_1; + arg3 = *(btConvexShape **)&_swig_go_2; + arg4 = *(btConvexShape **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btTransform **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = *(btVector3 **)&_swig_go_8; + arg10 = *(btIDebugDraw **)&_swig_go_9; + + result = (bool)(arg1)->calcPenDepth(*arg2,(btConvexShape const *)arg3,(btConvexShape const *)arg4,(btTransform const &)*arg5,(btTransform const &)*arg6,*arg7,*arg8,*arg9,arg10); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btGjkEpaPenetrationDepthSolver_mbt_e879218550ba2e2b(btGjkEpaPenetrationDepthSolver *_swig_go_0) { + btGjkEpaPenetrationDepthSolver *arg1 = (btGjkEpaPenetrationDepthSolver *) 0 ; + + arg1 = *(btGjkEpaPenetrationDepthSolver **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_delete_btTriangleCallback_mbt_e879218550ba2e2b(btTriangleCallback *_swig_go_0) { + btTriangleCallback *arg1 = (btTriangleCallback *) 0 ; + + arg1 = *(btTriangleCallback **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btTriangleCallback_processTriangle_mbt_e879218550ba2e2b(btTriangleCallback *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btTriangleCallback *arg1 = (btTriangleCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(btTriangleCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->processTriangle(arg2,arg3,arg4); + +} + + +void _wrap_delete_btInternalTriangleIndexCallback_mbt_e879218550ba2e2b(btInternalTriangleIndexCallback *_swig_go_0) { + btInternalTriangleIndexCallback *arg1 = (btInternalTriangleIndexCallback *) 0 ; + + arg1 = *(btInternalTriangleIndexCallback **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btInternalTriangleIndexCallback_internalProcessTriangleIndex_mbt_e879218550ba2e2b(btInternalTriangleIndexCallback *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btInternalTriangleIndexCallback *arg1 = (btInternalTriangleIndexCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(btInternalTriangleIndexCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->internalProcessTriangleIndex(arg2,arg3,arg4); + +} + + +intgo _wrap_PHY_FLOAT_mbt_e879218550ba2e2b() { + PHY_ScalarType result; + intgo _swig_go_result; + + + result = PHY_FLOAT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_PHY_DOUBLE_mbt_e879218550ba2e2b() { + PHY_ScalarType result; + intgo _swig_go_result; + + + result = PHY_DOUBLE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_PHY_INTEGER_mbt_e879218550ba2e2b() { + PHY_ScalarType result; + intgo _swig_go_result; + + + result = PHY_INTEGER; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_PHY_SHORT_mbt_e879218550ba2e2b() { + PHY_ScalarType result; + intgo _swig_go_result; + + + result = PHY_SHORT; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_PHY_FIXEDPOINT88_mbt_e879218550ba2e2b() { + PHY_ScalarType result; + intgo _swig_go_result; + + + result = PHY_FIXEDPOINT88; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_PHY_UCHAR_mbt_e879218550ba2e2b() { + PHY_ScalarType result; + intgo _swig_go_result; + + + result = PHY_UCHAR; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_delete_btConcaveShape_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConcaveShape_processAllTriangles_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, btTriangleCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btTriangleCallback *arg2 = (btTriangleCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = *(btTriangleCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btConcaveShape const *)arg1)->processAllTriangles(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +float _wrap_btConcaveShape_getMargin_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + result = (btScalar)((btConcaveShape const *)arg1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConcaveShape_setMargin_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, float _swig_go_1) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setMargin(arg2); + +} + + +void _wrap_btConcaveShape_getAabb_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + ((btCollisionShape const *)swig_b0)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btConcaveShape_getBoundingSphere_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + ((btCollisionShape const *)swig_b0)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btConcaveShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (btScalar)((btCollisionShape const *)swig_b0)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConcaveShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, float _swig_go_1) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (btScalar)((btCollisionShape const *)swig_b0)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConcaveShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + ((btCollisionShape const *)swig_b0)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btConcaveShape_isPolyhedral_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConcaveShape_isConvex2d_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConcaveShape_isConvex_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConcaveShape_isNonMoving_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConcaveShape_isConcave_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConcaveShape_isCompound_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConcaveShape_isSoftBody_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConcaveShape_isInfinite_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (bool)((btCollisionShape const *)swig_b0)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConcaveShape_setLocalScaling_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, btVector3 *_swig_go_1) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + (swig_b0)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btConcaveShape_getLocalScaling_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (btVector3 *) &((btCollisionShape const *)swig_b0)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConcaveShape_calculateLocalInertia_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + ((btCollisionShape const *)swig_b0)->calculateLocalInertia(arg2,*arg3); + +} + + +_gostring_ _wrap_btConcaveShape_getName_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (char *)((btCollisionShape const *)swig_b0)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btConcaveShape_getShapeType_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (int)((btCollisionShape const *)swig_b0)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btConcaveShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = ((btCollisionShape const *)swig_b0)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btConcaveShape_setUserPointer_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, void *_swig_go_1) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + (swig_b0)->setUserPointer(arg2); + +} + + +void *_wrap_btConcaveShape_getUserPointer_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (void *)((btCollisionShape const *)swig_b0)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btConcaveShape_setUserIndex_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, intgo _swig_go_1) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + int arg2 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + (swig_b0)->setUserIndex(arg2); + +} + + +intgo _wrap_btConcaveShape_getUserIndex_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (int)((btCollisionShape const *)swig_b0)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConcaveShape_setUserIndex2_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, intgo _swig_go_1) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + int arg2 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + (swig_b0)->setUserIndex2(arg2); + +} + + +intgo _wrap_btConcaveShape_getUserIndex2_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (int)((btCollisionShape const *)swig_b0)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConcaveShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (int)((btCollisionShape const *)swig_b0)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btConcaveShape_serialize_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + result = (char *)((btCollisionShape const *)swig_b0)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btConcaveShape_serializeSingleShape_mbt_e879218550ba2e2b(btConcaveShape *_swig_go_0, btSerializer *_swig_go_1) { + btConcaveShape *arg1 = (btConcaveShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btConcaveShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btCollisionShape *swig_b0 = (btCollisionShape *)arg1; + ((btCollisionShape const *)swig_b0)->serializeSingleShape(arg2); + +} + + +void _wrap_delete_btStridingMeshInterface_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btStridingMeshInterface_InternalProcessAllTriangles_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, btInternalTriangleIndexCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + btInternalTriangleIndexCallback *arg2 = (btInternalTriangleIndexCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = *(btInternalTriangleIndexCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btStridingMeshInterface const *)arg1)->InternalProcessAllTriangles(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btStridingMeshInterface_calculateAabbBruteForce_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->calculateAabbBruteForce(*arg2,*arg3); + +} + + +void _wrap_btStridingMeshInterface_getLockedVertexIndexBase__SWIG_0_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, char **_swig_go_1, intgo *_swig_go_2, PHY_ScalarType *_swig_go_3, intgo *_swig_go_4, char **_swig_go_5, intgo *_swig_go_6, intgo *_swig_go_7, PHY_ScalarType *_swig_go_8, intgo _swig_go_9) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + unsigned char **arg2 = (unsigned char **) 0 ; + int *arg3 = 0 ; + PHY_ScalarType *arg4 = 0 ; + int *arg5 = 0 ; + unsigned char **arg6 = (unsigned char **) 0 ; + int *arg7 = 0 ; + int *arg8 = 0 ; + PHY_ScalarType *arg9 = 0 ; + int arg10 ; + int e3 ; + int e5 ; + int e7 ; + int e8 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = *(unsigned char ***)&_swig_go_1; + + e3 = (int)*_swig_go_2; + arg3 = &e3; + + arg4 = *(PHY_ScalarType **)&_swig_go_3; + + e5 = (int)*_swig_go_4; + arg5 = &e5; + + arg6 = *(unsigned char ***)&_swig_go_5; + + e7 = (int)*_swig_go_6; + arg7 = &e7; + + + e8 = (int)*_swig_go_7; + arg8 = &e8; + + arg9 = *(PHY_ScalarType **)&_swig_go_8; + arg10 = (int)_swig_go_9; + + (arg1)->getLockedVertexIndexBase(arg2,*arg3,*arg4,*arg5,arg6,*arg7,*arg8,*arg9,arg10); + + *_swig_go_2 = (intgo)e3; + *_swig_go_4 = (intgo)e5; + *_swig_go_6 = (intgo)e7; + *_swig_go_7 = (intgo)e8; +} + + +void _wrap_btStridingMeshInterface_getLockedVertexIndexBase__SWIG_1_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, char **_swig_go_1, intgo *_swig_go_2, PHY_ScalarType *_swig_go_3, intgo *_swig_go_4, char **_swig_go_5, intgo *_swig_go_6, intgo *_swig_go_7, PHY_ScalarType *_swig_go_8) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + unsigned char **arg2 = (unsigned char **) 0 ; + int *arg3 = 0 ; + PHY_ScalarType *arg4 = 0 ; + int *arg5 = 0 ; + unsigned char **arg6 = (unsigned char **) 0 ; + int *arg7 = 0 ; + int *arg8 = 0 ; + PHY_ScalarType *arg9 = 0 ; + int e3 ; + int e5 ; + int e7 ; + int e8 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = *(unsigned char ***)&_swig_go_1; + + e3 = (int)*_swig_go_2; + arg3 = &e3; + + arg4 = *(PHY_ScalarType **)&_swig_go_3; + + e5 = (int)*_swig_go_4; + arg5 = &e5; + + arg6 = *(unsigned char ***)&_swig_go_5; + + e7 = (int)*_swig_go_6; + arg7 = &e7; + + + e8 = (int)*_swig_go_7; + arg8 = &e8; + + arg9 = *(PHY_ScalarType **)&_swig_go_8; + + (arg1)->getLockedVertexIndexBase(arg2,*arg3,*arg4,*arg5,arg6,*arg7,*arg8,*arg9); + + *_swig_go_2 = (intgo)e3; + *_swig_go_4 = (intgo)e5; + *_swig_go_6 = (intgo)e7; + *_swig_go_7 = (intgo)e8; +} + + +void _wrap_btStridingMeshInterface_getLockedReadOnlyVertexIndexBase__SWIG_0_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, char **_swig_go_1, intgo *_swig_go_2, PHY_ScalarType *_swig_go_3, intgo *_swig_go_4, char **_swig_go_5, intgo *_swig_go_6, intgo *_swig_go_7, PHY_ScalarType *_swig_go_8, intgo _swig_go_9) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + unsigned char **arg2 = (unsigned char **) 0 ; + int *arg3 = 0 ; + PHY_ScalarType *arg4 = 0 ; + int *arg5 = 0 ; + unsigned char **arg6 = (unsigned char **) 0 ; + int *arg7 = 0 ; + int *arg8 = 0 ; + PHY_ScalarType *arg9 = 0 ; + int arg10 ; + int e3 ; + int e5 ; + int e7 ; + int e8 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = *(unsigned char ***)&_swig_go_1; + + e3 = (int)*_swig_go_2; + arg3 = &e3; + + arg4 = *(PHY_ScalarType **)&_swig_go_3; + + e5 = (int)*_swig_go_4; + arg5 = &e5; + + arg6 = *(unsigned char ***)&_swig_go_5; + + e7 = (int)*_swig_go_6; + arg7 = &e7; + + + e8 = (int)*_swig_go_7; + arg8 = &e8; + + arg9 = *(PHY_ScalarType **)&_swig_go_8; + arg10 = (int)_swig_go_9; + + ((btStridingMeshInterface const *)arg1)->getLockedReadOnlyVertexIndexBase((unsigned char const **)arg2,*arg3,*arg4,*arg5,(unsigned char const **)arg6,*arg7,*arg8,*arg9,arg10); + + *_swig_go_2 = (intgo)e3; + *_swig_go_4 = (intgo)e5; + *_swig_go_6 = (intgo)e7; + *_swig_go_7 = (intgo)e8; +} + + +void _wrap_btStridingMeshInterface_getLockedReadOnlyVertexIndexBase__SWIG_1_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, char **_swig_go_1, intgo *_swig_go_2, PHY_ScalarType *_swig_go_3, intgo *_swig_go_4, char **_swig_go_5, intgo *_swig_go_6, intgo *_swig_go_7, PHY_ScalarType *_swig_go_8) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + unsigned char **arg2 = (unsigned char **) 0 ; + int *arg3 = 0 ; + PHY_ScalarType *arg4 = 0 ; + int *arg5 = 0 ; + unsigned char **arg6 = (unsigned char **) 0 ; + int *arg7 = 0 ; + int *arg8 = 0 ; + PHY_ScalarType *arg9 = 0 ; + int e3 ; + int e5 ; + int e7 ; + int e8 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = *(unsigned char ***)&_swig_go_1; + + e3 = (int)*_swig_go_2; + arg3 = &e3; + + arg4 = *(PHY_ScalarType **)&_swig_go_3; + + e5 = (int)*_swig_go_4; + arg5 = &e5; + + arg6 = *(unsigned char ***)&_swig_go_5; + + e7 = (int)*_swig_go_6; + arg7 = &e7; + + + e8 = (int)*_swig_go_7; + arg8 = &e8; + + arg9 = *(PHY_ScalarType **)&_swig_go_8; + + ((btStridingMeshInterface const *)arg1)->getLockedReadOnlyVertexIndexBase((unsigned char const **)arg2,*arg3,*arg4,*arg5,(unsigned char const **)arg6,*arg7,*arg8,*arg9); + + *_swig_go_2 = (intgo)e3; + *_swig_go_4 = (intgo)e5; + *_swig_go_6 = (intgo)e7; + *_swig_go_7 = (intgo)e8; +} + + +void _wrap_btStridingMeshInterface_unLockVertexBase_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, intgo _swig_go_1) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + int arg2 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->unLockVertexBase(arg2); + +} + + +void _wrap_btStridingMeshInterface_unLockReadOnlyVertexBase_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, intgo _swig_go_1) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + int arg2 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + ((btStridingMeshInterface const *)arg1)->unLockReadOnlyVertexBase(arg2); + +} + + +intgo _wrap_btStridingMeshInterface_getNumSubParts_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + + result = (int)((btStridingMeshInterface const *)arg1)->getNumSubParts(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btStridingMeshInterface_preallocateVertices_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, intgo _swig_go_1) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + int arg2 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->preallocateVertices(arg2); + +} + + +void _wrap_btStridingMeshInterface_preallocateIndices_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, intgo _swig_go_1) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + int arg2 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->preallocateIndices(arg2); + +} + + +bool _wrap_btStridingMeshInterface_hasPremadeAabb_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + + result = (bool)((btStridingMeshInterface const *)arg1)->hasPremadeAabb(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btStridingMeshInterface_setPremadeAabb_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btStridingMeshInterface const *)arg1)->setPremadeAabb((btVector3 const &)*arg2,(btVector3 const &)*arg3); + +} + + +void _wrap_btStridingMeshInterface_getPremadeAabb_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + btVector3 *arg3 = (btVector3 *) 0 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btStridingMeshInterface const *)arg1)->getPremadeAabb(arg2,arg3); + +} + + +btVector3 *_wrap_btStridingMeshInterface_getScaling_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + + result = (btVector3 *) &((btStridingMeshInterface const *)arg1)->getScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btStridingMeshInterface_setScaling_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, btVector3 *_swig_go_1) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setScaling((btVector3 const &)*arg2); + +} + + +intgo _wrap_btStridingMeshInterface_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + + result = (int)((btStridingMeshInterface const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btStridingMeshInterface_serialize_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btStridingMeshInterface const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btIntIndexData_m_value_set_mbt_e879218550ba2e2b(btIntIndexData *_swig_go_0, intgo _swig_go_1) { + btIntIndexData *arg1 = (btIntIndexData *) 0 ; + int arg2 ; + + arg1 = *(btIntIndexData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_value = arg2; + +} + + +intgo _wrap_btIntIndexData_m_value_get_mbt_e879218550ba2e2b(btIntIndexData *_swig_go_0) { + btIntIndexData *arg1 = (btIntIndexData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btIntIndexData **)&_swig_go_0; + + result = (int) ((arg1)->m_value); + _swig_go_result = result; + return _swig_go_result; +} + + +btIntIndexData *_wrap_new_btIntIndexData_mbt_e879218550ba2e2b() { + btIntIndexData *result = 0 ; + btIntIndexData *_swig_go_result; + + + result = (btIntIndexData *)new btIntIndexData(); + *(btIntIndexData **)&_swig_go_result = (btIntIndexData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btIntIndexData_mbt_e879218550ba2e2b(btIntIndexData *_swig_go_0) { + btIntIndexData *arg1 = (btIntIndexData *) 0 ; + + arg1 = *(btIntIndexData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btShortIntIndexData_m_value_set_mbt_e879218550ba2e2b(btShortIntIndexData *_swig_go_0, short _swig_go_1) { + btShortIntIndexData *arg1 = (btShortIntIndexData *) 0 ; + short arg2 ; + + arg1 = *(btShortIntIndexData **)&_swig_go_0; + arg2 = (short)_swig_go_1; + + if (arg1) (arg1)->m_value = arg2; + +} + + +short _wrap_btShortIntIndexData_m_value_get_mbt_e879218550ba2e2b(btShortIntIndexData *_swig_go_0) { + btShortIntIndexData *arg1 = (btShortIntIndexData *) 0 ; + short result; + short _swig_go_result; + + arg1 = *(btShortIntIndexData **)&_swig_go_0; + + result = (short) ((arg1)->m_value); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btShortIntIndexData_m_pad_set_mbt_e879218550ba2e2b(btShortIntIndexData *_swig_go_0, _gostring_ _swig_go_1) { + btShortIntIndexData *arg1 = (btShortIntIndexData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btShortIntIndexData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_pad, (const char *)arg2, 2-1); + arg1->m_pad[2-1] = 0; + } else { + arg1->m_pad[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btShortIntIndexData_m_pad_get_mbt_e879218550ba2e2b(btShortIntIndexData *_swig_go_0) { + btShortIntIndexData *arg1 = (btShortIntIndexData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btShortIntIndexData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_pad); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btShortIntIndexData *_wrap_new_btShortIntIndexData_mbt_e879218550ba2e2b() { + btShortIntIndexData *result = 0 ; + btShortIntIndexData *_swig_go_result; + + + result = (btShortIntIndexData *)new btShortIntIndexData(); + *(btShortIntIndexData **)&_swig_go_result = (btShortIntIndexData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btShortIntIndexData_mbt_e879218550ba2e2b(btShortIntIndexData *_swig_go_0) { + btShortIntIndexData *arg1 = (btShortIntIndexData *) 0 ; + + arg1 = *(btShortIntIndexData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btShortIntIndexTripletData_m_values_set_mbt_e879218550ba2e2b(btShortIntIndexTripletData *_swig_go_0, short *_swig_go_1) { + btShortIntIndexTripletData *arg1 = (btShortIntIndexTripletData *) 0 ; + short *arg2 = (short *) (short *)0 ; + + arg1 = *(btShortIntIndexTripletData **)&_swig_go_0; + arg2 = *(short **)&_swig_go_1; + + { + size_t ii; + short *b = (short *) arg1->m_values; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((short *) arg2 + ii); + } + +} + + +short *_wrap_btShortIntIndexTripletData_m_values_get_mbt_e879218550ba2e2b(btShortIntIndexTripletData *_swig_go_0) { + btShortIntIndexTripletData *arg1 = (btShortIntIndexTripletData *) 0 ; + short *result = 0 ; + short *_swig_go_result; + + arg1 = *(btShortIntIndexTripletData **)&_swig_go_0; + + result = (short *)(short *) ((arg1)->m_values); + *(short **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btShortIntIndexTripletData_m_pad_set_mbt_e879218550ba2e2b(btShortIntIndexTripletData *_swig_go_0, _gostring_ _swig_go_1) { + btShortIntIndexTripletData *arg1 = (btShortIntIndexTripletData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btShortIntIndexTripletData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_pad, (const char *)arg2, 2-1); + arg1->m_pad[2-1] = 0; + } else { + arg1->m_pad[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btShortIntIndexTripletData_m_pad_get_mbt_e879218550ba2e2b(btShortIntIndexTripletData *_swig_go_0) { + btShortIntIndexTripletData *arg1 = (btShortIntIndexTripletData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btShortIntIndexTripletData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_pad); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btShortIntIndexTripletData *_wrap_new_btShortIntIndexTripletData_mbt_e879218550ba2e2b() { + btShortIntIndexTripletData *result = 0 ; + btShortIntIndexTripletData *_swig_go_result; + + + result = (btShortIntIndexTripletData *)new btShortIntIndexTripletData(); + *(btShortIntIndexTripletData **)&_swig_go_result = (btShortIntIndexTripletData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btShortIntIndexTripletData_mbt_e879218550ba2e2b(btShortIntIndexTripletData *_swig_go_0) { + btShortIntIndexTripletData *arg1 = (btShortIntIndexTripletData *) 0 ; + + arg1 = *(btShortIntIndexTripletData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btCharIndexTripletData_m_values_set_mbt_e879218550ba2e2b(btCharIndexTripletData *_swig_go_0, char *_swig_go_1) { + btCharIndexTripletData *arg1 = (btCharIndexTripletData *) 0 ; + unsigned char *arg2 = (unsigned char *) (unsigned char *)0 ; + + arg1 = *(btCharIndexTripletData **)&_swig_go_0; + arg2 = *(unsigned char **)&_swig_go_1; + + { + size_t ii; + unsigned char *b = (unsigned char *) arg1->m_values; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned char *) arg2 + ii); + } + +} + + +char *_wrap_btCharIndexTripletData_m_values_get_mbt_e879218550ba2e2b(btCharIndexTripletData *_swig_go_0) { + btCharIndexTripletData *arg1 = (btCharIndexTripletData *) 0 ; + unsigned char *result = 0 ; + char *_swig_go_result; + + arg1 = *(btCharIndexTripletData **)&_swig_go_0; + + result = (unsigned char *)(unsigned char *) ((arg1)->m_values); + *(unsigned char **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCharIndexTripletData_m_pad_set_mbt_e879218550ba2e2b(btCharIndexTripletData *_swig_go_0, char _swig_go_1) { + btCharIndexTripletData *arg1 = (btCharIndexTripletData *) 0 ; + char arg2 ; + + arg1 = *(btCharIndexTripletData **)&_swig_go_0; + arg2 = (char)_swig_go_1; + + if (arg1) (arg1)->m_pad = arg2; + +} + + +char _wrap_btCharIndexTripletData_m_pad_get_mbt_e879218550ba2e2b(btCharIndexTripletData *_swig_go_0) { + btCharIndexTripletData *arg1 = (btCharIndexTripletData *) 0 ; + char result; + char _swig_go_result; + + arg1 = *(btCharIndexTripletData **)&_swig_go_0; + + result = (char) ((arg1)->m_pad); + _swig_go_result = result; + return _swig_go_result; +} + + +btCharIndexTripletData *_wrap_new_btCharIndexTripletData_mbt_e879218550ba2e2b() { + btCharIndexTripletData *result = 0 ; + btCharIndexTripletData *_swig_go_result; + + + result = (btCharIndexTripletData *)new btCharIndexTripletData(); + *(btCharIndexTripletData **)&_swig_go_result = (btCharIndexTripletData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCharIndexTripletData_mbt_e879218550ba2e2b(btCharIndexTripletData *_swig_go_0) { + btCharIndexTripletData *arg1 = (btCharIndexTripletData *) 0 ; + + arg1 = *(btCharIndexTripletData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btMeshPartData_m_vertices3f_set_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btMeshPartData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_vertices3f = arg2; + +} + + +btVector3FloatData *_wrap_btMeshPartData_m_vertices3f_get_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btMeshPartData **)&_swig_go_0; + + result = (btVector3FloatData *) ((arg1)->m_vertices3f); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btMeshPartData_m_vertices3d_set_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btMeshPartData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_vertices3d = arg2; + +} + + +btVector3DoubleData *_wrap_btMeshPartData_m_vertices3d_get_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btMeshPartData **)&_swig_go_0; + + result = (btVector3DoubleData *) ((arg1)->m_vertices3d); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btMeshPartData_m_indices32_set_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0, btIntIndexData *_swig_go_1) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btIntIndexData *arg2 = (btIntIndexData *) 0 ; + + arg1 = *(btMeshPartData **)&_swig_go_0; + arg2 = *(btIntIndexData **)&_swig_go_1; + + if (arg1) (arg1)->m_indices32 = arg2; + +} + + +btIntIndexData *_wrap_btMeshPartData_m_indices32_get_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btIntIndexData *result = 0 ; + btIntIndexData *_swig_go_result; + + arg1 = *(btMeshPartData **)&_swig_go_0; + + result = (btIntIndexData *) ((arg1)->m_indices32); + *(btIntIndexData **)&_swig_go_result = (btIntIndexData *)result; + return _swig_go_result; +} + + +void _wrap_btMeshPartData_m_3indices16_set_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0, btShortIntIndexTripletData *_swig_go_1) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btShortIntIndexTripletData *arg2 = (btShortIntIndexTripletData *) 0 ; + + arg1 = *(btMeshPartData **)&_swig_go_0; + arg2 = *(btShortIntIndexTripletData **)&_swig_go_1; + + if (arg1) (arg1)->m_3indices16 = arg2; + +} + + +btShortIntIndexTripletData *_wrap_btMeshPartData_m_3indices16_get_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btShortIntIndexTripletData *result = 0 ; + btShortIntIndexTripletData *_swig_go_result; + + arg1 = *(btMeshPartData **)&_swig_go_0; + + result = (btShortIntIndexTripletData *) ((arg1)->m_3indices16); + *(btShortIntIndexTripletData **)&_swig_go_result = (btShortIntIndexTripletData *)result; + return _swig_go_result; +} + + +void _wrap_btMeshPartData_m_3indices8_set_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0, btCharIndexTripletData *_swig_go_1) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btCharIndexTripletData *arg2 = (btCharIndexTripletData *) 0 ; + + arg1 = *(btMeshPartData **)&_swig_go_0; + arg2 = *(btCharIndexTripletData **)&_swig_go_1; + + if (arg1) (arg1)->m_3indices8 = arg2; + +} + + +btCharIndexTripletData *_wrap_btMeshPartData_m_3indices8_get_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btCharIndexTripletData *result = 0 ; + btCharIndexTripletData *_swig_go_result; + + arg1 = *(btMeshPartData **)&_swig_go_0; + + result = (btCharIndexTripletData *) ((arg1)->m_3indices8); + *(btCharIndexTripletData **)&_swig_go_result = (btCharIndexTripletData *)result; + return _swig_go_result; +} + + +void _wrap_btMeshPartData_m_indices16_set_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0, btShortIntIndexData *_swig_go_1) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btShortIntIndexData *arg2 = (btShortIntIndexData *) 0 ; + + arg1 = *(btMeshPartData **)&_swig_go_0; + arg2 = *(btShortIntIndexData **)&_swig_go_1; + + if (arg1) (arg1)->m_indices16 = arg2; + +} + + +btShortIntIndexData *_wrap_btMeshPartData_m_indices16_get_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + btShortIntIndexData *result = 0 ; + btShortIntIndexData *_swig_go_result; + + arg1 = *(btMeshPartData **)&_swig_go_0; + + result = (btShortIntIndexData *) ((arg1)->m_indices16); + *(btShortIntIndexData **)&_swig_go_result = (btShortIntIndexData *)result; + return _swig_go_result; +} + + +void _wrap_btMeshPartData_m_numTriangles_set_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0, intgo _swig_go_1) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + int arg2 ; + + arg1 = *(btMeshPartData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numTriangles = arg2; + +} + + +intgo _wrap_btMeshPartData_m_numTriangles_get_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btMeshPartData **)&_swig_go_0; + + result = (int) ((arg1)->m_numTriangles); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btMeshPartData_m_numVertices_set_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0, intgo _swig_go_1) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + int arg2 ; + + arg1 = *(btMeshPartData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numVertices = arg2; + +} + + +intgo _wrap_btMeshPartData_m_numVertices_get_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btMeshPartData **)&_swig_go_0; + + result = (int) ((arg1)->m_numVertices); + _swig_go_result = result; + return _swig_go_result; +} + + +btMeshPartData *_wrap_new_btMeshPartData_mbt_e879218550ba2e2b() { + btMeshPartData *result = 0 ; + btMeshPartData *_swig_go_result; + + + result = (btMeshPartData *)new btMeshPartData(); + *(btMeshPartData **)&_swig_go_result = (btMeshPartData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btMeshPartData_mbt_e879218550ba2e2b(btMeshPartData *_swig_go_0) { + btMeshPartData *arg1 = (btMeshPartData *) 0 ; + + arg1 = *(btMeshPartData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btStridingMeshInterfaceData_m_meshPartsPtr_set_mbt_e879218550ba2e2b(btStridingMeshInterfaceData *_swig_go_0, btMeshPartData *_swig_go_1) { + btStridingMeshInterfaceData *arg1 = (btStridingMeshInterfaceData *) 0 ; + btMeshPartData *arg2 = (btMeshPartData *) 0 ; + + arg1 = *(btStridingMeshInterfaceData **)&_swig_go_0; + arg2 = *(btMeshPartData **)&_swig_go_1; + + if (arg1) (arg1)->m_meshPartsPtr = arg2; + +} + + +btMeshPartData *_wrap_btStridingMeshInterfaceData_m_meshPartsPtr_get_mbt_e879218550ba2e2b(btStridingMeshInterfaceData *_swig_go_0) { + btStridingMeshInterfaceData *arg1 = (btStridingMeshInterfaceData *) 0 ; + btMeshPartData *result = 0 ; + btMeshPartData *_swig_go_result; + + arg1 = *(btStridingMeshInterfaceData **)&_swig_go_0; + + result = (btMeshPartData *) ((arg1)->m_meshPartsPtr); + *(btMeshPartData **)&_swig_go_result = (btMeshPartData *)result; + return _swig_go_result; +} + + +void _wrap_btStridingMeshInterfaceData_m_scaling_set_mbt_e879218550ba2e2b(btStridingMeshInterfaceData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btStridingMeshInterfaceData *arg1 = (btStridingMeshInterfaceData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btStridingMeshInterfaceData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_scaling = *arg2; + +} + + +btVector3FloatData *_wrap_btStridingMeshInterfaceData_m_scaling_get_mbt_e879218550ba2e2b(btStridingMeshInterfaceData *_swig_go_0) { + btStridingMeshInterfaceData *arg1 = (btStridingMeshInterfaceData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btStridingMeshInterfaceData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_scaling); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btStridingMeshInterfaceData_m_numMeshParts_set_mbt_e879218550ba2e2b(btStridingMeshInterfaceData *_swig_go_0, intgo _swig_go_1) { + btStridingMeshInterfaceData *arg1 = (btStridingMeshInterfaceData *) 0 ; + int arg2 ; + + arg1 = *(btStridingMeshInterfaceData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numMeshParts = arg2; + +} + + +intgo _wrap_btStridingMeshInterfaceData_m_numMeshParts_get_mbt_e879218550ba2e2b(btStridingMeshInterfaceData *_swig_go_0) { + btStridingMeshInterfaceData *arg1 = (btStridingMeshInterfaceData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btStridingMeshInterfaceData **)&_swig_go_0; + + result = (int) ((arg1)->m_numMeshParts); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btStridingMeshInterfaceData_m_padding_set_mbt_e879218550ba2e2b(btStridingMeshInterfaceData *_swig_go_0, _gostring_ _swig_go_1) { + btStridingMeshInterfaceData *arg1 = (btStridingMeshInterfaceData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btStridingMeshInterfaceData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_padding, (const char *)arg2, 4-1); + arg1->m_padding[4-1] = 0; + } else { + arg1->m_padding[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btStridingMeshInterfaceData_m_padding_get_mbt_e879218550ba2e2b(btStridingMeshInterfaceData *_swig_go_0) { + btStridingMeshInterfaceData *arg1 = (btStridingMeshInterfaceData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btStridingMeshInterfaceData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_padding); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btStridingMeshInterfaceData *_wrap_new_btStridingMeshInterfaceData_mbt_e879218550ba2e2b() { + btStridingMeshInterfaceData *result = 0 ; + btStridingMeshInterfaceData *_swig_go_result; + + + result = (btStridingMeshInterfaceData *)new btStridingMeshInterfaceData(); + *(btStridingMeshInterfaceData **)&_swig_go_result = (btStridingMeshInterfaceData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btStridingMeshInterfaceData_mbt_e879218550ba2e2b(btStridingMeshInterfaceData *_swig_go_0) { + btStridingMeshInterfaceData *arg1 = (btStridingMeshInterfaceData *) 0 ; + + arg1 = *(btStridingMeshInterfaceData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_delete_btTriangleMeshShape_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + delete arg1; + +} + + +btVector3 *_wrap_btTriangleMeshShape_localGetSupportingVertex_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, btVector3 *_swig_go_1) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btTriangleMeshShape const *)arg1)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btTriangleMeshShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, btVector3 *_swig_go_1) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btTriangleMeshShape const *)arg1)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShape_recalcLocalAabb_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + (arg1)->recalcLocalAabb(); + +} + + +void _wrap_btTriangleMeshShape_getAabb_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btTriangleMeshShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btTriangleMeshShape_processAllTriangles_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, btTriangleCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btTriangleCallback *arg2 = (btTriangleCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = *(btTriangleCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btTriangleMeshShape const *)arg1)->processAllTriangles(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btTriangleMeshShape_calculateLocalInertia_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btTriangleMeshShape const *)arg1)->calculateLocalInertia(arg2,*arg3); + +} + + +void _wrap_btTriangleMeshShape_setLocalScaling_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, btVector3 *_swig_go_1) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btTriangleMeshShape_getLocalScaling_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + result = (btVector3 *) &((btTriangleMeshShape const *)arg1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btStridingMeshInterface *_wrap_btTriangleMeshShape_getMeshInterface__SWIG_0_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btStridingMeshInterface *result = 0 ; + btStridingMeshInterface *_swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + result = (btStridingMeshInterface *)(arg1)->getMeshInterface(); + *(btStridingMeshInterface **)&_swig_go_result = (btStridingMeshInterface *)result; + return _swig_go_result; +} + + +btStridingMeshInterface *_wrap_btTriangleMeshShape_getMeshInterface__SWIG_1_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btStridingMeshInterface *result = 0 ; + btStridingMeshInterface *_swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + result = (btStridingMeshInterface *)((btTriangleMeshShape const *)arg1)->getMeshInterface(); + *(btStridingMeshInterface **)&_swig_go_result = (btStridingMeshInterface *)result; + return _swig_go_result; +} + + +btVector3 *_wrap_btTriangleMeshShape_getLocalAabbMin_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + result = (btVector3 *) &((btTriangleMeshShape const *)arg1)->getLocalAabbMin(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btTriangleMeshShape_getLocalAabbMax_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + result = (btVector3 *) &((btTriangleMeshShape const *)arg1)->getLocalAabbMax(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btTriangleMeshShape_getName_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + result = (char *)((btTriangleMeshShape const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +float _wrap_btTriangleMeshShape_getMargin_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + result = (btScalar)((btConcaveShape const *)swig_b0)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShape_setMargin_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, float _swig_go_1) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + (swig_b0)->setMargin(arg2); + +} + + +void _wrap_btTriangleMeshShape_getBoundingSphere_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btTriangleMeshShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (btScalar)((btCollisionShape const *)swig_b1)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btTriangleMeshShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, float _swig_go_1) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (btScalar)((btCollisionShape const *)swig_b1)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btTriangleMeshShape_isPolyhedral_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btTriangleMeshShape_isConvex2d_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btTriangleMeshShape_isConvex_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btTriangleMeshShape_isNonMoving_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btTriangleMeshShape_isConcave_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btTriangleMeshShape_isCompound_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btTriangleMeshShape_isSoftBody_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btTriangleMeshShape_isInfinite_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btTriangleMeshShape_getShapeType_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btTriangleMeshShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = ((btCollisionShape const *)swig_b1)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShape_setUserPointer_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, void *_swig_go_1) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserPointer(arg2); + +} + + +void *_wrap_btTriangleMeshShape_getUserPointer_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (void *)((btCollisionShape const *)swig_b1)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShape_setUserIndex_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, intgo _swig_go_1) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + int arg2 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserIndex(arg2); + +} + + +intgo _wrap_btTriangleMeshShape_getUserIndex_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShape_setUserIndex2_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, intgo _swig_go_1) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + int arg2 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserIndex2(arg2); + +} + + +intgo _wrap_btTriangleMeshShape_getUserIndex2_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btTriangleMeshShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btTriangleMeshShape_serialize_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (char *)((btCollisionShape const *)swig_b1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShape_serializeSingleShape_mbt_e879218550ba2e2b(btTriangleMeshShape *_swig_go_0, btSerializer *_swig_go_1) { + btTriangleMeshShape *arg1 = (btTriangleMeshShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btTriangleMeshShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->serializeSingleShape(arg2); + +} + + +void _wrap_btQuantizedBvhNode_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0, short *_swig_go_1) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + unsigned short *arg2 = (unsigned short *) (unsigned short *)0 ; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + + { + size_t ii; + unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMin; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); + } + +} + + +short *_wrap_btQuantizedBvhNode_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + unsigned short *result = 0 ; + short *_swig_go_result; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + + result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMin); + *(unsigned short **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhNode_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0, short *_swig_go_1) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + unsigned short *arg2 = (unsigned short *) (unsigned short *)0 ; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + + { + size_t ii; + unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMax; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); + } + +} + + +short *_wrap_btQuantizedBvhNode_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + unsigned short *result = 0 ; + short *_swig_go_result; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + + result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMax); + *(unsigned short **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhNode_m_escapeIndexOrTriangleIndex_set_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_escapeIndexOrTriangleIndex = arg2; + +} + + +intgo _wrap_btQuantizedBvhNode_m_escapeIndexOrTriangleIndex_get_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + + result = (int) ((arg1)->m_escapeIndexOrTriangleIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btQuantizedBvhNode_isLeafNode_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + + result = (bool)((btQuantizedBvhNode const *)arg1)->isLeafNode(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btQuantizedBvhNode_getEscapeIndex_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + + result = (int)((btQuantizedBvhNode const *)arg1)->getEscapeIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btQuantizedBvhNode_getTriangleIndex_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + + result = (int)((btQuantizedBvhNode const *)arg1)->getTriangleIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btQuantizedBvhNode_getPartId_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + + result = (int)((btQuantizedBvhNode const *)arg1)->getPartId(); + _swig_go_result = result; + return _swig_go_result; +} + + +btQuantizedBvhNode *_wrap_new_btQuantizedBvhNode_mbt_e879218550ba2e2b() { + btQuantizedBvhNode *result = 0 ; + btQuantizedBvhNode *_swig_go_result; + + + result = (btQuantizedBvhNode *)new btQuantizedBvhNode(); + *(btQuantizedBvhNode **)&_swig_go_result = (btQuantizedBvhNode *)result; + return _swig_go_result; +} + + +void _wrap_delete_btQuantizedBvhNode_mbt_e879218550ba2e2b(btQuantizedBvhNode *_swig_go_0) { + btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; + + arg1 = *(btQuantizedBvhNode **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btOptimizedBvhNode_m_aabbMinOrg_set_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0, btVector3 *_swig_go_1) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_aabbMinOrg = *arg2; + +} + + +btVector3 *_wrap_btOptimizedBvhNode_m_aabbMinOrg_get_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_aabbMinOrg); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNode_m_aabbMaxOrg_set_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0, btVector3 *_swig_go_1) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_aabbMaxOrg = *arg2; + +} + + +btVector3 *_wrap_btOptimizedBvhNode_m_aabbMaxOrg_get_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_aabbMaxOrg); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNode_m_escapeIndex_set_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0, intgo _swig_go_1) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + int arg2 ; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_escapeIndex = arg2; + +} + + +intgo _wrap_btOptimizedBvhNode_m_escapeIndex_get_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + + result = (int) ((arg1)->m_escapeIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNode_m_subPart_set_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0, intgo _swig_go_1) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + int arg2 ; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_subPart = arg2; + +} + + +intgo _wrap_btOptimizedBvhNode_m_subPart_get_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + + result = (int) ((arg1)->m_subPart); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNode_m_triangleIndex_set_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0, intgo _swig_go_1) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + int arg2 ; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_triangleIndex = arg2; + +} + + +intgo _wrap_btOptimizedBvhNode_m_triangleIndex_get_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + + result = (int) ((arg1)->m_triangleIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNode_m_padding_set_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0, _gostring_ _swig_go_1) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_padding, (const char *)arg2, 20-1); + arg1->m_padding[20-1] = 0; + } else { + arg1->m_padding[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btOptimizedBvhNode_m_padding_get_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_padding); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btOptimizedBvhNode *_wrap_new_btOptimizedBvhNode_mbt_e879218550ba2e2b() { + btOptimizedBvhNode *result = 0 ; + btOptimizedBvhNode *_swig_go_result; + + + result = (btOptimizedBvhNode *)new btOptimizedBvhNode(); + *(btOptimizedBvhNode **)&_swig_go_result = (btOptimizedBvhNode *)result; + return _swig_go_result; +} + + +void _wrap_delete_btOptimizedBvhNode_mbt_e879218550ba2e2b(btOptimizedBvhNode *_swig_go_0) { + btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; + + arg1 = *(btOptimizedBvhNode **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btBvhSubtreeInfo_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0, short *_swig_go_1) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + unsigned short *arg2 = (unsigned short *) (unsigned short *)0 ; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + + { + size_t ii; + unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMin; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); + } + +} + + +short *_wrap_btBvhSubtreeInfo_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + unsigned short *result = 0 ; + short *_swig_go_result; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + + result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMin); + *(unsigned short **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhSubtreeInfo_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0, short *_swig_go_1) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + unsigned short *arg2 = (unsigned short *) (unsigned short *)0 ; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + + { + size_t ii; + unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMax; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); + } + +} + + +short *_wrap_btBvhSubtreeInfo_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + unsigned short *result = 0 ; + short *_swig_go_result; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + + result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMax); + *(unsigned short **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhSubtreeInfo_m_rootNodeIndex_set_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0, intgo _swig_go_1) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + int arg2 ; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_rootNodeIndex = arg2; + +} + + +intgo _wrap_btBvhSubtreeInfo_m_rootNodeIndex_get_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + + result = (int) ((arg1)->m_rootNodeIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhSubtreeInfo_m_subtreeSize_set_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0, intgo _swig_go_1) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + int arg2 ; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_subtreeSize = arg2; + +} + + +intgo _wrap_btBvhSubtreeInfo_m_subtreeSize_get_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + + result = (int) ((arg1)->m_subtreeSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhSubtreeInfo_m_padding_set_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0, intgo *_swig_go_1) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_padding; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btBvhSubtreeInfo_m_padding_get_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_padding); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +btBvhSubtreeInfo *_wrap_new_btBvhSubtreeInfo_mbt_e879218550ba2e2b() { + btBvhSubtreeInfo *result = 0 ; + btBvhSubtreeInfo *_swig_go_result; + + + result = (btBvhSubtreeInfo *)new btBvhSubtreeInfo(); + *(btBvhSubtreeInfo **)&_swig_go_result = (btBvhSubtreeInfo *)result; + return _swig_go_result; +} + + +void _wrap_btBvhSubtreeInfo_setAabbFromQuantizeNode_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0, btQuantizedBvhNode *_swig_go_1) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + btQuantizedBvhNode *arg2 = 0 ; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + arg2 = *(btQuantizedBvhNode **)&_swig_go_1; + + (arg1)->setAabbFromQuantizeNode((btQuantizedBvhNode const &)*arg2); + +} + + +void _wrap_delete_btBvhSubtreeInfo_mbt_e879218550ba2e2b(btBvhSubtreeInfo *_swig_go_0) { + btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; + + arg1 = *(btBvhSubtreeInfo **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_delete_btNodeOverlapCallback_mbt_e879218550ba2e2b(btNodeOverlapCallback *_swig_go_0) { + btNodeOverlapCallback *arg1 = (btNodeOverlapCallback *) 0 ; + + arg1 = *(btNodeOverlapCallback **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btNodeOverlapCallback_processNode_mbt_e879218550ba2e2b(btNodeOverlapCallback *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btNodeOverlapCallback *arg1 = (btNodeOverlapCallback *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btNodeOverlapCallback **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->processNode(arg2,arg3); + +} + + +intgo _wrap_TRAVERSAL_STACKLESS_btQuantizedBvh_mbt_e879218550ba2e2b() { + btQuantizedBvh::btTraversalMode result; + intgo _swig_go_result; + + + result = btQuantizedBvh::TRAVERSAL_STACKLESS; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_TRAVERSAL_STACKLESS_CACHE_FRIENDLY_btQuantizedBvh_mbt_e879218550ba2e2b() { + btQuantizedBvh::btTraversalMode result; + intgo _swig_go_result; + + + result = btQuantizedBvh::TRAVERSAL_STACKLESS_CACHE_FRIENDLY; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_TRAVERSAL_RECURSIVE_btQuantizedBvh_mbt_e879218550ba2e2b() { + btQuantizedBvh::btTraversalMode result; + intgo _swig_go_result; + + + result = btQuantizedBvh::TRAVERSAL_RECURSIVE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +btQuantizedBvh *_wrap_new_btQuantizedBvh_mbt_e879218550ba2e2b() { + btQuantizedBvh *result = 0 ; + btQuantizedBvh *_swig_go_result; + + + result = (btQuantizedBvh *)new btQuantizedBvh(); + *(btQuantizedBvh **)&_swig_go_result = (btQuantizedBvh *)result; + return _swig_go_result; +} + + +void _wrap_delete_btQuantizedBvh_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btQuantizedBvh_setQuantizationValues__SWIG_0_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->setQuantizationValues((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +void _wrap_btQuantizedBvh_setQuantizationValues__SWIG_1_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->setQuantizationValues((btVector3 const &)*arg2,(btVector3 const &)*arg3); + +} + + +btAlignedObjectArray< btQuantizedBvhNode > *_wrap_btQuantizedBvh_getLeafNodeArray_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + QuantizedNodeArray *result = 0 ; + btAlignedObjectArray< btQuantizedBvhNode > *_swig_go_result; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + + result = (QuantizedNodeArray *) &(arg1)->getLeafNodeArray(); + *(QuantizedNodeArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvh_buildInternal_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + + (arg1)->buildInternal(); + +} + + +void _wrap_btQuantizedBvh_reportAabbOverlappingNodex_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, btNodeOverlapCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + btNodeOverlapCallback *arg2 = (btNodeOverlapCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(btNodeOverlapCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btQuantizedBvh const *)arg1)->reportAabbOverlappingNodex(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btQuantizedBvh_reportRayOverlappingNodex_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, btNodeOverlapCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + btNodeOverlapCallback *arg2 = (btNodeOverlapCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(btNodeOverlapCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btQuantizedBvh const *)arg1)->reportRayOverlappingNodex(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btQuantizedBvh_reportBoxCastOverlappingNodex_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, btNodeOverlapCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + btNodeOverlapCallback *arg2 = (btNodeOverlapCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(btNodeOverlapCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + ((btQuantizedBvh const *)arg1)->reportBoxCastOverlappingNodex(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btQuantizedBvh_quantize_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, short *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + unsigned short *arg2 = (unsigned short *) 0 ; + btVector3 *arg3 = 0 ; + int arg4 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + ((btQuantizedBvh const *)arg1)->quantize(arg2,(btVector3 const &)*arg3,arg4); + +} + + +void _wrap_btQuantizedBvh_quantizeWithClamp_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, short *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + unsigned short *arg2 = (unsigned short *) 0 ; + btVector3 *arg3 = 0 ; + int arg4 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + ((btQuantizedBvh const *)arg1)->quantizeWithClamp(arg2,(btVector3 const &)*arg3,arg4); + +} + + +btVector3 *_wrap_btQuantizedBvh_unQuantize_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, short *_swig_go_1) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + unsigned short *arg2 = (unsigned short *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + + result = ((btQuantizedBvh const *)arg1)->unQuantize((unsigned short const *)arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btQuantizedBvh_setTraversalMode_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + btQuantizedBvh::btTraversalMode arg2 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = (btQuantizedBvh::btTraversalMode)_swig_go_1; + + (arg1)->setTraversalMode(arg2); + +} + + +btAlignedObjectArray< btQuantizedBvhNode > *_wrap_btQuantizedBvh_getQuantizedNodeArray_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + QuantizedNodeArray *result = 0 ; + btAlignedObjectArray< btQuantizedBvhNode > *_swig_go_result; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + + result = (QuantizedNodeArray *) &(arg1)->getQuantizedNodeArray(); + *(QuantizedNodeArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btBvhSubtreeInfo > *_wrap_btQuantizedBvh_getSubtreeInfoArray_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + BvhSubtreeInfoArray *result = 0 ; + btAlignedObjectArray< btBvhSubtreeInfo > *_swig_go_result; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + + result = (BvhSubtreeInfoArray *) &(arg1)->getSubtreeInfoArray(); + *(BvhSubtreeInfoArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btQuantizedBvh_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + + result = (unsigned int)((btQuantizedBvh const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btQuantizedBvh_serialize__SWIG_0_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, void *_swig_go_1, intgo _swig_go_2, bool _swig_go_3) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + void *arg2 = (void *) 0 ; + unsigned int arg3 ; + bool arg4 ; + bool result; + bool _swig_go_result; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = (unsigned int)_swig_go_2; + arg4 = (bool)_swig_go_3; + + result = (bool)((btQuantizedBvh const *)arg1)->serialize(arg2,arg3,arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +btQuantizedBvh *_wrap_btQuantizedBvh_deSerializeInPlace_mbt_e879218550ba2e2b(void *_swig_go_0, intgo _swig_go_1, bool _swig_go_2) { + void *arg1 = (void *) 0 ; + unsigned int arg2 ; + bool arg3 ; + btQuantizedBvh *result = 0 ; + btQuantizedBvh *_swig_go_result; + + arg1 = *(void **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + arg3 = (bool)_swig_go_2; + + result = (btQuantizedBvh *)btQuantizedBvh::deSerializeInPlace(arg1,arg2,arg3); + *(btQuantizedBvh **)&_swig_go_result = (btQuantizedBvh *)result; + return _swig_go_result; +} + + +intgo _wrap_btQuantizedBvh_getAlignmentSerializationPadding_mbt_e879218550ba2e2b() { + unsigned int result; + intgo _swig_go_result; + + + result = (unsigned int)btQuantizedBvh::getAlignmentSerializationPadding(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btQuantizedBvh_calculateSerializeBufferSizeNew_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + + result = (int)((btQuantizedBvh const *)arg1)->calculateSerializeBufferSizeNew(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btQuantizedBvh_serialize__SWIG_1_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btQuantizedBvh const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btQuantizedBvh_deSerializeFloat_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, btQuantizedBvhFloatData *_swig_go_1) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + btQuantizedBvhFloatData *arg2 = 0 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(btQuantizedBvhFloatData **)&_swig_go_1; + + (arg1)->deSerializeFloat(*arg2); + +} + + +void _wrap_btQuantizedBvh_deSerializeDouble_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0, btQuantizedBvhDoubleData *_swig_go_1) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + btQuantizedBvhDoubleData *arg2 = 0 ; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + arg2 = *(btQuantizedBvhDoubleData **)&_swig_go_1; + + (arg1)->deSerializeDouble(*arg2); + +} + + +bool _wrap_btQuantizedBvh_isQuantized_mbt_e879218550ba2e2b(btQuantizedBvh *_swig_go_0) { + btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btQuantizedBvh **)&_swig_go_0; + + result = (bool)(arg1)->isQuantized(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhSubtreeInfoData_m_rootNodeIndex_set_mbt_e879218550ba2e2b(btBvhSubtreeInfoData *_swig_go_0, intgo _swig_go_1) { + btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; + int arg2 ; + + arg1 = *(btBvhSubtreeInfoData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_rootNodeIndex = arg2; + +} + + +intgo _wrap_btBvhSubtreeInfoData_m_rootNodeIndex_get_mbt_e879218550ba2e2b(btBvhSubtreeInfoData *_swig_go_0) { + btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBvhSubtreeInfoData **)&_swig_go_0; + + result = (int) ((arg1)->m_rootNodeIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhSubtreeInfoData_m_subtreeSize_set_mbt_e879218550ba2e2b(btBvhSubtreeInfoData *_swig_go_0, intgo _swig_go_1) { + btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; + int arg2 ; + + arg1 = *(btBvhSubtreeInfoData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_subtreeSize = arg2; + +} + + +intgo _wrap_btBvhSubtreeInfoData_m_subtreeSize_get_mbt_e879218550ba2e2b(btBvhSubtreeInfoData *_swig_go_0) { + btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBvhSubtreeInfoData **)&_swig_go_0; + + result = (int) ((arg1)->m_subtreeSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhSubtreeInfoData_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(btBvhSubtreeInfoData *_swig_go_0, short *_swig_go_1) { + btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; + unsigned short *arg2 = (unsigned short *) (unsigned short *)0 ; + + arg1 = *(btBvhSubtreeInfoData **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + + { + size_t ii; + unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMin; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); + } + +} + + +short *_wrap_btBvhSubtreeInfoData_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(btBvhSubtreeInfoData *_swig_go_0) { + btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; + unsigned short *result = 0 ; + short *_swig_go_result; + + arg1 = *(btBvhSubtreeInfoData **)&_swig_go_0; + + result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMin); + *(unsigned short **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhSubtreeInfoData_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(btBvhSubtreeInfoData *_swig_go_0, short *_swig_go_1) { + btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; + unsigned short *arg2 = (unsigned short *) (unsigned short *)0 ; + + arg1 = *(btBvhSubtreeInfoData **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + + { + size_t ii; + unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMax; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); + } + +} + + +short *_wrap_btBvhSubtreeInfoData_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(btBvhSubtreeInfoData *_swig_go_0) { + btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; + unsigned short *result = 0 ; + short *_swig_go_result; + + arg1 = *(btBvhSubtreeInfoData **)&_swig_go_0; + + result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMax); + *(unsigned short **)&_swig_go_result = result; + return _swig_go_result; +} + + +btBvhSubtreeInfoData *_wrap_new_btBvhSubtreeInfoData_mbt_e879218550ba2e2b() { + btBvhSubtreeInfoData *result = 0 ; + btBvhSubtreeInfoData *_swig_go_result; + + + result = (btBvhSubtreeInfoData *)new btBvhSubtreeInfoData(); + *(btBvhSubtreeInfoData **)&_swig_go_result = (btBvhSubtreeInfoData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btBvhSubtreeInfoData_mbt_e879218550ba2e2b(btBvhSubtreeInfoData *_swig_go_0) { + btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; + + arg1 = *(btBvhSubtreeInfoData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btOptimizedBvhNodeFloatData_m_aabbMinOrg_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_aabbMinOrg = *arg2; + +} + + +btVector3FloatData *_wrap_btOptimizedBvhNodeFloatData_m_aabbMinOrg_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_aabbMinOrg); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNodeFloatData_m_aabbMaxOrg_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_aabbMaxOrg = *arg2; + +} + + +btVector3FloatData *_wrap_btOptimizedBvhNodeFloatData_m_aabbMaxOrg_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_aabbMaxOrg); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNodeFloatData_m_escapeIndex_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0, intgo _swig_go_1) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + int arg2 ; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_escapeIndex = arg2; + +} + + +intgo _wrap_btOptimizedBvhNodeFloatData_m_escapeIndex_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_escapeIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNodeFloatData_m_subPart_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0, intgo _swig_go_1) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + int arg2 ; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_subPart = arg2; + +} + + +intgo _wrap_btOptimizedBvhNodeFloatData_m_subPart_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_subPart); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNodeFloatData_m_triangleIndex_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0, intgo _swig_go_1) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + int arg2 ; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_triangleIndex = arg2; + +} + + +intgo _wrap_btOptimizedBvhNodeFloatData_m_triangleIndex_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_triangleIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNodeFloatData_m_pad_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0, _gostring_ _swig_go_1) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_pad, (const char *)arg2, 4-1); + arg1->m_pad[4-1] = 0; + } else { + arg1->m_pad[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btOptimizedBvhNodeFloatData_m_pad_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_pad); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btOptimizedBvhNodeFloatData *_wrap_new_btOptimizedBvhNodeFloatData_mbt_e879218550ba2e2b() { + btOptimizedBvhNodeFloatData *result = 0 ; + btOptimizedBvhNodeFloatData *_swig_go_result; + + + result = (btOptimizedBvhNodeFloatData *)new btOptimizedBvhNodeFloatData(); + *(btOptimizedBvhNodeFloatData **)&_swig_go_result = (btOptimizedBvhNodeFloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btOptimizedBvhNodeFloatData_mbt_e879218550ba2e2b(btOptimizedBvhNodeFloatData *_swig_go_0) { + btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; + + arg1 = *(btOptimizedBvhNodeFloatData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btOptimizedBvhNodeDoubleData_m_aabbMinOrg_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_aabbMinOrg = *arg2; + +} + + +btVector3DoubleData *_wrap_btOptimizedBvhNodeDoubleData_m_aabbMinOrg_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_aabbMinOrg); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNodeDoubleData_m_aabbMaxOrg_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_aabbMaxOrg = *arg2; + +} + + +btVector3DoubleData *_wrap_btOptimizedBvhNodeDoubleData_m_aabbMaxOrg_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_aabbMaxOrg); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNodeDoubleData_m_escapeIndex_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0, intgo _swig_go_1) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_escapeIndex = arg2; + +} + + +intgo _wrap_btOptimizedBvhNodeDoubleData_m_escapeIndex_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_escapeIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNodeDoubleData_m_subPart_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0, intgo _swig_go_1) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_subPart = arg2; + +} + + +intgo _wrap_btOptimizedBvhNodeDoubleData_m_subPart_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_subPart); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNodeDoubleData_m_triangleIndex_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0, intgo _swig_go_1) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_triangleIndex = arg2; + +} + + +intgo _wrap_btOptimizedBvhNodeDoubleData_m_triangleIndex_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_triangleIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvhNodeDoubleData_m_pad_set_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0, _gostring_ _swig_go_1) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_pad, (const char *)arg2, 4-1); + arg1->m_pad[4-1] = 0; + } else { + arg1->m_pad[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btOptimizedBvhNodeDoubleData_m_pad_get_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_pad); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btOptimizedBvhNodeDoubleData *_wrap_new_btOptimizedBvhNodeDoubleData_mbt_e879218550ba2e2b() { + btOptimizedBvhNodeDoubleData *result = 0 ; + btOptimizedBvhNodeDoubleData *_swig_go_result; + + + result = (btOptimizedBvhNodeDoubleData *)new btOptimizedBvhNodeDoubleData(); + *(btOptimizedBvhNodeDoubleData **)&_swig_go_result = (btOptimizedBvhNodeDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btOptimizedBvhNodeDoubleData_mbt_e879218550ba2e2b(btOptimizedBvhNodeDoubleData *_swig_go_0) { + btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; + + arg1 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btQuantizedBvhNodeData_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(btQuantizedBvhNodeData *_swig_go_0, short *_swig_go_1) { + btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; + unsigned short *arg2 = (unsigned short *) (unsigned short *)0 ; + + arg1 = *(btQuantizedBvhNodeData **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + + { + size_t ii; + unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMin; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); + } + +} + + +short *_wrap_btQuantizedBvhNodeData_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(btQuantizedBvhNodeData *_swig_go_0) { + btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; + unsigned short *result = 0 ; + short *_swig_go_result; + + arg1 = *(btQuantizedBvhNodeData **)&_swig_go_0; + + result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMin); + *(unsigned short **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhNodeData_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(btQuantizedBvhNodeData *_swig_go_0, short *_swig_go_1) { + btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; + unsigned short *arg2 = (unsigned short *) (unsigned short *)0 ; + + arg1 = *(btQuantizedBvhNodeData **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + + { + size_t ii; + unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMax; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); + } + +} + + +short *_wrap_btQuantizedBvhNodeData_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(btQuantizedBvhNodeData *_swig_go_0) { + btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; + unsigned short *result = 0 ; + short *_swig_go_result; + + arg1 = *(btQuantizedBvhNodeData **)&_swig_go_0; + + result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMax); + *(unsigned short **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhNodeData_m_escapeIndexOrTriangleIndex_set_mbt_e879218550ba2e2b(btQuantizedBvhNodeData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhNodeData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_escapeIndexOrTriangleIndex = arg2; + +} + + +intgo _wrap_btQuantizedBvhNodeData_m_escapeIndexOrTriangleIndex_get_mbt_e879218550ba2e2b(btQuantizedBvhNodeData *_swig_go_0) { + btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhNodeData **)&_swig_go_0; + + result = (int) ((arg1)->m_escapeIndexOrTriangleIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +btQuantizedBvhNodeData *_wrap_new_btQuantizedBvhNodeData_mbt_e879218550ba2e2b() { + btQuantizedBvhNodeData *result = 0 ; + btQuantizedBvhNodeData *_swig_go_result; + + + result = (btQuantizedBvhNodeData *)new btQuantizedBvhNodeData(); + *(btQuantizedBvhNodeData **)&_swig_go_result = (btQuantizedBvhNodeData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btQuantizedBvhNodeData_mbt_e879218550ba2e2b(btQuantizedBvhNodeData *_swig_go_0) { + btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; + + arg1 = *(btQuantizedBvhNodeData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btQuantizedBvhFloatData_m_bvhAabbMin_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_bvhAabbMin = *arg2; + +} + + +btVector3FloatData *_wrap_btQuantizedBvhFloatData_m_bvhAabbMin_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_bvhAabbMin); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_bvhAabbMax_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_bvhAabbMax = *arg2; + +} + + +btVector3FloatData *_wrap_btQuantizedBvhFloatData_m_bvhAabbMax_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_bvhAabbMax); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_bvhQuantization_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_bvhQuantization = *arg2; + +} + + +btVector3FloatData *_wrap_btQuantizedBvhFloatData_m_bvhQuantization_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_bvhQuantization); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_curNodeIndex_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_curNodeIndex = arg2; + +} + + +intgo _wrap_btQuantizedBvhFloatData_m_curNodeIndex_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_curNodeIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_useQuantization_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_useQuantization = arg2; + +} + + +intgo _wrap_btQuantizedBvhFloatData_m_useQuantization_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_useQuantization); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_numContiguousLeafNodes_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numContiguousLeafNodes = arg2; + +} + + +intgo _wrap_btQuantizedBvhFloatData_m_numContiguousLeafNodes_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_numContiguousLeafNodes); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_numQuantizedContiguousNodes_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numQuantizedContiguousNodes = arg2; + +} + + +intgo _wrap_btQuantizedBvhFloatData_m_numQuantizedContiguousNodes_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_numQuantizedContiguousNodes); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_contiguousNodesPtr_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, btOptimizedBvhNodeFloatData *_swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btOptimizedBvhNodeFloatData *arg2 = (btOptimizedBvhNodeFloatData *) 0 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = *(btOptimizedBvhNodeFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_contiguousNodesPtr = arg2; + +} + + +btOptimizedBvhNodeFloatData *_wrap_btQuantizedBvhFloatData_m_contiguousNodesPtr_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btOptimizedBvhNodeFloatData *result = 0 ; + btOptimizedBvhNodeFloatData *_swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (btOptimizedBvhNodeFloatData *) ((arg1)->m_contiguousNodesPtr); + *(btOptimizedBvhNodeFloatData **)&_swig_go_result = (btOptimizedBvhNodeFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_quantizedContiguousNodesPtr_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, btQuantizedBvhNodeData *_swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btQuantizedBvhNodeData *arg2 = (btQuantizedBvhNodeData *) 0 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = *(btQuantizedBvhNodeData **)&_swig_go_1; + + if (arg1) (arg1)->m_quantizedContiguousNodesPtr = arg2; + +} + + +btQuantizedBvhNodeData *_wrap_btQuantizedBvhFloatData_m_quantizedContiguousNodesPtr_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btQuantizedBvhNodeData *result = 0 ; + btQuantizedBvhNodeData *_swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (btQuantizedBvhNodeData *) ((arg1)->m_quantizedContiguousNodesPtr); + *(btQuantizedBvhNodeData **)&_swig_go_result = (btQuantizedBvhNodeData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_subTreeInfoPtr_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, btBvhSubtreeInfoData *_swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btBvhSubtreeInfoData *arg2 = (btBvhSubtreeInfoData *) 0 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = *(btBvhSubtreeInfoData **)&_swig_go_1; + + if (arg1) (arg1)->m_subTreeInfoPtr = arg2; + +} + + +btBvhSubtreeInfoData *_wrap_btQuantizedBvhFloatData_m_subTreeInfoPtr_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + btBvhSubtreeInfoData *result = 0 ; + btBvhSubtreeInfoData *_swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (btBvhSubtreeInfoData *) ((arg1)->m_subTreeInfoPtr); + *(btBvhSubtreeInfoData **)&_swig_go_result = (btBvhSubtreeInfoData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_traversalMode_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_traversalMode = arg2; + +} + + +intgo _wrap_btQuantizedBvhFloatData_m_traversalMode_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_traversalMode); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhFloatData_m_numSubtreeHeaders_set_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numSubtreeHeaders = arg2; + +} + + +intgo _wrap_btQuantizedBvhFloatData_m_numSubtreeHeaders_get_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_numSubtreeHeaders); + _swig_go_result = result; + return _swig_go_result; +} + + +btQuantizedBvhFloatData *_wrap_new_btQuantizedBvhFloatData_mbt_e879218550ba2e2b() { + btQuantizedBvhFloatData *result = 0 ; + btQuantizedBvhFloatData *_swig_go_result; + + + result = (btQuantizedBvhFloatData *)new btQuantizedBvhFloatData(); + *(btQuantizedBvhFloatData **)&_swig_go_result = (btQuantizedBvhFloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btQuantizedBvhFloatData_mbt_e879218550ba2e2b(btQuantizedBvhFloatData *_swig_go_0) { + btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; + + arg1 = *(btQuantizedBvhFloatData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btQuantizedBvhDoubleData_m_bvhAabbMin_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_bvhAabbMin = *arg2; + +} + + +btVector3DoubleData *_wrap_btQuantizedBvhDoubleData_m_bvhAabbMin_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_bvhAabbMin); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_bvhAabbMax_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_bvhAabbMax = *arg2; + +} + + +btVector3DoubleData *_wrap_btQuantizedBvhDoubleData_m_bvhAabbMax_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_bvhAabbMax); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_bvhQuantization_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_bvhQuantization = *arg2; + +} + + +btVector3DoubleData *_wrap_btQuantizedBvhDoubleData_m_bvhQuantization_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_bvhQuantization); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_curNodeIndex_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_curNodeIndex = arg2; + +} + + +intgo _wrap_btQuantizedBvhDoubleData_m_curNodeIndex_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_curNodeIndex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_useQuantization_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_useQuantization = arg2; + +} + + +intgo _wrap_btQuantizedBvhDoubleData_m_useQuantization_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_useQuantization); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_numContiguousLeafNodes_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numContiguousLeafNodes = arg2; + +} + + +intgo _wrap_btQuantizedBvhDoubleData_m_numContiguousLeafNodes_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_numContiguousLeafNodes); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_numQuantizedContiguousNodes_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numQuantizedContiguousNodes = arg2; + +} + + +intgo _wrap_btQuantizedBvhDoubleData_m_numQuantizedContiguousNodes_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_numQuantizedContiguousNodes); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_contiguousNodesPtr_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, btOptimizedBvhNodeDoubleData *_swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btOptimizedBvhNodeDoubleData *arg2 = (btOptimizedBvhNodeDoubleData *) 0 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = *(btOptimizedBvhNodeDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_contiguousNodesPtr = arg2; + +} + + +btOptimizedBvhNodeDoubleData *_wrap_btQuantizedBvhDoubleData_m_contiguousNodesPtr_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btOptimizedBvhNodeDoubleData *result = 0 ; + btOptimizedBvhNodeDoubleData *_swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (btOptimizedBvhNodeDoubleData *) ((arg1)->m_contiguousNodesPtr); + *(btOptimizedBvhNodeDoubleData **)&_swig_go_result = (btOptimizedBvhNodeDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_quantizedContiguousNodesPtr_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, btQuantizedBvhNodeData *_swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btQuantizedBvhNodeData *arg2 = (btQuantizedBvhNodeData *) 0 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = *(btQuantizedBvhNodeData **)&_swig_go_1; + + if (arg1) (arg1)->m_quantizedContiguousNodesPtr = arg2; + +} + + +btQuantizedBvhNodeData *_wrap_btQuantizedBvhDoubleData_m_quantizedContiguousNodesPtr_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btQuantizedBvhNodeData *result = 0 ; + btQuantizedBvhNodeData *_swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (btQuantizedBvhNodeData *) ((arg1)->m_quantizedContiguousNodesPtr); + *(btQuantizedBvhNodeData **)&_swig_go_result = (btQuantizedBvhNodeData *)result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_traversalMode_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_traversalMode = arg2; + +} + + +intgo _wrap_btQuantizedBvhDoubleData_m_traversalMode_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_traversalMode); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_numSubtreeHeaders_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, intgo _swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numSubtreeHeaders = arg2; + +} + + +intgo _wrap_btQuantizedBvhDoubleData_m_numSubtreeHeaders_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_numSubtreeHeaders); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btQuantizedBvhDoubleData_m_subTreeInfoPtr_set_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0, btBvhSubtreeInfoData *_swig_go_1) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btBvhSubtreeInfoData *arg2 = (btBvhSubtreeInfoData *) 0 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + arg2 = *(btBvhSubtreeInfoData **)&_swig_go_1; + + if (arg1) (arg1)->m_subTreeInfoPtr = arg2; + +} + + +btBvhSubtreeInfoData *_wrap_btQuantizedBvhDoubleData_m_subTreeInfoPtr_get_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + btBvhSubtreeInfoData *result = 0 ; + btBvhSubtreeInfoData *_swig_go_result; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + result = (btBvhSubtreeInfoData *) ((arg1)->m_subTreeInfoPtr); + *(btBvhSubtreeInfoData **)&_swig_go_result = (btBvhSubtreeInfoData *)result; + return _swig_go_result; +} + + +btQuantizedBvhDoubleData *_wrap_new_btQuantizedBvhDoubleData_mbt_e879218550ba2e2b() { + btQuantizedBvhDoubleData *result = 0 ; + btQuantizedBvhDoubleData *_swig_go_result; + + + result = (btQuantizedBvhDoubleData *)new btQuantizedBvhDoubleData(); + *(btQuantizedBvhDoubleData **)&_swig_go_result = (btQuantizedBvhDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btQuantizedBvhDoubleData_mbt_e879218550ba2e2b(btQuantizedBvhDoubleData *_swig_go_0) { + btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; + + arg1 = *(btQuantizedBvhDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +btOptimizedBvh *_wrap_new_btOptimizedBvh_mbt_e879218550ba2e2b() { + btOptimizedBvh *result = 0 ; + btOptimizedBvh *_swig_go_result; + + + result = (btOptimizedBvh *)new btOptimizedBvh(); + *(btOptimizedBvh **)&_swig_go_result = (btOptimizedBvh *)result; + return _swig_go_result; +} + + +void _wrap_delete_btOptimizedBvh_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btOptimizedBvh_build_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btStridingMeshInterface *_swig_go_1, bool _swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btStridingMeshInterface *arg2 = (btStridingMeshInterface *) 0 ; + bool arg3 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btStridingMeshInterface **)&_swig_go_1; + arg3 = (bool)_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + (arg1)->build(arg2,arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5); + +} + + +void _wrap_btOptimizedBvh_refit_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btStridingMeshInterface *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btStridingMeshInterface *arg2 = (btStridingMeshInterface *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btStridingMeshInterface **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->refit(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btOptimizedBvh_refitPartial_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btStridingMeshInterface *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btStridingMeshInterface *arg2 = (btStridingMeshInterface *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btStridingMeshInterface **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->refitPartial(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btOptimizedBvh_updateBvhNodes_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btStridingMeshInterface *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3, intgo _swig_go_4) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btStridingMeshInterface *arg2 = (btStridingMeshInterface *) 0 ; + int arg3 ; + int arg4 ; + int arg5 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btStridingMeshInterface **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (int)_swig_go_4; + + (arg1)->updateBvhNodes(arg2,arg3,arg4,arg5); + +} + + +bool _wrap_btOptimizedBvh_serializeInPlace_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, void *_swig_go_1, intgo _swig_go_2, bool _swig_go_3) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + void *arg2 = (void *) 0 ; + unsigned int arg3 ; + bool arg4 ; + bool result; + bool _swig_go_result; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = (unsigned int)_swig_go_2; + arg4 = (bool)_swig_go_3; + + result = (bool)((btOptimizedBvh const *)arg1)->serializeInPlace(arg2,arg3,arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +btOptimizedBvh *_wrap_btOptimizedBvh_deSerializeInPlace_mbt_e879218550ba2e2b(void *_swig_go_0, intgo _swig_go_1, bool _swig_go_2) { + void *arg1 = (void *) 0 ; + unsigned int arg2 ; + bool arg3 ; + btOptimizedBvh *result = 0 ; + btOptimizedBvh *_swig_go_result; + + arg1 = *(void **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + arg3 = (bool)_swig_go_2; + + result = (btOptimizedBvh *)btOptimizedBvh::deSerializeInPlace(arg1,arg2,arg3); + *(btOptimizedBvh **)&_swig_go_result = (btOptimizedBvh *)result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvh_setQuantizationValues__SWIG_0_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + (swig_b0)->setQuantizationValues((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +void _wrap_btOptimizedBvh_setQuantizationValues__SWIG_1_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + (swig_b0)->setQuantizationValues((btVector3 const &)*arg2,(btVector3 const &)*arg3); + +} + + +btAlignedObjectArray< btQuantizedBvhNode > *_wrap_btOptimizedBvh_getLeafNodeArray_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + QuantizedNodeArray *result = 0 ; + btAlignedObjectArray< btQuantizedBvhNode > *_swig_go_result; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + result = (QuantizedNodeArray *) &(swig_b0)->getLeafNodeArray(); + *(QuantizedNodeArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvh_buildInternal_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + (swig_b0)->buildInternal(); + +} + + +void _wrap_btOptimizedBvh_reportAabbOverlappingNodex_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btNodeOverlapCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btNodeOverlapCallback *arg2 = (btNodeOverlapCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btNodeOverlapCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + ((btQuantizedBvh const *)swig_b0)->reportAabbOverlappingNodex(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btOptimizedBvh_reportRayOverlappingNodex_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btNodeOverlapCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btNodeOverlapCallback *arg2 = (btNodeOverlapCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btNodeOverlapCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + ((btQuantizedBvh const *)swig_b0)->reportRayOverlappingNodex(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btOptimizedBvh_reportBoxCastOverlappingNodex_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btNodeOverlapCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btNodeOverlapCallback *arg2 = (btNodeOverlapCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btNodeOverlapCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + ((btQuantizedBvh const *)swig_b0)->reportBoxCastOverlappingNodex(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btOptimizedBvh_quantize_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, short *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + unsigned short *arg2 = (unsigned short *) 0 ; + btVector3 *arg3 = 0 ; + int arg4 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + ((btQuantizedBvh const *)swig_b0)->quantize(arg2,(btVector3 const &)*arg3,arg4); + +} + + +void _wrap_btOptimizedBvh_quantizeWithClamp_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, short *_swig_go_1, btVector3 *_swig_go_2, intgo _swig_go_3) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + unsigned short *arg2 = (unsigned short *) 0 ; + btVector3 *arg3 = 0 ; + int arg4 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (int)_swig_go_3; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + ((btQuantizedBvh const *)swig_b0)->quantizeWithClamp(arg2,(btVector3 const &)*arg3,arg4); + +} + + +btVector3 *_wrap_btOptimizedBvh_unQuantize_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, short *_swig_go_1) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + unsigned short *arg2 = (unsigned short *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(unsigned short **)&_swig_go_1; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + result = ((btQuantizedBvh const *)swig_b0)->unQuantize((unsigned short const *)arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btOptimizedBvh_setTraversalMode_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, intgo _swig_go_1) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btQuantizedBvh::btTraversalMode arg2 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = (btQuantizedBvh::btTraversalMode)_swig_go_1; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + (swig_b0)->setTraversalMode(arg2); + +} + + +btAlignedObjectArray< btQuantizedBvhNode > *_wrap_btOptimizedBvh_getQuantizedNodeArray_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + QuantizedNodeArray *result = 0 ; + btAlignedObjectArray< btQuantizedBvhNode > *_swig_go_result; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + result = (QuantizedNodeArray *) &(swig_b0)->getQuantizedNodeArray(); + *(QuantizedNodeArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btBvhSubtreeInfo > *_wrap_btOptimizedBvh_getSubtreeInfoArray_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + BvhSubtreeInfoArray *result = 0 ; + btAlignedObjectArray< btBvhSubtreeInfo > *_swig_go_result; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + result = (BvhSubtreeInfoArray *) &(swig_b0)->getSubtreeInfoArray(); + *(BvhSubtreeInfoArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btOptimizedBvh_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + result = (unsigned int)((btQuantizedBvh const *)swig_b0)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btOptimizedBvh_serialize__SWIG_0_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, void *_swig_go_1, intgo _swig_go_2, bool _swig_go_3) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + void *arg2 = (void *) 0 ; + unsigned int arg3 ; + bool arg4 ; + bool result; + bool _swig_go_result; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = (unsigned int)_swig_go_2; + arg4 = (bool)_swig_go_3; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + result = (bool)((btQuantizedBvh const *)swig_b0)->serialize(arg2,arg3,arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btOptimizedBvh_serialize__SWIG_1_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + result = (char *)((btQuantizedBvh const *)swig_b0)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btOptimizedBvh_getAlignmentSerializationPadding_mbt_e879218550ba2e2b() { + unsigned int result; + intgo _swig_go_result; + + + result = (unsigned int)btQuantizedBvh::getAlignmentSerializationPadding(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btOptimizedBvh_calculateSerializeBufferSizeNew_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + result = (int)((btQuantizedBvh const *)swig_b0)->calculateSerializeBufferSizeNew(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btOptimizedBvh_deSerializeFloat_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btQuantizedBvhFloatData *_swig_go_1) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btQuantizedBvhFloatData *arg2 = 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btQuantizedBvhFloatData **)&_swig_go_1; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + (swig_b0)->deSerializeFloat(*arg2); + +} + + +void _wrap_btOptimizedBvh_deSerializeDouble_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0, btQuantizedBvhDoubleData *_swig_go_1) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + btQuantizedBvhDoubleData *arg2 = 0 ; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + arg2 = *(btQuantizedBvhDoubleData **)&_swig_go_1; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + (swig_b0)->deSerializeDouble(*arg2); + +} + + +bool _wrap_btOptimizedBvh_isQuantized_mbt_e879218550ba2e2b(btOptimizedBvh *_swig_go_0) { + btOptimizedBvh *arg1 = (btOptimizedBvh *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btOptimizedBvh **)&_swig_go_0; + + btQuantizedBvh *swig_b0 = (btQuantizedBvh *)arg1; + result = (bool)(swig_b0)->isQuantized(); + _swig_go_result = result; + return _swig_go_result; +} + + +btTriangleInfo *_wrap_new_btTriangleInfo_mbt_e879218550ba2e2b() { + btTriangleInfo *result = 0 ; + btTriangleInfo *_swig_go_result; + + + result = (btTriangleInfo *)new btTriangleInfo(); + *(btTriangleInfo **)&_swig_go_result = (btTriangleInfo *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfo_m_flags_set_mbt_e879218550ba2e2b(btTriangleInfo *_swig_go_0, intgo _swig_go_1) { + btTriangleInfo *arg1 = (btTriangleInfo *) 0 ; + int arg2 ; + + arg1 = *(btTriangleInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_flags = arg2; + +} + + +intgo _wrap_btTriangleInfo_m_flags_get_mbt_e879218550ba2e2b(btTriangleInfo *_swig_go_0) { + btTriangleInfo *arg1 = (btTriangleInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleInfo **)&_swig_go_0; + + result = (int) ((arg1)->m_flags); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfo_m_edgeV0V1Angle_set_mbt_e879218550ba2e2b(btTriangleInfo *_swig_go_0, float _swig_go_1) { + btTriangleInfo *arg1 = (btTriangleInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_edgeV0V1Angle = arg2; + +} + + +float _wrap_btTriangleInfo_m_edgeV0V1Angle_get_mbt_e879218550ba2e2b(btTriangleInfo *_swig_go_0) { + btTriangleInfo *arg1 = (btTriangleInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleInfo **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_edgeV0V1Angle); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfo_m_edgeV1V2Angle_set_mbt_e879218550ba2e2b(btTriangleInfo *_swig_go_0, float _swig_go_1) { + btTriangleInfo *arg1 = (btTriangleInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_edgeV1V2Angle = arg2; + +} + + +float _wrap_btTriangleInfo_m_edgeV1V2Angle_get_mbt_e879218550ba2e2b(btTriangleInfo *_swig_go_0) { + btTriangleInfo *arg1 = (btTriangleInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleInfo **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_edgeV1V2Angle); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfo_m_edgeV2V0Angle_set_mbt_e879218550ba2e2b(btTriangleInfo *_swig_go_0, float _swig_go_1) { + btTriangleInfo *arg1 = (btTriangleInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_edgeV2V0Angle = arg2; + +} + + +float _wrap_btTriangleInfo_m_edgeV2V0Angle_get_mbt_e879218550ba2e2b(btTriangleInfo *_swig_go_0) { + btTriangleInfo *arg1 = (btTriangleInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleInfo **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_edgeV2V0Angle); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btTriangleInfo_mbt_e879218550ba2e2b(btTriangleInfo *_swig_go_0) { + btTriangleInfo *arg1 = (btTriangleInfo *) 0 ; + + arg1 = *(btTriangleInfo **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btTriangleInfoMap_m_convexEpsilon_set_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0, float _swig_go_1) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_convexEpsilon = arg2; + +} + + +float _wrap_btTriangleInfoMap_m_convexEpsilon_get_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_convexEpsilon); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMap_m_planarEpsilon_set_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0, float _swig_go_1) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_planarEpsilon = arg2; + +} + + +float _wrap_btTriangleInfoMap_m_planarEpsilon_get_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_planarEpsilon); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMap_m_equalVertexThreshold_set_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0, float _swig_go_1) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_equalVertexThreshold = arg2; + +} + + +float _wrap_btTriangleInfoMap_m_equalVertexThreshold_get_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_equalVertexThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMap_m_edgeDistanceThreshold_set_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0, float _swig_go_1) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_edgeDistanceThreshold = arg2; + +} + + +float _wrap_btTriangleInfoMap_m_edgeDistanceThreshold_get_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_edgeDistanceThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMap_m_maxEdgeAngleThreshold_set_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0, float _swig_go_1) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_maxEdgeAngleThreshold = arg2; + +} + + +float _wrap_btTriangleInfoMap_m_maxEdgeAngleThreshold_get_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_maxEdgeAngleThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMap_m_zeroAreaThreshold_set_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0, float _swig_go_1) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_zeroAreaThreshold = arg2; + +} + + +float _wrap_btTriangleInfoMap_m_zeroAreaThreshold_get_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_zeroAreaThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +btTriangleInfoMap *_wrap_new_btTriangleInfoMap_mbt_e879218550ba2e2b() { + btTriangleInfoMap *result = 0 ; + btTriangleInfoMap *_swig_go_result; + + + result = (btTriangleInfoMap *)new btTriangleInfoMap(); + *(btTriangleInfoMap **)&_swig_go_result = (btTriangleInfoMap *)result; + return _swig_go_result; +} + + +void _wrap_delete_btTriangleInfoMap_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_btTriangleInfoMap_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + + result = (int)((btTriangleInfoMap const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btTriangleInfoMap_serialize_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btTriangleInfoMap const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMap_deSerialize_mbt_e879218550ba2e2b(btTriangleInfoMap *_swig_go_0, btTriangleInfoMapData *_swig_go_1) { + btTriangleInfoMap *arg1 = (btTriangleInfoMap *) 0 ; + btTriangleInfoMapData *arg2 = 0 ; + + arg1 = *(btTriangleInfoMap **)&_swig_go_0; + arg2 = *(btTriangleInfoMapData **)&_swig_go_1; + + (arg1)->deSerialize(*arg2); + +} + + +void _wrap_btTriangleInfoData_m_flags_set_mbt_e879218550ba2e2b(btTriangleInfoData *_swig_go_0, intgo _swig_go_1) { + btTriangleInfoData *arg1 = (btTriangleInfoData *) 0 ; + int arg2 ; + + arg1 = *(btTriangleInfoData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_flags = arg2; + +} + + +intgo _wrap_btTriangleInfoData_m_flags_get_mbt_e879218550ba2e2b(btTriangleInfoData *_swig_go_0) { + btTriangleInfoData *arg1 = (btTriangleInfoData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleInfoData **)&_swig_go_0; + + result = (int) ((arg1)->m_flags); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoData_m_edgeV0V1Angle_set_mbt_e879218550ba2e2b(btTriangleInfoData *_swig_go_0, float _swig_go_1) { + btTriangleInfoData *arg1 = (btTriangleInfoData *) 0 ; + float arg2 ; + + arg1 = *(btTriangleInfoData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_edgeV0V1Angle = arg2; + +} + + +float _wrap_btTriangleInfoData_m_edgeV0V1Angle_get_mbt_e879218550ba2e2b(btTriangleInfoData *_swig_go_0) { + btTriangleInfoData *arg1 = (btTriangleInfoData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTriangleInfoData **)&_swig_go_0; + + result = (float) ((arg1)->m_edgeV0V1Angle); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoData_m_edgeV1V2Angle_set_mbt_e879218550ba2e2b(btTriangleInfoData *_swig_go_0, float _swig_go_1) { + btTriangleInfoData *arg1 = (btTriangleInfoData *) 0 ; + float arg2 ; + + arg1 = *(btTriangleInfoData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_edgeV1V2Angle = arg2; + +} + + +float _wrap_btTriangleInfoData_m_edgeV1V2Angle_get_mbt_e879218550ba2e2b(btTriangleInfoData *_swig_go_0) { + btTriangleInfoData *arg1 = (btTriangleInfoData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTriangleInfoData **)&_swig_go_0; + + result = (float) ((arg1)->m_edgeV1V2Angle); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoData_m_edgeV2V0Angle_set_mbt_e879218550ba2e2b(btTriangleInfoData *_swig_go_0, float _swig_go_1) { + btTriangleInfoData *arg1 = (btTriangleInfoData *) 0 ; + float arg2 ; + + arg1 = *(btTriangleInfoData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_edgeV2V0Angle = arg2; + +} + + +float _wrap_btTriangleInfoData_m_edgeV2V0Angle_get_mbt_e879218550ba2e2b(btTriangleInfoData *_swig_go_0) { + btTriangleInfoData *arg1 = (btTriangleInfoData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTriangleInfoData **)&_swig_go_0; + + result = (float) ((arg1)->m_edgeV2V0Angle); + _swig_go_result = result; + return _swig_go_result; +} + + +btTriangleInfoData *_wrap_new_btTriangleInfoData_mbt_e879218550ba2e2b() { + btTriangleInfoData *result = 0 ; + btTriangleInfoData *_swig_go_result; + + + result = (btTriangleInfoData *)new btTriangleInfoData(); + *(btTriangleInfoData **)&_swig_go_result = (btTriangleInfoData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btTriangleInfoData_mbt_e879218550ba2e2b(btTriangleInfoData *_swig_go_0) { + btTriangleInfoData *arg1 = (btTriangleInfoData *) 0 ; + + arg1 = *(btTriangleInfoData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btTriangleInfoMapData_m_hashTablePtr_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, intgo *_swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int *arg2 = (int *) 0 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + if (arg1) (arg1)->m_hashTablePtr = arg2; + +} + + +intgo *_wrap_btTriangleInfoMapData_m_hashTablePtr_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (int *) ((arg1)->m_hashTablePtr); + *(int **)&_swig_go_result = (int *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_nextPtr_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, intgo *_swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int *arg2 = (int *) 0 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + if (arg1) (arg1)->m_nextPtr = arg2; + +} + + +intgo *_wrap_btTriangleInfoMapData_m_nextPtr_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (int *) ((arg1)->m_nextPtr); + *(int **)&_swig_go_result = (int *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_valueArrayPtr_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, btTriangleInfoData *_swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + btTriangleInfoData *arg2 = (btTriangleInfoData *) 0 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = *(btTriangleInfoData **)&_swig_go_1; + + if (arg1) (arg1)->m_valueArrayPtr = arg2; + +} + + +btTriangleInfoData *_wrap_btTriangleInfoMapData_m_valueArrayPtr_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + btTriangleInfoData *result = 0 ; + btTriangleInfoData *_swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (btTriangleInfoData *) ((arg1)->m_valueArrayPtr); + *(btTriangleInfoData **)&_swig_go_result = (btTriangleInfoData *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_keyArrayPtr_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, intgo *_swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int *arg2 = (int *) 0 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + if (arg1) (arg1)->m_keyArrayPtr = arg2; + +} + + +intgo *_wrap_btTriangleInfoMapData_m_keyArrayPtr_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (int *) ((arg1)->m_keyArrayPtr); + *(int **)&_swig_go_result = (int *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_convexEpsilon_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, float _swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + float arg2 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_convexEpsilon = arg2; + +} + + +float _wrap_btTriangleInfoMapData_m_convexEpsilon_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (float) ((arg1)->m_convexEpsilon); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_planarEpsilon_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, float _swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + float arg2 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_planarEpsilon = arg2; + +} + + +float _wrap_btTriangleInfoMapData_m_planarEpsilon_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (float) ((arg1)->m_planarEpsilon); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_equalVertexThreshold_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, float _swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + float arg2 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_equalVertexThreshold = arg2; + +} + + +float _wrap_btTriangleInfoMapData_m_equalVertexThreshold_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (float) ((arg1)->m_equalVertexThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_edgeDistanceThreshold_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, float _swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + float arg2 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_edgeDistanceThreshold = arg2; + +} + + +float _wrap_btTriangleInfoMapData_m_edgeDistanceThreshold_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (float) ((arg1)->m_edgeDistanceThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_zeroAreaThreshold_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, float _swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + float arg2 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_zeroAreaThreshold = arg2; + +} + + +float _wrap_btTriangleInfoMapData_m_zeroAreaThreshold_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (float) ((arg1)->m_zeroAreaThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_nextSize_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, intgo _swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int arg2 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_nextSize = arg2; + +} + + +intgo _wrap_btTriangleInfoMapData_m_nextSize_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (int) ((arg1)->m_nextSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_hashTableSize_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, intgo _swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int arg2 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_hashTableSize = arg2; + +} + + +intgo _wrap_btTriangleInfoMapData_m_hashTableSize_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (int) ((arg1)->m_hashTableSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_numValues_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, intgo _swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int arg2 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numValues = arg2; + +} + + +intgo _wrap_btTriangleInfoMapData_m_numValues_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (int) ((arg1)->m_numValues); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_numKeys_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, intgo _swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int arg2 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numKeys = arg2; + +} + + +intgo _wrap_btTriangleInfoMapData_m_numKeys_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (int) ((arg1)->m_numKeys); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleInfoMapData_m_padding_set_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0, _gostring_ _swig_go_1) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_padding, (const char *)arg2, 4-1); + arg1->m_padding[4-1] = 0; + } else { + arg1->m_padding[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btTriangleInfoMapData_m_padding_get_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_padding); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btTriangleInfoMapData *_wrap_new_btTriangleInfoMapData_mbt_e879218550ba2e2b() { + btTriangleInfoMapData *result = 0 ; + btTriangleInfoMapData *_swig_go_result; + + + result = (btTriangleInfoMapData *)new btTriangleInfoMapData(); + *(btTriangleInfoMapData **)&_swig_go_result = (btTriangleInfoMapData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btTriangleInfoMapData_mbt_e879218550ba2e2b(btTriangleInfoMapData *_swig_go_0) { + btTriangleInfoMapData *arg1 = (btTriangleInfoMapData *) 0 ; + + arg1 = *(btTriangleInfoMapData **)&_swig_go_0; + + delete arg1; + +} + + +btBvhTriangleMeshShape *_wrap_new_btBvhTriangleMeshShape__SWIG_0_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, bool _swig_go_1, bool _swig_go_2) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + bool arg2 ; + bool arg3 ; + btBvhTriangleMeshShape *result = 0 ; + btBvhTriangleMeshShape *_swig_go_result; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + arg3 = (bool)_swig_go_2; + + result = (btBvhTriangleMeshShape *)new btBvhTriangleMeshShape(arg1,arg2,arg3); + *(btBvhTriangleMeshShape **)&_swig_go_result = (btBvhTriangleMeshShape *)result; + return _swig_go_result; +} + + +btBvhTriangleMeshShape *_wrap_new_btBvhTriangleMeshShape__SWIG_1_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, bool _swig_go_1) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + bool arg2 ; + btBvhTriangleMeshShape *result = 0 ; + btBvhTriangleMeshShape *_swig_go_result; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + result = (btBvhTriangleMeshShape *)new btBvhTriangleMeshShape(arg1,arg2); + *(btBvhTriangleMeshShape **)&_swig_go_result = (btBvhTriangleMeshShape *)result; + return _swig_go_result; +} + + +btBvhTriangleMeshShape *_wrap_new_btBvhTriangleMeshShape__SWIG_2_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, bool _swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, bool _swig_go_4) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + bool arg2 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + bool arg5 ; + btBvhTriangleMeshShape *result = 0 ; + btBvhTriangleMeshShape *_swig_go_result; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + + result = (btBvhTriangleMeshShape *)new btBvhTriangleMeshShape(arg1,arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5); + *(btBvhTriangleMeshShape **)&_swig_go_result = (btBvhTriangleMeshShape *)result; + return _swig_go_result; +} + + +btBvhTriangleMeshShape *_wrap_new_btBvhTriangleMeshShape__SWIG_3_mbt_e879218550ba2e2b(btStridingMeshInterface *_swig_go_0, bool _swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btStridingMeshInterface *arg1 = (btStridingMeshInterface *) 0 ; + bool arg2 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btBvhTriangleMeshShape *result = 0 ; + btBvhTriangleMeshShape *_swig_go_result; + + arg1 = *(btStridingMeshInterface **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = (btBvhTriangleMeshShape *)new btBvhTriangleMeshShape(arg1,arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + *(btBvhTriangleMeshShape **)&_swig_go_result = (btBvhTriangleMeshShape *)result; + return _swig_go_result; +} + + +void _wrap_delete_btBvhTriangleMeshShape_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btBvhTriangleMeshShape_getOwnsBvh_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + result = (bool)((btBvhTriangleMeshShape const *)arg1)->getOwnsBvh(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_performRaycast_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btTriangleCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btTriangleCallback *arg2 = (btTriangleCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btTriangleCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->performRaycast(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btBvhTriangleMeshShape_performConvexcast_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btTriangleCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btTriangleCallback *arg2 = (btTriangleCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btTriangleCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->performConvexcast(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btBvhTriangleMeshShape_processAllTriangles_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btTriangleCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btTriangleCallback *arg2 = (btTriangleCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btTriangleCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btBvhTriangleMeshShape const *)arg1)->processAllTriangles(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btBvhTriangleMeshShape_refitTree_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->refitTree((btVector3 const &)*arg2,(btVector3 const &)*arg3); + +} + + +void _wrap_btBvhTriangleMeshShape_partialRefitTree_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->partialRefitTree((btVector3 const &)*arg2,(btVector3 const &)*arg3); + +} + + +_gostring_ _wrap_btBvhTriangleMeshShape_getName_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + result = (char *)((btBvhTriangleMeshShape const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_setLocalScaling_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btVector3 *_swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btOptimizedBvh *_wrap_btBvhTriangleMeshShape_getOptimizedBvh_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btOptimizedBvh *result = 0 ; + btOptimizedBvh *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + result = (btOptimizedBvh *)(arg1)->getOptimizedBvh(); + *(btOptimizedBvh **)&_swig_go_result = (btOptimizedBvh *)result; + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_setOptimizedBvh__SWIG_0_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btOptimizedBvh *_swig_go_1, btVector3 *_swig_go_2) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btOptimizedBvh *arg2 = (btOptimizedBvh *) 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btOptimizedBvh **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->setOptimizedBvh(arg2,(btVector3 const &)*arg3); + +} + + +void _wrap_btBvhTriangleMeshShape_setOptimizedBvh__SWIG_1_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btOptimizedBvh *_swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btOptimizedBvh *arg2 = (btOptimizedBvh *) 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btOptimizedBvh **)&_swig_go_1; + + (arg1)->setOptimizedBvh(arg2); + +} + + +void _wrap_btBvhTriangleMeshShape_buildOptimizedBvh_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + (arg1)->buildOptimizedBvh(); + +} + + +bool _wrap_btBvhTriangleMeshShape_usesQuantizedAabbCompression_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + result = (bool)((btBvhTriangleMeshShape const *)arg1)->usesQuantizedAabbCompression(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_setTriangleInfoMap_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btTriangleInfoMap *_swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btTriangleInfoMap *arg2 = (btTriangleInfoMap *) 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btTriangleInfoMap **)&_swig_go_1; + + (arg1)->setTriangleInfoMap(arg2); + +} + + +btTriangleInfoMap *_wrap_btBvhTriangleMeshShape_getTriangleInfoMap__SWIG_0_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btTriangleInfoMap *result = 0 ; + btTriangleInfoMap *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + result = (btTriangleInfoMap *)((btBvhTriangleMeshShape const *)arg1)->getTriangleInfoMap(); + *(btTriangleInfoMap **)&_swig_go_result = (btTriangleInfoMap *)result; + return _swig_go_result; +} + + +btTriangleInfoMap *_wrap_btBvhTriangleMeshShape_getTriangleInfoMap__SWIG_1_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btTriangleInfoMap *result = 0 ; + btTriangleInfoMap *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + result = (btTriangleInfoMap *)(arg1)->getTriangleInfoMap(); + *(btTriangleInfoMap **)&_swig_go_result = (btTriangleInfoMap *)result; + return _swig_go_result; +} + + +intgo _wrap_btBvhTriangleMeshShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + result = (int)((btBvhTriangleMeshShape const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btBvhTriangleMeshShape_serialize_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btBvhTriangleMeshShape const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_serializeSingleBvh_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btSerializer *_swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + ((btBvhTriangleMeshShape const *)arg1)->serializeSingleBvh(arg2); + +} + + +void _wrap_btBvhTriangleMeshShape_serializeSingleTriangleInfoMap_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btSerializer *_swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + ((btBvhTriangleMeshShape const *)arg1)->serializeSingleTriangleInfoMap(arg2); + +} + + +btVector3 *_wrap_btBvhTriangleMeshShape_localGetSupportingVertex_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btVector3 *_swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + result = ((btTriangleMeshShape const *)swig_b0)->localGetSupportingVertex((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_btBvhTriangleMeshShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btVector3 *_swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + result = ((btTriangleMeshShape const *)swig_b0)->localGetSupportingVertexWithoutMargin((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_recalcLocalAabb_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + (swig_b0)->recalcLocalAabb(); + +} + + +void _wrap_btBvhTriangleMeshShape_getAabb_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + ((btTriangleMeshShape const *)swig_b0)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btBvhTriangleMeshShape_calculateLocalInertia_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + ((btTriangleMeshShape const *)swig_b0)->calculateLocalInertia(arg2,*arg3); + +} + + +btVector3 *_wrap_btBvhTriangleMeshShape_getLocalScaling_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + result = (btVector3 *) &((btTriangleMeshShape const *)swig_b0)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btStridingMeshInterface *_wrap_btBvhTriangleMeshShape_getMeshInterface__SWIG_0_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btStridingMeshInterface *result = 0 ; + btStridingMeshInterface *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + result = (btStridingMeshInterface *)(swig_b0)->getMeshInterface(); + *(btStridingMeshInterface **)&_swig_go_result = (btStridingMeshInterface *)result; + return _swig_go_result; +} + + +btStridingMeshInterface *_wrap_btBvhTriangleMeshShape_getMeshInterface__SWIG_1_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btStridingMeshInterface *result = 0 ; + btStridingMeshInterface *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + result = (btStridingMeshInterface *)((btTriangleMeshShape const *)swig_b0)->getMeshInterface(); + *(btStridingMeshInterface **)&_swig_go_result = (btStridingMeshInterface *)result; + return _swig_go_result; +} + + +btVector3 *_wrap_btBvhTriangleMeshShape_getLocalAabbMin_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + result = (btVector3 *) &((btTriangleMeshShape const *)swig_b0)->getLocalAabbMin(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btBvhTriangleMeshShape_getLocalAabbMax_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + result = (btVector3 *) &((btTriangleMeshShape const *)swig_b0)->getLocalAabbMax(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBvhTriangleMeshShape_getMargin_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + result = (btScalar)((btConcaveShape const *)swig_b1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_setMargin_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, float _swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + (swig_b1)->setMargin(arg2); + +} + + +void _wrap_btBvhTriangleMeshShape_getBoundingSphere_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btBvhTriangleMeshShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (btScalar)((btCollisionShape const *)swig_b2)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBvhTriangleMeshShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, float _swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (btScalar)((btCollisionShape const *)swig_b2)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btBvhTriangleMeshShape_isPolyhedral_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBvhTriangleMeshShape_isConvex2d_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBvhTriangleMeshShape_isConvex_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBvhTriangleMeshShape_isNonMoving_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBvhTriangleMeshShape_isConcave_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBvhTriangleMeshShape_isCompound_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBvhTriangleMeshShape_isSoftBody_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btBvhTriangleMeshShape_isInfinite_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (bool)((btCollisionShape const *)swig_b2)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btBvhTriangleMeshShape_getShapeType_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btBvhTriangleMeshShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = ((btCollisionShape const *)swig_b2)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_setUserPointer_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, void *_swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserPointer(arg2); + +} + + +void *_wrap_btBvhTriangleMeshShape_getUserPointer_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (void *)((btCollisionShape const *)swig_b2)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_setUserIndex_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, intgo _swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + int arg2 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserIndex(arg2); + +} + + +intgo _wrap_btBvhTriangleMeshShape_getUserIndex_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_setUserIndex2_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, intgo _swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + int arg2 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + (swig_b2)->setUserIndex2(arg2); + +} + + +intgo _wrap_btBvhTriangleMeshShape_getUserIndex2_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + result = (int)((btCollisionShape const *)swig_b2)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBvhTriangleMeshShape_serializeSingleShape_mbt_e879218550ba2e2b(btBvhTriangleMeshShape *_swig_go_0, btSerializer *_swig_go_1) { + btBvhTriangleMeshShape *arg1 = (btBvhTriangleMeshShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btBvhTriangleMeshShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btTriangleMeshShape *swig_b0 = (btTriangleMeshShape *)arg1; + btConcaveShape *swig_b1 = (btConcaveShape *)swig_b0; + btCollisionShape *swig_b2 = (btCollisionShape *)swig_b1; + ((btCollisionShape const *)swig_b2)->serializeSingleShape(arg2); + +} + + +void _wrap_btTriangleMeshShapeData_m_collisionShapeData_set_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0, btCollisionShapeData *_swig_go_1) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + btCollisionShapeData *arg2 = (btCollisionShapeData *) 0 ; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + arg2 = *(btCollisionShapeData **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionShapeData = *arg2; + +} + + +btCollisionShapeData *_wrap_btTriangleMeshShapeData_m_collisionShapeData_get_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + btCollisionShapeData *result = 0 ; + btCollisionShapeData *_swig_go_result; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + + result = (btCollisionShapeData *)& ((arg1)->m_collisionShapeData); + *(btCollisionShapeData **)&_swig_go_result = (btCollisionShapeData *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShapeData_m_meshInterface_set_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0, btStridingMeshInterfaceData *_swig_go_1) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + btStridingMeshInterfaceData *arg2 = (btStridingMeshInterfaceData *) 0 ; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + arg2 = *(btStridingMeshInterfaceData **)&_swig_go_1; + + if (arg1) (arg1)->m_meshInterface = *arg2; + +} + + +btStridingMeshInterfaceData *_wrap_btTriangleMeshShapeData_m_meshInterface_get_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + btStridingMeshInterfaceData *result = 0 ; + btStridingMeshInterfaceData *_swig_go_result; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + + result = (btStridingMeshInterfaceData *)& ((arg1)->m_meshInterface); + *(btStridingMeshInterfaceData **)&_swig_go_result = (btStridingMeshInterfaceData *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShapeData_m_quantizedFloatBvh_set_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0, btQuantizedBvhFloatData *_swig_go_1) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + btQuantizedBvhFloatData *arg2 = (btQuantizedBvhFloatData *) 0 ; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + arg2 = *(btQuantizedBvhFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_quantizedFloatBvh = arg2; + +} + + +btQuantizedBvhFloatData *_wrap_btTriangleMeshShapeData_m_quantizedFloatBvh_get_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + btQuantizedBvhFloatData *result = 0 ; + btQuantizedBvhFloatData *_swig_go_result; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + + result = (btQuantizedBvhFloatData *) ((arg1)->m_quantizedFloatBvh); + *(btQuantizedBvhFloatData **)&_swig_go_result = (btQuantizedBvhFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShapeData_m_quantizedDoubleBvh_set_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0, btQuantizedBvhDoubleData *_swig_go_1) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + btQuantizedBvhDoubleData *arg2 = (btQuantizedBvhDoubleData *) 0 ; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + arg2 = *(btQuantizedBvhDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_quantizedDoubleBvh = arg2; + +} + + +btQuantizedBvhDoubleData *_wrap_btTriangleMeshShapeData_m_quantizedDoubleBvh_get_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + btQuantizedBvhDoubleData *result = 0 ; + btQuantizedBvhDoubleData *_swig_go_result; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + + result = (btQuantizedBvhDoubleData *) ((arg1)->m_quantizedDoubleBvh); + *(btQuantizedBvhDoubleData **)&_swig_go_result = (btQuantizedBvhDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShapeData_m_triangleInfoMap_set_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0, btTriangleInfoMapData *_swig_go_1) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + btTriangleInfoMapData *arg2 = (btTriangleInfoMapData *) 0 ; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + arg2 = *(btTriangleInfoMapData **)&_swig_go_1; + + if (arg1) (arg1)->m_triangleInfoMap = arg2; + +} + + +btTriangleInfoMapData *_wrap_btTriangleMeshShapeData_m_triangleInfoMap_get_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + btTriangleInfoMapData *result = 0 ; + btTriangleInfoMapData *_swig_go_result; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + + result = (btTriangleInfoMapData *) ((arg1)->m_triangleInfoMap); + *(btTriangleInfoMapData **)&_swig_go_result = (btTriangleInfoMapData *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShapeData_m_collisionMargin_set_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0, float _swig_go_1) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + float arg2 ; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_collisionMargin = arg2; + +} + + +float _wrap_btTriangleMeshShapeData_m_collisionMargin_get_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + + result = (float) ((arg1)->m_collisionMargin); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleMeshShapeData_m_pad3_set_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0, _gostring_ _swig_go_1) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_pad3, (const char *)arg2, 4-1); + arg1->m_pad3[4-1] = 0; + } else { + arg1->m_pad3[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btTriangleMeshShapeData_m_pad3_get_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_pad3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btTriangleMeshShapeData *_wrap_new_btTriangleMeshShapeData_mbt_e879218550ba2e2b() { + btTriangleMeshShapeData *result = 0 ; + btTriangleMeshShapeData *_swig_go_result; + + + result = (btTriangleMeshShapeData *)new btTriangleMeshShapeData(); + *(btTriangleMeshShapeData **)&_swig_go_result = (btTriangleMeshShapeData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btTriangleMeshShapeData_mbt_e879218550ba2e2b(btTriangleMeshShapeData *_swig_go_0) { + btTriangleMeshShapeData *arg1 = (btTriangleMeshShapeData *) 0 ; + + arg1 = *(btTriangleMeshShapeData **)&_swig_go_0; + + delete arg1; + +} + + +btHeightfieldTerrainShape *_wrap_new_btHeightfieldTerrainShape__SWIG_0_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1, float *_swig_go_2, float _swig_go_3, float _swig_go_4, intgo _swig_go_5, bool _swig_go_6) { + int arg1 ; + int arg2 ; + float *arg3 = (float *) 0 ; + btScalar arg4 ; + btScalar arg5 ; + int arg6 ; + bool arg7 ; + btHeightfieldTerrainShape *result = 0 ; + btHeightfieldTerrainShape *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(float **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (int)_swig_go_5; + arg7 = (bool)_swig_go_6; + + result = (btHeightfieldTerrainShape *)new btHeightfieldTerrainShape(arg1,arg2,(float const *)arg3,arg4,arg5,arg6,arg7); + *(btHeightfieldTerrainShape **)&_swig_go_result = (btHeightfieldTerrainShape *)result; + return _swig_go_result; +} + + +btHeightfieldTerrainShape *_wrap_new_btHeightfieldTerrainShape__SWIG_1_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1, double *_swig_go_2, float _swig_go_3, float _swig_go_4, intgo _swig_go_5, bool _swig_go_6) { + int arg1 ; + int arg2 ; + double *arg3 = (double *) 0 ; + btScalar arg4 ; + btScalar arg5 ; + int arg6 ; + bool arg7 ; + btHeightfieldTerrainShape *result = 0 ; + btHeightfieldTerrainShape *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(double **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (int)_swig_go_5; + arg7 = (bool)_swig_go_6; + + result = (btHeightfieldTerrainShape *)new btHeightfieldTerrainShape(arg1,arg2,(double const *)arg3,arg4,arg5,arg6,arg7); + *(btHeightfieldTerrainShape **)&_swig_go_result = (btHeightfieldTerrainShape *)result; + return _swig_go_result; +} + + +btHeightfieldTerrainShape *_wrap_new_btHeightfieldTerrainShape__SWIG_2_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1, short *_swig_go_2, float _swig_go_3, float _swig_go_4, float _swig_go_5, intgo _swig_go_6, bool _swig_go_7) { + int arg1 ; + int arg2 ; + short *arg3 = (short *) 0 ; + btScalar arg4 ; + btScalar arg5 ; + btScalar arg6 ; + int arg7 ; + bool arg8 ; + btHeightfieldTerrainShape *result = 0 ; + btHeightfieldTerrainShape *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(short **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (int)_swig_go_6; + arg8 = (bool)_swig_go_7; + + result = (btHeightfieldTerrainShape *)new btHeightfieldTerrainShape(arg1,arg2,(short const *)arg3,arg4,arg5,arg6,arg7,arg8); + *(btHeightfieldTerrainShape **)&_swig_go_result = (btHeightfieldTerrainShape *)result; + return _swig_go_result; +} + + +btHeightfieldTerrainShape *_wrap_new_btHeightfieldTerrainShape__SWIG_3_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1, char *_swig_go_2, float _swig_go_3, float _swig_go_4, float _swig_go_5, intgo _swig_go_6, bool _swig_go_7) { + int arg1 ; + int arg2 ; + unsigned char *arg3 = (unsigned char *) 0 ; + btScalar arg4 ; + btScalar arg5 ; + btScalar arg6 ; + int arg7 ; + bool arg8 ; + btHeightfieldTerrainShape *result = 0 ; + btHeightfieldTerrainShape *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(unsigned char **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (int)_swig_go_6; + arg8 = (bool)_swig_go_7; + + result = (btHeightfieldTerrainShape *)new btHeightfieldTerrainShape(arg1,arg2,(unsigned char const *)arg3,arg4,arg5,arg6,arg7,arg8); + *(btHeightfieldTerrainShape **)&_swig_go_result = (btHeightfieldTerrainShape *)result; + return _swig_go_result; +} + + +btHeightfieldTerrainShape *_wrap_new_btHeightfieldTerrainShape__SWIG_4_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1, void *_swig_go_2, float _swig_go_3, float _swig_go_4, float _swig_go_5, intgo _swig_go_6, intgo _swig_go_7, bool _swig_go_8) { + int arg1 ; + int arg2 ; + void *arg3 = (void *) 0 ; + btScalar arg4 ; + btScalar arg5 ; + btScalar arg6 ; + int arg7 ; + PHY_ScalarType arg8 ; + bool arg9 ; + btHeightfieldTerrainShape *result = 0 ; + btHeightfieldTerrainShape *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(void **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (int)_swig_go_6; + arg8 = (PHY_ScalarType)_swig_go_7; + arg9 = (bool)_swig_go_8; + + result = (btHeightfieldTerrainShape *)new btHeightfieldTerrainShape(arg1,arg2,(void const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9); + *(btHeightfieldTerrainShape **)&_swig_go_result = (btHeightfieldTerrainShape *)result; + return _swig_go_result; +} + + +btHeightfieldTerrainShape *_wrap_new_btHeightfieldTerrainShape__SWIG_5_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1, void *_swig_go_2, float _swig_go_3, intgo _swig_go_4, bool _swig_go_5, bool _swig_go_6) { + int arg1 ; + int arg2 ; + void *arg3 = (void *) 0 ; + btScalar arg4 ; + int arg5 ; + bool arg6 ; + bool arg7 ; + btHeightfieldTerrainShape *result = 0 ; + btHeightfieldTerrainShape *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = *(void **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (int)_swig_go_4; + arg6 = (bool)_swig_go_5; + arg7 = (bool)_swig_go_6; + + result = (btHeightfieldTerrainShape *)new btHeightfieldTerrainShape(arg1,arg2,(void const *)arg3,arg4,arg5,arg6,arg7); + *(btHeightfieldTerrainShape **)&_swig_go_result = (btHeightfieldTerrainShape *)result; + return _swig_go_result; +} + + +void _wrap_delete_btHeightfieldTerrainShape_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btHeightfieldTerrainShape_setUseDiamondSubdivision__SWIG_0_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, bool _swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool arg2 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setUseDiamondSubdivision(arg2); + +} + + +void _wrap_btHeightfieldTerrainShape_setUseDiamondSubdivision__SWIG_1_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + (arg1)->setUseDiamondSubdivision(); + +} + + +void _wrap_btHeightfieldTerrainShape_setUseZigzagSubdivision__SWIG_0_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, bool _swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool arg2 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setUseZigzagSubdivision(arg2); + +} + + +void _wrap_btHeightfieldTerrainShape_setUseZigzagSubdivision__SWIG_1_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + (arg1)->setUseZigzagSubdivision(); + +} + + +void _wrap_btHeightfieldTerrainShape_setFlipTriangleWinding_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, bool _swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool arg2 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setFlipTriangleWinding(arg2); + +} + + +void _wrap_btHeightfieldTerrainShape_getAabb_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btHeightfieldTerrainShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btHeightfieldTerrainShape_processAllTriangles_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, btTriangleCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btTriangleCallback *arg2 = (btTriangleCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = *(btTriangleCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btHeightfieldTerrainShape const *)arg1)->processAllTriangles(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btHeightfieldTerrainShape_calculateLocalInertia_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btHeightfieldTerrainShape const *)arg1)->calculateLocalInertia(arg2,*arg3); + +} + + +void _wrap_btHeightfieldTerrainShape_setLocalScaling_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, btVector3 *_swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btHeightfieldTerrainShape_getLocalScaling_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + result = (btVector3 *) &((btHeightfieldTerrainShape const *)arg1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btHeightfieldTerrainShape_getVertex_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2, btVector3 *_swig_go_3) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + int arg2 ; + int arg3 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btHeightfieldTerrainShape const *)arg1)->getVertex(arg2,arg3,*arg4); + +} + + +void _wrap_btHeightfieldTerrainShape_performRaycast_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, btTriangleCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btTriangleCallback *arg2 = (btTriangleCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = *(btTriangleCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btHeightfieldTerrainShape const *)arg1)->performRaycast(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btHeightfieldTerrainShape_buildAccelerator__SWIG_0_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, intgo _swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + int arg2 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->buildAccelerator(arg2); + +} + + +void _wrap_btHeightfieldTerrainShape_buildAccelerator__SWIG_1_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + (arg1)->buildAccelerator(); + +} + + +void _wrap_btHeightfieldTerrainShape_clearAccelerator_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + (arg1)->clearAccelerator(); + +} + + +intgo _wrap_btHeightfieldTerrainShape_getUpAxis_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + result = (int)((btHeightfieldTerrainShape const *)arg1)->getUpAxis(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btHeightfieldTerrainShape_getName_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + result = (char *)((btHeightfieldTerrainShape const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btHeightfieldTerrainShape_setUserValue3_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, float _swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setUserValue3(arg2); + +} + + +float _wrap_btHeightfieldTerrainShape_getUserValue3_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + result = (btScalar)((btHeightfieldTerrainShape const *)arg1)->getUserValue3(); + _swig_go_result = result; + return _swig_go_result; +} + + +btTriangleInfoMap *_wrap_btHeightfieldTerrainShape_getTriangleInfoMap__SWIG_0_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btTriangleInfoMap *result = 0 ; + btTriangleInfoMap *_swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + result = (btTriangleInfoMap *)((btHeightfieldTerrainShape const *)arg1)->getTriangleInfoMap(); + *(btTriangleInfoMap **)&_swig_go_result = (btTriangleInfoMap *)result; + return _swig_go_result; +} + + +btTriangleInfoMap *_wrap_btHeightfieldTerrainShape_getTriangleInfoMap__SWIG_1_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btTriangleInfoMap *result = 0 ; + btTriangleInfoMap *_swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + result = (btTriangleInfoMap *)(arg1)->getTriangleInfoMap(); + *(btTriangleInfoMap **)&_swig_go_result = (btTriangleInfoMap *)result; + return _swig_go_result; +} + + +void _wrap_btHeightfieldTerrainShape_setTriangleInfoMap_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, btTriangleInfoMap *_swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btTriangleInfoMap *arg2 = (btTriangleInfoMap *) 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = *(btTriangleInfoMap **)&_swig_go_1; + + (arg1)->setTriangleInfoMap(arg2); + +} + + +char *_wrap_btHeightfieldTerrainShape_getHeightfieldRawData_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + unsigned char *result = 0 ; + char *_swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + result = (unsigned char *)((btHeightfieldTerrainShape const *)arg1)->getHeightfieldRawData(); + *(unsigned char **)&_swig_go_result = (unsigned char *)result; + return _swig_go_result; +} + + +float _wrap_btHeightfieldTerrainShape_getMargin_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + result = (btScalar)((btConcaveShape const *)swig_b0)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btHeightfieldTerrainShape_setMargin_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, float _swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + (swig_b0)->setMargin(arg2); + +} + + +void _wrap_btHeightfieldTerrainShape_getBoundingSphere_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btHeightfieldTerrainShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (btScalar)((btCollisionShape const *)swig_b1)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btHeightfieldTerrainShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, float _swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (btScalar)((btCollisionShape const *)swig_b1)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btHeightfieldTerrainShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btHeightfieldTerrainShape_isPolyhedral_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btHeightfieldTerrainShape_isConvex2d_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btHeightfieldTerrainShape_isConvex_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btHeightfieldTerrainShape_isNonMoving_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btHeightfieldTerrainShape_isConcave_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btHeightfieldTerrainShape_isCompound_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btHeightfieldTerrainShape_isSoftBody_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btHeightfieldTerrainShape_isInfinite_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btHeightfieldTerrainShape_getShapeType_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btHeightfieldTerrainShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = ((btCollisionShape const *)swig_b1)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btHeightfieldTerrainShape_setUserPointer_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, void *_swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserPointer(arg2); + +} + + +void *_wrap_btHeightfieldTerrainShape_getUserPointer_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (void *)((btCollisionShape const *)swig_b1)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btHeightfieldTerrainShape_setUserIndex_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, intgo _swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + int arg2 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserIndex(arg2); + +} + + +intgo _wrap_btHeightfieldTerrainShape_getUserIndex_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btHeightfieldTerrainShape_setUserIndex2_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, intgo _swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + int arg2 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserIndex2(arg2); + +} + + +intgo _wrap_btHeightfieldTerrainShape_getUserIndex2_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btHeightfieldTerrainShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btHeightfieldTerrainShape_serialize_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (char *)((btCollisionShape const *)swig_b1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btHeightfieldTerrainShape_serializeSingleShape_mbt_e879218550ba2e2b(btHeightfieldTerrainShape *_swig_go_0, btSerializer *_swig_go_1) { + btHeightfieldTerrainShape *arg1 = (btHeightfieldTerrainShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btHeightfieldTerrainShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->serializeSingleShape(arg2); + +} + + +void _wrap_btTriangleRaycastCallback_m_from_set_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0, btVector3 *_swig_go_1) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_from = *arg2; + +} + + +btVector3 *_wrap_btTriangleRaycastCallback_m_from_get_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_from); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleRaycastCallback_m_to_set_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0, btVector3 *_swig_go_1) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_to = *arg2; + +} + + +btVector3 *_wrap_btTriangleRaycastCallback_m_to_get_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_to); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +intgo _wrap_kF_None_btTriangleRaycastCallback_mbt_e879218550ba2e2b() { + btTriangleRaycastCallback::EFlags result; + intgo _swig_go_result; + + + result = btTriangleRaycastCallback::kF_None; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_kF_FilterBackfaces_btTriangleRaycastCallback_mbt_e879218550ba2e2b() { + btTriangleRaycastCallback::EFlags result; + intgo _swig_go_result; + + + result = btTriangleRaycastCallback::kF_FilterBackfaces; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_kF_KeepUnflippedNormal_btTriangleRaycastCallback_mbt_e879218550ba2e2b() { + btTriangleRaycastCallback::EFlags result; + intgo _swig_go_result; + + + result = btTriangleRaycastCallback::kF_KeepUnflippedNormal; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_kF_UseSubSimplexConvexCastRaytest_btTriangleRaycastCallback_mbt_e879218550ba2e2b() { + btTriangleRaycastCallback::EFlags result; + intgo _swig_go_result; + + + result = btTriangleRaycastCallback::kF_UseSubSimplexConvexCastRaytest; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_kF_UseGjkConvexCastRaytest_btTriangleRaycastCallback_mbt_e879218550ba2e2b() { + btTriangleRaycastCallback::EFlags result; + intgo _swig_go_result; + + + result = btTriangleRaycastCallback::kF_UseGjkConvexCastRaytest; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_kF_DisableHeightfieldAccelerator_btTriangleRaycastCallback_mbt_e879218550ba2e2b() { + btTriangleRaycastCallback::EFlags result; + intgo _swig_go_result; + + + result = btTriangleRaycastCallback::kF_DisableHeightfieldAccelerator; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_kF_Terminator_btTriangleRaycastCallback_mbt_e879218550ba2e2b() { + btTriangleRaycastCallback::EFlags result; + intgo _swig_go_result; + + + result = btTriangleRaycastCallback::kF_Terminator; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btTriangleRaycastCallback_m_flags_set_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0, intgo _swig_go_1) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + unsigned int arg2 ; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + + if (arg1) (arg1)->m_flags = arg2; + +} + + +intgo _wrap_btTriangleRaycastCallback_m_flags_get_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + + result = (unsigned int) ((arg1)->m_flags); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleRaycastCallback_m_hitFraction_set_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0, float _swig_go_1) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_hitFraction = arg2; + +} + + +float _wrap_btTriangleRaycastCallback_m_hitFraction_get_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_hitFraction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleRaycastCallback_processTriangle_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->processTriangle(arg2,arg3,arg4); + +} + + +float _wrap_btTriangleRaycastCallback_reportHit_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2, intgo _swig_go_3, intgo _swig_go_4) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + int arg4 ; + int arg5 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (int)_swig_go_4; + + result = (btScalar)(arg1)->reportHit((btVector3 const &)*arg2,arg3,arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btTriangleRaycastCallback_mbt_e879218550ba2e2b(btTriangleRaycastCallback *_swig_go_0) { + btTriangleRaycastCallback *arg1 = (btTriangleRaycastCallback *) 0 ; + + arg1 = *(btTriangleRaycastCallback **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btTriangleConvexcastCallback_m_convexShape_set_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0, btConvexShape *_swig_go_1) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + + if (arg1) (arg1)->m_convexShape = (btConvexShape const *)arg2; + +} + + +btConvexShape *_wrap_btTriangleConvexcastCallback_m_convexShape_get_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btConvexShape *result = 0 ; + btConvexShape *_swig_go_result; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + + result = (btConvexShape *) ((arg1)->m_convexShape); + *(btConvexShape **)&_swig_go_result = (btConvexShape *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleConvexcastCallback_m_convexShapeFrom_set_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0, btTransform *_swig_go_1) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_convexShapeFrom = *arg2; + +} + + +btTransform *_wrap_btTriangleConvexcastCallback_m_convexShapeFrom_get_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_convexShapeFrom); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleConvexcastCallback_m_convexShapeTo_set_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0, btTransform *_swig_go_1) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_convexShapeTo = *arg2; + +} + + +btTransform *_wrap_btTriangleConvexcastCallback_m_convexShapeTo_get_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_convexShapeTo); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleConvexcastCallback_m_triangleToWorld_set_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0, btTransform *_swig_go_1) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_triangleToWorld = *arg2; + +} + + +btTransform *_wrap_btTriangleConvexcastCallback_m_triangleToWorld_get_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_triangleToWorld); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btTriangleConvexcastCallback_m_hitFraction_set_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0, float _swig_go_1) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_hitFraction = arg2; + +} + + +float _wrap_btTriangleConvexcastCallback_m_hitFraction_get_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_hitFraction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleConvexcastCallback_m_triangleCollisionMargin_set_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0, float _swig_go_1) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_triangleCollisionMargin = arg2; + +} + + +float _wrap_btTriangleConvexcastCallback_m_triangleCollisionMargin_get_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_triangleCollisionMargin); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleConvexcastCallback_m_allowedPenetration_set_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0, float _swig_go_1) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btScalar arg2 ; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_allowedPenetration = arg2; + +} + + +float _wrap_btTriangleConvexcastCallback_m_allowedPenetration_get_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_allowedPenetration); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTriangleConvexcastCallback_processTriangle_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->processTriangle(arg2,arg3,arg4); + +} + + +float _wrap_btTriangleConvexcastCallback_reportHit_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3, intgo _swig_go_4, intgo _swig_go_5) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + int arg5 ; + int arg6 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (int)_swig_go_4; + arg6 = (int)_swig_go_5; + + result = (btScalar)(arg1)->reportHit((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5,arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btTriangleConvexcastCallback_mbt_e879218550ba2e2b(btTriangleConvexcastCallback *_swig_go_0) { + btTriangleConvexcastCallback *arg1 = (btTriangleConvexcastCallback *) 0 ; + + arg1 = *(btTriangleConvexcastCallback **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_DBG_NoDebug_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_NoDebug; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_DrawWireframe_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_DrawWireframe; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_DrawAabb_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_DrawAabb; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_DrawFeaturesText_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_DrawFeaturesText; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_DrawContactPoints_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_DrawContactPoints; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_NoDeactivation_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_NoDeactivation; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_NoHelpText_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_NoHelpText; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_DrawText_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_DrawText; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_ProfileTimings_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_ProfileTimings; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_EnableSatComparison_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_EnableSatComparison; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_DisableBulletLCP_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_DisableBulletLCP; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_EnableCCD_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_EnableCCD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_DrawConstraints_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_DrawConstraints; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_DrawConstraintLimits_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_DrawConstraintLimits; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_FastWireframe_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_FastWireframe; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_DrawNormals_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_DrawNormals; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_DrawFrames_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_DrawFrames; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_DBG_MAX_DEBUG_DRAW_MODE_btIDebugDraw_mbt_e879218550ba2e2b() { + btIDebugDraw::DebugDrawModes result; + intgo _swig_go_result; + + + result = btIDebugDraw::DBG_MAX_DEBUG_DRAW_MODE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_delete_btIDebugDraw_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + + delete arg1; + +} + + +btIDebugDraw::DefaultColors *_wrap_btIDebugDraw_getDefaultColors_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btIDebugDraw::DefaultColors result; + btIDebugDraw::DefaultColors *_swig_go_result; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + + result = ((btIDebugDraw const *)arg1)->getDefaultColors(); + *(btIDebugDraw::DefaultColors **)&_swig_go_result = new btIDebugDraw::DefaultColors(result); + return _swig_go_result; +} + + +void _wrap_btIDebugDraw_setDefaultColors_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btIDebugDraw::DefaultColors *_swig_go_1) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btIDebugDraw::DefaultColors *arg2 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btIDebugDraw::DefaultColors **)&_swig_go_1; + + (arg1)->setDefaultColors((btIDebugDraw::DefaultColors const &)*arg2); + +} + + +void _wrap_btIDebugDraw_drawLine__SWIG_0_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btIDebugDraw_drawLine__SWIG_1_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + (arg1)->drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5); + +} + + +void _wrap_btIDebugDraw_drawSphere__SWIG_0_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, float _swig_go_1, btTransform *_swig_go_2, btVector3 *_swig_go_3) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btScalar arg2 ; + btTransform *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawSphere(arg2,(btTransform const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btIDebugDraw_drawSphere__SWIG_1_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2, btVector3 *_swig_go_3) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawSphere((btVector3 const &)*arg2,arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btIDebugDraw_drawTriangle__SWIG_0_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7, float _swig_go_8) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + btScalar arg9 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = (btScalar)_swig_go_8; + + (arg1)->drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8,arg9); + +} + + +void _wrap_btIDebugDraw_drawTriangle__SWIG_1_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, float _swig_go_5) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btScalar arg6 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + (arg1)->drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,arg6); + +} + + +void _wrap_btIDebugDraw_drawContactPoint_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3, intgo _swig_go_4, btVector3 *_swig_go_5) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + int arg5 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (int)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->drawContactPoint((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btIDebugDraw_reportErrorWarning_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, _gostring_ _swig_go_1) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + (arg1)->reportErrorWarning((char const *)arg2); + + free(arg2); +} + + +void _wrap_btIDebugDraw_draw3dText_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, _gostring_ _swig_go_2) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + char *arg3 = (char *) 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + arg3 = (char *)malloc(_swig_go_2.n + 1); + memcpy(arg3, _swig_go_2.p, _swig_go_2.n); + arg3[_swig_go_2.n] = '\0'; + + + (arg1)->draw3dText((btVector3 const &)*arg2,(char const *)arg3); + + free(arg3); +} + + +void _wrap_btIDebugDraw_setDebugMode_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, intgo _swig_go_1) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + int arg2 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setDebugMode(arg2); + +} + + +intgo _wrap_btIDebugDraw_getDebugMode_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + + result = (int)((btIDebugDraw const *)arg1)->getDebugMode(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btIDebugDraw_drawAabb_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawAabb((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btIDebugDraw_drawTransform_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btTransform *_swig_go_1, float _swig_go_2) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btTransform *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->drawTransform((btTransform const &)*arg2,arg3); + +} + + +void _wrap_btIDebugDraw_drawArc__SWIG_0_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, btVector3 *_swig_go_8, bool _swig_go_9, float _swig_go_10) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + btScalar arg8 ; + btVector3 *arg9 = 0 ; + bool arg10 ; + btScalar arg11 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + arg9 = *(btVector3 **)&_swig_go_8; + arg10 = (bool)_swig_go_9; + arg11 = (btScalar)_swig_go_10; + + (arg1)->drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10,arg11); + +} + + +void _wrap_btIDebugDraw_drawArc__SWIG_1_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, btVector3 *_swig_go_8, bool _swig_go_9) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + btScalar arg8 ; + btVector3 *arg9 = 0 ; + bool arg10 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + arg9 = *(btVector3 **)&_swig_go_8; + arg10 = (bool)_swig_go_9; + + (arg1)->drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10); + +} + + +void _wrap_btIDebugDraw_drawSpherePatch__SWIG_0_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, float _swig_go_8, btVector3 *_swig_go_9, float _swig_go_10, bool _swig_go_11) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + btScalar arg8 ; + btScalar arg9 ; + btVector3 *arg10 = 0 ; + btScalar arg11 ; + bool arg12 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + arg9 = (btScalar)_swig_go_8; + arg10 = *(btVector3 **)&_swig_go_9; + arg11 = (btScalar)_swig_go_10; + arg12 = (bool)_swig_go_11; + + (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11,arg12); + +} + + +void _wrap_btIDebugDraw_drawSpherePatch__SWIG_1_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, float _swig_go_8, btVector3 *_swig_go_9, float _swig_go_10) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + btScalar arg8 ; + btScalar arg9 ; + btVector3 *arg10 = 0 ; + btScalar arg11 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + arg9 = (btScalar)_swig_go_8; + arg10 = *(btVector3 **)&_swig_go_9; + arg11 = (btScalar)_swig_go_10; + + (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11); + +} + + +void _wrap_btIDebugDraw_drawSpherePatch__SWIG_2_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, float _swig_go_8, btVector3 *_swig_go_9) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + btScalar arg8 ; + btScalar arg9 ; + btVector3 *arg10 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + arg9 = (btScalar)_swig_go_8; + arg10 = *(btVector3 **)&_swig_go_9; + + (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10); + +} + + +void _wrap_btIDebugDraw_drawBox__SWIG_0_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btIDebugDraw_drawBox__SWIG_1_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + (arg1)->drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); + +} + + +void _wrap_btIDebugDraw_drawCapsule_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, float _swig_go_1, float _swig_go_2, intgo _swig_go_3, btTransform *_swig_go_4, btVector3 *_swig_go_5) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + int arg4 ; + btTransform *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->drawCapsule(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btIDebugDraw_drawCylinder_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, float _swig_go_1, float _swig_go_2, intgo _swig_go_3, btTransform *_swig_go_4, btVector3 *_swig_go_5) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + int arg4 ; + btTransform *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->drawCylinder(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btIDebugDraw_drawCone_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, float _swig_go_1, float _swig_go_2, intgo _swig_go_3, btTransform *_swig_go_4, btVector3 *_swig_go_5) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + int arg4 ; + btTransform *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->drawCone(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btIDebugDraw_drawPlane_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + (arg1)->drawPlane((btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); + +} + + +void _wrap_btIDebugDraw_clearLines_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + + (arg1)->clearLines(); + +} + + +void _wrap_btIDebugDraw_flushLines_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + + (arg1)->flushLines(); + +} + + +void _wrap_delete_btConvexCast_mbt_e879218550ba2e2b(btConvexCast *_swig_go_0) { + btConvexCast *arg1 = (btConvexCast *) 0 ; + + arg1 = *(btConvexCast **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btConvexCast_calcTimeOfImpact_mbt_e879218550ba2e2b(btConvexCast *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btTransform *_swig_go_4, btConvexCast::CastResult *_swig_go_5) { + btConvexCast *arg1 = (btConvexCast *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btTransform *arg5 = 0 ; + btConvexCast::CastResult *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexCast **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btConvexCast::CastResult **)&_swig_go_5; + + result = (bool)(arg1)->calcTimeOfImpact((btTransform const &)*arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btTransform const &)*arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +btSubsimplexConvexCast *_wrap_new_btSubsimplexConvexCast_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btConvexShape *_swig_go_1, btVoronoiSimplexSolver *_swig_go_2) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + btVoronoiSimplexSolver *arg3 = (btVoronoiSimplexSolver *) 0 ; + btSubsimplexConvexCast *result = 0 ; + btSubsimplexConvexCast *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = *(btVoronoiSimplexSolver **)&_swig_go_2; + + result = (btSubsimplexConvexCast *)new btSubsimplexConvexCast((btConvexShape const *)arg1,(btConvexShape const *)arg2,arg3); + *(btSubsimplexConvexCast **)&_swig_go_result = (btSubsimplexConvexCast *)result; + return _swig_go_result; +} + + +bool _wrap_btSubsimplexConvexCast_calcTimeOfImpact_mbt_e879218550ba2e2b(btSubsimplexConvexCast *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btTransform *_swig_go_4, btConvexCast::CastResult *_swig_go_5) { + btSubsimplexConvexCast *arg1 = (btSubsimplexConvexCast *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btTransform *arg5 = 0 ; + btConvexCast::CastResult *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSubsimplexConvexCast **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btConvexCast::CastResult **)&_swig_go_5; + + result = (bool)(arg1)->calcTimeOfImpact((btTransform const &)*arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btTransform const &)*arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btSubsimplexConvexCast_mbt_e879218550ba2e2b(btSubsimplexConvexCast *_swig_go_0) { + btSubsimplexConvexCast *arg1 = (btSubsimplexConvexCast *) 0 ; + + arg1 = *(btSubsimplexConvexCast **)&_swig_go_0; + + delete arg1; + +} + + +btGjkConvexCast *_wrap_new_btGjkConvexCast_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btConvexShape *_swig_go_1, btVoronoiSimplexSolver *_swig_go_2) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + btVoronoiSimplexSolver *arg3 = (btVoronoiSimplexSolver *) 0 ; + btGjkConvexCast *result = 0 ; + btGjkConvexCast *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = *(btVoronoiSimplexSolver **)&_swig_go_2; + + result = (btGjkConvexCast *)new btGjkConvexCast((btConvexShape const *)arg1,(btConvexShape const *)arg2,arg3); + *(btGjkConvexCast **)&_swig_go_result = (btGjkConvexCast *)result; + return _swig_go_result; +} + + +bool _wrap_btGjkConvexCast_calcTimeOfImpact_mbt_e879218550ba2e2b(btGjkConvexCast *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btTransform *_swig_go_4, btConvexCast::CastResult *_swig_go_5) { + btGjkConvexCast *arg1 = (btGjkConvexCast *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btTransform *arg5 = 0 ; + btConvexCast::CastResult *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGjkConvexCast **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btConvexCast::CastResult **)&_swig_go_5; + + result = (bool)(arg1)->calcTimeOfImpact((btTransform const &)*arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btTransform const &)*arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btGjkConvexCast_mbt_e879218550ba2e2b(btGjkConvexCast *_swig_go_0) { + btGjkConvexCast *arg1 = (btGjkConvexCast *) 0 ; + + arg1 = *(btGjkConvexCast **)&_swig_go_0; + + delete arg1; + +} + + +btContinuousConvexCollision *_wrap_new_btContinuousConvexCollision__SWIG_0_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btConvexShape *_swig_go_1, btVoronoiSimplexSolver *_swig_go_2, btConvexPenetrationDepthSolver *_swig_go_3) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + btVoronoiSimplexSolver *arg3 = (btVoronoiSimplexSolver *) 0 ; + btConvexPenetrationDepthSolver *arg4 = (btConvexPenetrationDepthSolver *) 0 ; + btContinuousConvexCollision *result = 0 ; + btContinuousConvexCollision *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = *(btVoronoiSimplexSolver **)&_swig_go_2; + arg4 = *(btConvexPenetrationDepthSolver **)&_swig_go_3; + + result = (btContinuousConvexCollision *)new btContinuousConvexCollision((btConvexShape const *)arg1,(btConvexShape const *)arg2,arg3,arg4); + *(btContinuousConvexCollision **)&_swig_go_result = (btContinuousConvexCollision *)result; + return _swig_go_result; +} + + +btContinuousConvexCollision *_wrap_new_btContinuousConvexCollision__SWIG_1_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btStaticPlaneShape *_swig_go_1) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btStaticPlaneShape *arg2 = (btStaticPlaneShape *) 0 ; + btContinuousConvexCollision *result = 0 ; + btContinuousConvexCollision *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btStaticPlaneShape **)&_swig_go_1; + + result = (btContinuousConvexCollision *)new btContinuousConvexCollision((btConvexShape const *)arg1,(btStaticPlaneShape const *)arg2); + *(btContinuousConvexCollision **)&_swig_go_result = (btContinuousConvexCollision *)result; + return _swig_go_result; +} + + +bool _wrap_btContinuousConvexCollision_calcTimeOfImpact_mbt_e879218550ba2e2b(btContinuousConvexCollision *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btTransform *_swig_go_4, btConvexCast::CastResult *_swig_go_5) { + btContinuousConvexCollision *arg1 = (btContinuousConvexCollision *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btTransform *arg5 = 0 ; + btConvexCast::CastResult *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btContinuousConvexCollision **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btConvexCast::CastResult **)&_swig_go_5; + + result = (bool)(arg1)->calcTimeOfImpact((btTransform const &)*arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btTransform const &)*arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btContinuousConvexCollision_mbt_e879218550ba2e2b(btContinuousConvexCollision *_swig_go_0) { + btContinuousConvexCollision *arg1 = (btContinuousConvexCollision *) 0 ; + + arg1 = *(btContinuousConvexCollision **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btSingleRayCallback_m_rayFromWorld_set_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, btVector3 *_swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_rayFromWorld = *arg2; + +} + + +btVector3 *_wrap_btSingleRayCallback_m_rayFromWorld_get_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_rayFromWorld); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSingleRayCallback_m_rayToWorld_set_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, btVector3 *_swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_rayToWorld = *arg2; + +} + + +btVector3 *_wrap_btSingleRayCallback_m_rayToWorld_get_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_rayToWorld); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSingleRayCallback_m_rayFromTrans_set_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, btTransform *_swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_rayFromTrans = *arg2; + +} + + +btTransform *_wrap_btSingleRayCallback_m_rayFromTrans_get_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_rayFromTrans); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btSingleRayCallback_m_rayToTrans_set_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, btTransform *_swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_rayToTrans = *arg2; + +} + + +btTransform *_wrap_btSingleRayCallback_m_rayToTrans_get_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_rayToTrans); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btSingleRayCallback_m_hitNormal_set_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, btVector3 *_swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_hitNormal = *arg2; + +} + + +btVector3 *_wrap_btSingleRayCallback_m_hitNormal_get_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_hitNormal); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSingleRayCallback_m_world_set_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, btCollisionWorld *_swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btCollisionWorld *arg2 = (btCollisionWorld *) 0 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = *(btCollisionWorld **)&_swig_go_1; + + if (arg1) (arg1)->m_world = (btCollisionWorld const *)arg2; + +} + + +btCollisionWorld *_wrap_btSingleRayCallback_m_world_get_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btCollisionWorld *result = 0 ; + btCollisionWorld *_swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + result = (btCollisionWorld *) ((arg1)->m_world); + *(btCollisionWorld **)&_swig_go_result = (btCollisionWorld *)result; + return _swig_go_result; +} + + +void _wrap_btSingleRayCallback_m_resultCallback_set_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, btCollisionWorld::RayResultCallback *_swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btCollisionWorld::RayResultCallback *arg2 = 0 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = *(btCollisionWorld::RayResultCallback **)&_swig_go_1; + + if (arg1) (arg1)->m_resultCallback = *arg2; + +} + + +btCollisionWorld::RayResultCallback *_wrap_btSingleRayCallback_m_resultCallback_get_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btCollisionWorld::RayResultCallback *result = 0 ; + btCollisionWorld::RayResultCallback *_swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + result = (btCollisionWorld::RayResultCallback *) &(btCollisionWorld::RayResultCallback &) ((arg1)->m_resultCallback); + *(btCollisionWorld::RayResultCallback **)&_swig_go_result = result; + return _swig_go_result; +} + + +btSingleRayCallback *_wrap_new_btSingleRayCallback_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btCollisionWorld *_swig_go_2, btCollisionWorld::RayResultCallback *_swig_go_3) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btCollisionWorld *arg3 = (btCollisionWorld *) 0 ; + btCollisionWorld::RayResultCallback *arg4 = 0 ; + btSingleRayCallback *result = 0 ; + btSingleRayCallback *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btCollisionWorld **)&_swig_go_2; + arg4 = *(btCollisionWorld::RayResultCallback **)&_swig_go_3; + + result = (btSingleRayCallback *)new btSingleRayCallback((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btCollisionWorld const *)arg3,*arg4); + *(btSingleRayCallback **)&_swig_go_result = (btSingleRayCallback *)result; + return _swig_go_result; +} + + +bool _wrap_btSingleRayCallback_process_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + result = (bool)(arg1)->process((btBroadphaseProxy const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btSingleRayCallback_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_SetbtSingleRayCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, btVector3 *_swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + if (swig_b0) (swig_b0)->m_rayDirectionInverse = *arg2; + +} + + +btVector3 *_wrap_GetbtSingleRayCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + result = (btVector3 *)& ((swig_b0)->m_rayDirectionInverse); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_SetbtSingleRayCallback_M_signs_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, intgo *_swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + unsigned int *arg2 = (unsigned int *) (unsigned int *)0 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = *(unsigned int **)&_swig_go_1; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + ; + +} + + +intgo *_wrap_GetbtSingleRayCallback_M_signs_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + unsigned int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + result = (unsigned int *)(unsigned int *) ((swig_b0)->m_signs); + *(unsigned int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtSingleRayCallback_M_lambda_max_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0, float _swig_go_1) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btScalar arg2 ; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + if (swig_b0) (swig_b0)->m_lambda_max = arg2; + +} + + +float _wrap_GetbtSingleRayCallback_M_lambda_max_mbt_e879218550ba2e2b(btSingleRayCallback *_swig_go_0) { + btSingleRayCallback *arg1 = (btSingleRayCallback *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSingleRayCallback **)&_swig_go_0; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + result = (btScalar) ((swig_b0)->m_lambda_max); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSingleSweepCallback_m_convexFromTrans_set_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, btTransform *_swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_convexFromTrans = *arg2; + +} + + +btTransform *_wrap_btSingleSweepCallback_m_convexFromTrans_get_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_convexFromTrans); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btSingleSweepCallback_m_convexToTrans_set_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, btTransform *_swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_convexToTrans = *arg2; + +} + + +btTransform *_wrap_btSingleSweepCallback_m_convexToTrans_get_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_convexToTrans); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_btSingleSweepCallback_m_hitNormal_set_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, btVector3 *_swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_hitNormal = *arg2; + +} + + +btVector3 *_wrap_btSingleSweepCallback_m_hitNormal_get_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_hitNormal); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSingleSweepCallback_m_world_set_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, btCollisionWorld *_swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btCollisionWorld *arg2 = (btCollisionWorld *) 0 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = *(btCollisionWorld **)&_swig_go_1; + + if (arg1) (arg1)->m_world = (btCollisionWorld const *)arg2; + +} + + +btCollisionWorld *_wrap_btSingleSweepCallback_m_world_get_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btCollisionWorld *result = 0 ; + btCollisionWorld *_swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + result = (btCollisionWorld *) ((arg1)->m_world); + *(btCollisionWorld **)&_swig_go_result = (btCollisionWorld *)result; + return _swig_go_result; +} + + +void _wrap_btSingleSweepCallback_m_resultCallback_set_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, btCollisionWorld::ConvexResultCallback *_swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btCollisionWorld::ConvexResultCallback *arg2 = 0 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_1; + + if (arg1) (arg1)->m_resultCallback = *arg2; + +} + + +btCollisionWorld::ConvexResultCallback *_wrap_btSingleSweepCallback_m_resultCallback_get_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btCollisionWorld::ConvexResultCallback *result = 0 ; + btCollisionWorld::ConvexResultCallback *_swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + result = (btCollisionWorld::ConvexResultCallback *) &(btCollisionWorld::ConvexResultCallback &) ((arg1)->m_resultCallback); + *(btCollisionWorld::ConvexResultCallback **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSingleSweepCallback_m_allowedCcdPenetration_set_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, float _swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btScalar arg2 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_allowedCcdPenetration = arg2; + +} + + +float _wrap_btSingleSweepCallback_m_allowedCcdPenetration_get_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_allowedCcdPenetration); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSingleSweepCallback_m_castShape_set_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, btConvexShape *_swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + + if (arg1) (arg1)->m_castShape = (btConvexShape const *)arg2; + +} + + +btConvexShape *_wrap_btSingleSweepCallback_m_castShape_get_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btConvexShape *result = 0 ; + btConvexShape *_swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + result = (btConvexShape *) ((arg1)->m_castShape); + *(btConvexShape **)&_swig_go_result = (btConvexShape *)result; + return _swig_go_result; +} + + +btSingleSweepCallback *_wrap_new_btSingleSweepCallback_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btCollisionWorld *_swig_go_3, btCollisionWorld::ConvexResultCallback *_swig_go_4, float _swig_go_5) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btCollisionWorld *arg4 = (btCollisionWorld *) 0 ; + btCollisionWorld::ConvexResultCallback *arg5 = 0 ; + btScalar arg6 ; + btSingleSweepCallback *result = 0 ; + btSingleSweepCallback *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btCollisionWorld **)&_swig_go_3; + arg5 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + result = (btSingleSweepCallback *)new btSingleSweepCallback((btConvexShape const *)arg1,(btTransform const &)*arg2,(btTransform const &)*arg3,(btCollisionWorld const *)arg4,*arg5,arg6); + *(btSingleSweepCallback **)&_swig_go_result = (btSingleSweepCallback *)result; + return _swig_go_result; +} + + +bool _wrap_btSingleSweepCallback_process_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + result = (bool)(arg1)->process((btBroadphaseProxy const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btSingleSweepCallback_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_SetbtSingleSweepCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, btVector3 *_swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + if (swig_b0) (swig_b0)->m_rayDirectionInverse = *arg2; + +} + + +btVector3 *_wrap_GetbtSingleSweepCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + result = (btVector3 *)& ((swig_b0)->m_rayDirectionInverse); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_SetbtSingleSweepCallback_M_signs_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, intgo *_swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + unsigned int *arg2 = (unsigned int *) (unsigned int *)0 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = *(unsigned int **)&_swig_go_1; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + ; + +} + + +intgo *_wrap_GetbtSingleSweepCallback_M_signs_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + unsigned int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + result = (unsigned int *)(unsigned int *) ((swig_b0)->m_signs); + *(unsigned int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtSingleSweepCallback_M_lambda_max_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0, float _swig_go_1) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btScalar arg2 ; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + if (swig_b0) (swig_b0)->m_lambda_max = arg2; + +} + + +float _wrap_GetbtSingleSweepCallback_M_lambda_max_mbt_e879218550ba2e2b(btSingleSweepCallback *_swig_go_0) { + btSingleSweepCallback *arg1 = (btSingleSweepCallback *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSingleSweepCallback **)&_swig_go_0; + + btBroadphaseRayCallback *swig_b0 = (btBroadphaseRayCallback *)arg1; + result = (btScalar) ((swig_b0)->m_lambda_max); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btBridgedManifoldResult_m_resultCallback_set_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0, btCollisionWorld::ContactResultCallback *_swig_go_1) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btCollisionWorld::ContactResultCallback *arg2 = 0 ; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + arg2 = *(btCollisionWorld::ContactResultCallback **)&_swig_go_1; + + if (arg1) (arg1)->m_resultCallback = *arg2; + +} + + +btCollisionWorld::ContactResultCallback *_wrap_btBridgedManifoldResult_m_resultCallback_get_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btCollisionWorld::ContactResultCallback *result = 0 ; + btCollisionWorld::ContactResultCallback *_swig_go_result; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + + result = (btCollisionWorld::ContactResultCallback *) &(btCollisionWorld::ContactResultCallback &) ((arg1)->m_resultCallback); + *(btCollisionWorld::ContactResultCallback **)&_swig_go_result = result; + return _swig_go_result; +} + + +btBridgedManifoldResult *_wrap_new_btBridgedManifoldResult_mbt_e879218550ba2e2b(btCollisionObjectWrapper *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionWorld::ContactResultCallback *_swig_go_2) { + btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionWorld::ContactResultCallback *arg3 = 0 ; + btBridgedManifoldResult *result = 0 ; + btBridgedManifoldResult *_swig_go_result; + + arg1 = *(btCollisionObjectWrapper **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionWorld::ContactResultCallback **)&_swig_go_2; + + result = (btBridgedManifoldResult *)new btBridgedManifoldResult((btCollisionObjectWrapper const *)arg1,(btCollisionObjectWrapper const *)arg2,*arg3); + *(btBridgedManifoldResult **)&_swig_go_result = (btBridgedManifoldResult *)result; + return _swig_go_result; +} + + +void _wrap_btBridgedManifoldResult_addContactPoint_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->addContactPoint((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); + +} + + +void _wrap_delete_btBridgedManifoldResult_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btBridgedManifoldResult_setPersistentManifold_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0, btPersistentManifold *_swig_go_1) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btPersistentManifold *arg2 = (btPersistentManifold *) 0 ; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + arg2 = *(btPersistentManifold **)&_swig_go_1; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + (swig_b0)->setPersistentManifold(arg2); + +} + + +btPersistentManifold *_wrap_btBridgedManifoldResult_getPersistentManifold__SWIG_0_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + result = (btPersistentManifold *)((btManifoldResult const *)swig_b0)->getPersistentManifold(); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +btPersistentManifold *_wrap_btBridgedManifoldResult_getPersistentManifold__SWIG_1_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + result = (btPersistentManifold *)(swig_b0)->getPersistentManifold(); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +void _wrap_btBridgedManifoldResult_setShapeIdentifiersA_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + (swig_b0)->setShapeIdentifiersA(arg2,arg3); + +} + + +void _wrap_btBridgedManifoldResult_setShapeIdentifiersB_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + (swig_b0)->setShapeIdentifiersB(arg2,arg3); + +} + + +void _wrap_btBridgedManifoldResult_refreshContactPoints_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + (swig_b0)->refreshContactPoints(); + +} + + +btCollisionObjectWrapper *_wrap_btBridgedManifoldResult_getBody0Wrap_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btCollisionObjectWrapper *result = 0 ; + btCollisionObjectWrapper *_swig_go_result; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + result = (btCollisionObjectWrapper *)((btManifoldResult const *)swig_b0)->getBody0Wrap(); + *(btCollisionObjectWrapper **)&_swig_go_result = (btCollisionObjectWrapper *)result; + return _swig_go_result; +} + + +btCollisionObjectWrapper *_wrap_btBridgedManifoldResult_getBody1Wrap_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btCollisionObjectWrapper *result = 0 ; + btCollisionObjectWrapper *_swig_go_result; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + result = (btCollisionObjectWrapper *)((btManifoldResult const *)swig_b0)->getBody1Wrap(); + *(btCollisionObjectWrapper **)&_swig_go_result = (btCollisionObjectWrapper *)result; + return _swig_go_result; +} + + +void _wrap_btBridgedManifoldResult_setBody0Wrap_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0, btCollisionObjectWrapper *_swig_go_1) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + (swig_b0)->setBody0Wrap((btCollisionObjectWrapper const *)arg2); + +} + + +void _wrap_btBridgedManifoldResult_setBody1Wrap_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0, btCollisionObjectWrapper *_swig_go_1) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + (swig_b0)->setBody1Wrap((btCollisionObjectWrapper const *)arg2); + +} + + +btCollisionObject *_wrap_btBridgedManifoldResult_getBody0Internal_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + result = (btCollisionObject *)((btManifoldResult const *)swig_b0)->getBody0Internal(); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +btCollisionObject *_wrap_btBridgedManifoldResult_getBody1Internal_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + result = (btCollisionObject *)((btManifoldResult const *)swig_b0)->getBody1Internal(); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +void _wrap_SetbtBridgedManifoldResult_M_closestPointDistanceThreshold_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0, float _swig_go_1) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btScalar arg2 ; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + if (swig_b0) (swig_b0)->m_closestPointDistanceThreshold = arg2; + +} + + +float _wrap_GetbtBridgedManifoldResult_M_closestPointDistanceThreshold_mbt_e879218550ba2e2b(btBridgedManifoldResult *_swig_go_0) { + btBridgedManifoldResult *arg1 = (btBridgedManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBridgedManifoldResult **)&_swig_go_0; + + btManifoldResult *swig_b0 = (btManifoldResult *)arg1; + result = (btScalar) ((swig_b0)->m_closestPointDistanceThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBridgedManifoldResult_calculateCombinedRestitution_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedRestitution((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBridgedManifoldResult_calculateCombinedFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedFriction((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBridgedManifoldResult_calculateCombinedRollingFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedRollingFriction((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBridgedManifoldResult_calculateCombinedSpinningFriction_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedSpinningFriction((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBridgedManifoldResult_calculateCombinedContactDamping_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedContactDamping((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btBridgedManifoldResult_calculateCombinedContactStiffness_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionObject *_swig_go_1) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + result = (btScalar)btManifoldResult::calculateCombinedContactStiffness((btCollisionObject const *)arg1,(btCollisionObject const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSingleContactCallback_m_collisionObject_set_mbt_e879218550ba2e2b(btSingleContactCallback *_swig_go_0, btCollisionObject *_swig_go_1) { + btSingleContactCallback *arg1 = (btSingleContactCallback *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btSingleContactCallback **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionObject = arg2; + +} + + +btCollisionObject *_wrap_btSingleContactCallback_m_collisionObject_get_mbt_e879218550ba2e2b(btSingleContactCallback *_swig_go_0) { + btSingleContactCallback *arg1 = (btSingleContactCallback *) 0 ; + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + arg1 = *(btSingleContactCallback **)&_swig_go_0; + + result = (btCollisionObject *) ((arg1)->m_collisionObject); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +void _wrap_btSingleContactCallback_m_world_set_mbt_e879218550ba2e2b(btSingleContactCallback *_swig_go_0, btCollisionWorld *_swig_go_1) { + btSingleContactCallback *arg1 = (btSingleContactCallback *) 0 ; + btCollisionWorld *arg2 = (btCollisionWorld *) 0 ; + + arg1 = *(btSingleContactCallback **)&_swig_go_0; + arg2 = *(btCollisionWorld **)&_swig_go_1; + + if (arg1) (arg1)->m_world = arg2; + +} + + +btCollisionWorld *_wrap_btSingleContactCallback_m_world_get_mbt_e879218550ba2e2b(btSingleContactCallback *_swig_go_0) { + btSingleContactCallback *arg1 = (btSingleContactCallback *) 0 ; + btCollisionWorld *result = 0 ; + btCollisionWorld *_swig_go_result; + + arg1 = *(btSingleContactCallback **)&_swig_go_0; + + result = (btCollisionWorld *) ((arg1)->m_world); + *(btCollisionWorld **)&_swig_go_result = (btCollisionWorld *)result; + return _swig_go_result; +} + + +void _wrap_btSingleContactCallback_m_resultCallback_set_mbt_e879218550ba2e2b(btSingleContactCallback *_swig_go_0, btCollisionWorld::ContactResultCallback *_swig_go_1) { + btSingleContactCallback *arg1 = (btSingleContactCallback *) 0 ; + btCollisionWorld::ContactResultCallback *arg2 = 0 ; + + arg1 = *(btSingleContactCallback **)&_swig_go_0; + arg2 = *(btCollisionWorld::ContactResultCallback **)&_swig_go_1; + + if (arg1) (arg1)->m_resultCallback = *arg2; + +} + + +btCollisionWorld::ContactResultCallback *_wrap_btSingleContactCallback_m_resultCallback_get_mbt_e879218550ba2e2b(btSingleContactCallback *_swig_go_0) { + btSingleContactCallback *arg1 = (btSingleContactCallback *) 0 ; + btCollisionWorld::ContactResultCallback *result = 0 ; + btCollisionWorld::ContactResultCallback *_swig_go_result; + + arg1 = *(btSingleContactCallback **)&_swig_go_0; + + result = (btCollisionWorld::ContactResultCallback *) &(btCollisionWorld::ContactResultCallback &) ((arg1)->m_resultCallback); + *(btCollisionWorld::ContactResultCallback **)&_swig_go_result = result; + return _swig_go_result; +} + + +btSingleContactCallback *_wrap_new_btSingleContactCallback_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btCollisionWorld *_swig_go_1, btCollisionWorld::ContactResultCallback *_swig_go_2) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btCollisionWorld *arg2 = (btCollisionWorld *) 0 ; + btCollisionWorld::ContactResultCallback *arg3 = 0 ; + btSingleContactCallback *result = 0 ; + btSingleContactCallback *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btCollisionWorld **)&_swig_go_1; + arg3 = *(btCollisionWorld::ContactResultCallback **)&_swig_go_2; + + result = (btSingleContactCallback *)new btSingleContactCallback(arg1,arg2,*arg3); + *(btSingleContactCallback **)&_swig_go_result = (btSingleContactCallback *)result; + return _swig_go_result; +} + + +bool _wrap_btSingleContactCallback_process_mbt_e879218550ba2e2b(btSingleContactCallback *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btSingleContactCallback *arg1 = (btSingleContactCallback *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSingleContactCallback **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + result = (bool)(arg1)->process((btBroadphaseProxy const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btSingleContactCallback_mbt_e879218550ba2e2b(btSingleContactCallback *_swig_go_0) { + btSingleContactCallback *arg1 = (btSingleContactCallback *) 0 ; + + arg1 = *(btSingleContactCallback **)&_swig_go_0; + + delete arg1; + +} + + +DebugDrawcallback *_wrap_new_DebugDrawcallback_mbt_e879218550ba2e2b(btIDebugDraw *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2) { + btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + DebugDrawcallback *result = 0 ; + DebugDrawcallback *_swig_go_result; + + arg1 = *(btIDebugDraw **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (DebugDrawcallback *)new DebugDrawcallback(arg1,(btTransform const &)*arg2,(btVector3 const &)*arg3); + *(DebugDrawcallback **)&_swig_go_result = (DebugDrawcallback *)result; + return _swig_go_result; +} + + +void _wrap_DebugDrawcallback_internalProcessTriangleIndex_mbt_e879218550ba2e2b(DebugDrawcallback *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + DebugDrawcallback *arg1 = (DebugDrawcallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(DebugDrawcallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->internalProcessTriangleIndex(arg2,arg3,arg4); + +} + + +void _wrap_DebugDrawcallback_processTriangle_mbt_e879218550ba2e2b(DebugDrawcallback *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + DebugDrawcallback *arg1 = (DebugDrawcallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(DebugDrawcallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->processTriangle(arg2,arg3,arg4); + +} + + +void _wrap_delete_DebugDrawcallback_mbt_e879218550ba2e2b(DebugDrawcallback *_swig_go_0) { + DebugDrawcallback *arg1 = (DebugDrawcallback *) 0 ; + + arg1 = *(DebugDrawcallback **)&_swig_go_0; + + delete arg1; + +} + + +btInternalTriangleIndexCallback *_wrap_DebugDrawcallback_SwigGetBtInternalTriangleIndexCallback_mbt_e879218550ba2e2b(DebugDrawcallback *_swig_go_0) { + DebugDrawcallback *arg1 = (DebugDrawcallback *) 0 ; + btInternalTriangleIndexCallback *result = 0 ; + btInternalTriangleIndexCallback *_swig_go_result; + + arg1 = *(DebugDrawcallback **)&_swig_go_0; + + result = (btInternalTriangleIndexCallback*)arg1; + *(btInternalTriangleIndexCallback **)&_swig_go_result = (btInternalTriangleIndexCallback *)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_RANDMIZE_ORDER_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_RANDMIZE_ORDER; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_FRICTION_SEPARATE_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_FRICTION_SEPARATE; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_USE_WARMSTARTING_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_USE_WARMSTARTING; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_USE_2_FRICTION_DIRECTIONS_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_USE_2_FRICTION_DIRECTIONS; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_ENABLE_FRICTION_DIRECTION_CACHING_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_ENABLE_FRICTION_DIRECTION_CACHING; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_CACHE_FRIENDLY_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_CACHE_FRIENDLY; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_SIMD_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_SIMD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_DISABLE_IMPLICIT_CONE_FRICTION_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_DISABLE_IMPLICIT_CONE_FRICTION; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_SOLVER_USE_ARTICULATED_WARMSTARTING_mbt_e879218550ba2e2b() { + btSolverMode result; + intgo _swig_go_result; + + + result = SOLVER_USE_ARTICULATED_WARMSTARTING; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_tau_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_tau = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_tau_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_tau); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_damping_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_damping = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_damping_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_damping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_friction_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_friction = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_friction_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_friction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_timeStep_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_timeStep = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_timeStep_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_timeStep); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_restitution_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_restitution = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_restitution_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_restitution); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_numIterations_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numIterations = arg2; + +} + + +intgo _wrap_btContactSolverInfoData_m_numIterations_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (int) ((arg1)->m_numIterations); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_maxErrorReduction_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_maxErrorReduction = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_maxErrorReduction_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_maxErrorReduction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_sor_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_sor = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_sor_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_sor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_erp_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_erp = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_erp_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_erp); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_erp2_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_erp2 = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_erp2_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_erp2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_deformable_erp_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_deformable_erp = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_deformable_erp_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_deformable_erp); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_deformable_cfm_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_deformable_cfm = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_deformable_cfm_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_deformable_cfm); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_deformable_maxErrorReduction_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_deformable_maxErrorReduction = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_deformable_maxErrorReduction_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_deformable_maxErrorReduction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_globalCfm_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_globalCfm = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_globalCfm_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_globalCfm); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_frictionERP_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_frictionERP = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_frictionERP_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_frictionERP); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_frictionCFM_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_frictionCFM = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_frictionCFM_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_frictionCFM); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_splitImpulse_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_splitImpulse = arg2; + +} + + +intgo _wrap_btContactSolverInfoData_m_splitImpulse_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (int) ((arg1)->m_splitImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_splitImpulsePenetrationThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_splitImpulsePenetrationThreshold = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_splitImpulsePenetrationThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_splitImpulsePenetrationThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_splitImpulseTurnErp_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_splitImpulseTurnErp = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_splitImpulseTurnErp_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_splitImpulseTurnErp); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_linearSlop_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_linearSlop = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_linearSlop_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_linearSlop); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_warmstartingFactor_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_warmstartingFactor = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_warmstartingFactor_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_warmstartingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_articulatedWarmstartingFactor_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_articulatedWarmstartingFactor = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_articulatedWarmstartingFactor_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_articulatedWarmstartingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_solverMode_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_solverMode = arg2; + +} + + +intgo _wrap_btContactSolverInfoData_m_solverMode_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (int) ((arg1)->m_solverMode); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_restingContactRestitutionThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_restingContactRestitutionThreshold = arg2; + +} + + +intgo _wrap_btContactSolverInfoData_m_restingContactRestitutionThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (int) ((arg1)->m_restingContactRestitutionThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_minimumSolverBatchSize_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_minimumSolverBatchSize = arg2; + +} + + +intgo _wrap_btContactSolverInfoData_m_minimumSolverBatchSize_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (int) ((arg1)->m_minimumSolverBatchSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_maxGyroscopicForce_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_maxGyroscopicForce = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_maxGyroscopicForce_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_maxGyroscopicForce); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_singleAxisRollingFrictionThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_singleAxisRollingFrictionThreshold = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_singleAxisRollingFrictionThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_singleAxisRollingFrictionThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_leastSquaresResidualThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_leastSquaresResidualThreshold = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_leastSquaresResidualThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_leastSquaresResidualThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_restitutionVelocityThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_restitutionVelocityThreshold = arg2; + +} + + +float _wrap_btContactSolverInfoData_m_restitutionVelocityThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_restitutionVelocityThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_jointFeedbackInWorldSpace_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, bool _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + bool arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_jointFeedbackInWorldSpace = arg2; + +} + + +bool _wrap_btContactSolverInfoData_m_jointFeedbackInWorldSpace_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (bool) ((arg1)->m_jointFeedbackInWorldSpace); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_jointFeedbackInJointFrame_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, bool _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + bool arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_jointFeedbackInJointFrame = arg2; + +} + + +bool _wrap_btContactSolverInfoData_m_jointFeedbackInJointFrame_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (bool) ((arg1)->m_jointFeedbackInJointFrame); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_reportSolverAnalytics_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_reportSolverAnalytics = arg2; + +} + + +intgo _wrap_btContactSolverInfoData_m_reportSolverAnalytics_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (int) ((arg1)->m_reportSolverAnalytics); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoData_m_numNonContactInnerIterations_set_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numNonContactInnerIterations = arg2; + +} + + +intgo _wrap_btContactSolverInfoData_m_numNonContactInnerIterations_get_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + result = (int) ((arg1)->m_numNonContactInnerIterations); + _swig_go_result = result; + return _swig_go_result; +} + + +btContactSolverInfoData *_wrap_new_btContactSolverInfoData_mbt_e879218550ba2e2b() { + btContactSolverInfoData *result = 0 ; + btContactSolverInfoData *_swig_go_result; + + + result = (btContactSolverInfoData *)new btContactSolverInfoData(); + *(btContactSolverInfoData **)&_swig_go_result = (btContactSolverInfoData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btContactSolverInfoData_mbt_e879218550ba2e2b(btContactSolverInfoData *_swig_go_0) { + btContactSolverInfoData *arg1 = (btContactSolverInfoData *) 0 ; + + arg1 = *(btContactSolverInfoData **)&_swig_go_0; + + delete arg1; + +} + + +btContactSolverInfo *_wrap_new_btContactSolverInfo_mbt_e879218550ba2e2b() { + btContactSolverInfo *result = 0 ; + btContactSolverInfo *_swig_go_result; + + + result = (btContactSolverInfo *)new btContactSolverInfo(); + *(btContactSolverInfo **)&_swig_go_result = (btContactSolverInfo *)result; + return _swig_go_result; +} + + +void _wrap_delete_btContactSolverInfo_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_SetbtContactSolverInfo_M_tau_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_tau = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_tau_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_tau); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_damping_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_damping = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_damping_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_damping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_friction_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_friction = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_friction_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_friction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_timeStep_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_timeStep = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_timeStep_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_timeStep); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_restitution_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_restitution = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_restitution_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_restitution); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_numIterations_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_numIterations = arg2; + +} + + +intgo _wrap_GetbtContactSolverInfo_M_numIterations_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (int) ((swig_b0)->m_numIterations); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_maxErrorReduction_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_maxErrorReduction = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_maxErrorReduction_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_maxErrorReduction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_sor_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_sor = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_sor_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_sor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_erp_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_erp = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_erp_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_erp); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_erp2_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_erp2 = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_erp2_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_erp2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_deformable_erp_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_deformable_erp = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_deformable_erp_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_deformable_erp); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_deformable_cfm_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_deformable_cfm = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_deformable_cfm_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_deformable_cfm); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_deformable_maxErrorReduction_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_deformable_maxErrorReduction = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_deformable_maxErrorReduction_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_deformable_maxErrorReduction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_globalCfm_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_globalCfm = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_globalCfm_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_globalCfm); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_frictionERP_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_frictionERP = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_frictionERP_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_frictionERP); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_frictionCFM_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_frictionCFM = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_frictionCFM_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_frictionCFM); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_splitImpulse_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_splitImpulse = arg2; + +} + + +intgo _wrap_GetbtContactSolverInfo_M_splitImpulse_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (int) ((swig_b0)->m_splitImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_splitImpulsePenetrationThreshold_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_splitImpulsePenetrationThreshold = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_splitImpulsePenetrationThreshold_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_splitImpulsePenetrationThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_splitImpulseTurnErp_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_splitImpulseTurnErp = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_splitImpulseTurnErp_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_splitImpulseTurnErp); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_linearSlop_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_linearSlop = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_linearSlop_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_linearSlop); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_warmstartingFactor_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_warmstartingFactor = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_warmstartingFactor_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_warmstartingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_articulatedWarmstartingFactor_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_articulatedWarmstartingFactor = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_articulatedWarmstartingFactor_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_articulatedWarmstartingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_solverMode_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_solverMode = arg2; + +} + + +intgo _wrap_GetbtContactSolverInfo_M_solverMode_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (int) ((swig_b0)->m_solverMode); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_restingContactRestitutionThreshold_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_restingContactRestitutionThreshold = arg2; + +} + + +intgo _wrap_GetbtContactSolverInfo_M_restingContactRestitutionThreshold_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (int) ((swig_b0)->m_restingContactRestitutionThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_minimumSolverBatchSize_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_minimumSolverBatchSize = arg2; + +} + + +intgo _wrap_GetbtContactSolverInfo_M_minimumSolverBatchSize_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (int) ((swig_b0)->m_minimumSolverBatchSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_maxGyroscopicForce_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_maxGyroscopicForce = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_maxGyroscopicForce_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_maxGyroscopicForce); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_singleAxisRollingFrictionThreshold_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_singleAxisRollingFrictionThreshold = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_singleAxisRollingFrictionThreshold_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_singleAxisRollingFrictionThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_leastSquaresResidualThreshold_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_leastSquaresResidualThreshold = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_leastSquaresResidualThreshold_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_leastSquaresResidualThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_restitutionVelocityThreshold_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, float _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_restitutionVelocityThreshold = arg2; + +} + + +float _wrap_GetbtContactSolverInfo_M_restitutionVelocityThreshold_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (btScalar) ((swig_b0)->m_restitutionVelocityThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_jointFeedbackInWorldSpace_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, bool _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + bool arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_jointFeedbackInWorldSpace = arg2; + +} + + +bool _wrap_GetbtContactSolverInfo_M_jointFeedbackInWorldSpace_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (bool) ((swig_b0)->m_jointFeedbackInWorldSpace); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_jointFeedbackInJointFrame_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, bool _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + bool arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_jointFeedbackInJointFrame = arg2; + +} + + +bool _wrap_GetbtContactSolverInfo_M_jointFeedbackInJointFrame_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (bool) ((swig_b0)->m_jointFeedbackInJointFrame); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_reportSolverAnalytics_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_reportSolverAnalytics = arg2; + +} + + +intgo _wrap_GetbtContactSolverInfo_M_reportSolverAnalytics_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (int) ((swig_b0)->m_reportSolverAnalytics); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtContactSolverInfo_M_numNonContactInnerIterations_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + if (swig_b0) (swig_b0)->m_numNonContactInnerIterations = arg2; + +} + + +intgo _wrap_GetbtContactSolverInfo_M_numNonContactInnerIterations_mbt_e879218550ba2e2b(btContactSolverInfo *_swig_go_0) { + btContactSolverInfo *arg1 = (btContactSolverInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfo **)&_swig_go_0; + + btContactSolverInfoData *swig_b0 = (btContactSolverInfoData *)arg1; + result = (int) ((swig_b0)->m_numNonContactInnerIterations); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_tau_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_tau = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_tau_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_tau); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_damping_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_damping = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_damping_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_damping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_friction_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_friction = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_friction_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_friction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_timeStep_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_timeStep = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_timeStep_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_timeStep); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_restitution_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_restitution = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_restitution_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_restitution); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_maxErrorReduction_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_maxErrorReduction = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_maxErrorReduction_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_maxErrorReduction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_sor_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_sor = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_sor_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_sor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_erp_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_erp = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_erp_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_erp); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_erp2_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_erp2 = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_erp2_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_erp2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_globalCfm_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_globalCfm = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_globalCfm_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_globalCfm); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_splitImpulsePenetrationThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_splitImpulsePenetrationThreshold = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_splitImpulsePenetrationThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_splitImpulsePenetrationThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_splitImpulseTurnErp_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_splitImpulseTurnErp = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_splitImpulseTurnErp_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_splitImpulseTurnErp); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_linearSlop_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_linearSlop = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_linearSlop_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_linearSlop); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_warmstartingFactor_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_warmstartingFactor = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_warmstartingFactor_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_warmstartingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_articulatedWarmstartingFactor_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_articulatedWarmstartingFactor = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_articulatedWarmstartingFactor_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_articulatedWarmstartingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_maxGyroscopicForce_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_maxGyroscopicForce = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_maxGyroscopicForce_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_maxGyroscopicForce); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_singleAxisRollingFrictionThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, double _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_singleAxisRollingFrictionThreshold = arg2; + +} + + +double _wrap_btContactSolverInfoDoubleData_m_singleAxisRollingFrictionThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_singleAxisRollingFrictionThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_numIterations_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numIterations = arg2; + +} + + +intgo _wrap_btContactSolverInfoDoubleData_m_numIterations_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_numIterations); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_solverMode_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_solverMode = arg2; + +} + + +intgo _wrap_btContactSolverInfoDoubleData_m_solverMode_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_solverMode); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_restingContactRestitutionThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_restingContactRestitutionThreshold = arg2; + +} + + +intgo _wrap_btContactSolverInfoDoubleData_m_restingContactRestitutionThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_restingContactRestitutionThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_minimumSolverBatchSize_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_minimumSolverBatchSize = arg2; + +} + + +intgo _wrap_btContactSolverInfoDoubleData_m_minimumSolverBatchSize_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_minimumSolverBatchSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_splitImpulse_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_splitImpulse = arg2; + +} + + +intgo _wrap_btContactSolverInfoDoubleData_m_splitImpulse_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (int) ((arg1)->m_splitImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoDoubleData_m_padding_set_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0, _gostring_ _swig_go_1) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_padding, (const char *)arg2, 4-1); + arg1->m_padding[4-1] = 0; + } else { + arg1->m_padding[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btContactSolverInfoDoubleData_m_padding_get_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_padding); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btContactSolverInfoDoubleData *_wrap_new_btContactSolverInfoDoubleData_mbt_e879218550ba2e2b() { + btContactSolverInfoDoubleData *result = 0 ; + btContactSolverInfoDoubleData *_swig_go_result; + + + result = (btContactSolverInfoDoubleData *)new btContactSolverInfoDoubleData(); + *(btContactSolverInfoDoubleData **)&_swig_go_result = (btContactSolverInfoDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btContactSolverInfoDoubleData_mbt_e879218550ba2e2b(btContactSolverInfoDoubleData *_swig_go_0) { + btContactSolverInfoDoubleData *arg1 = (btContactSolverInfoDoubleData *) 0 ; + + arg1 = *(btContactSolverInfoDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btContactSolverInfoFloatData_m_tau_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_tau = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_tau_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_tau); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_damping_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_damping = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_damping_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_damping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_friction_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_friction = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_friction_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_friction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_timeStep_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_timeStep = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_timeStep_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_timeStep); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_restitution_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_restitution = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_restitution_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_restitution); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_maxErrorReduction_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_maxErrorReduction = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_maxErrorReduction_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_maxErrorReduction); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_sor_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_sor = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_sor_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_sor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_erp_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_erp = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_erp_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_erp); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_erp2_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_erp2 = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_erp2_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_erp2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_globalCfm_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_globalCfm = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_globalCfm_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_globalCfm); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_splitImpulsePenetrationThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_splitImpulsePenetrationThreshold = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_splitImpulsePenetrationThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_splitImpulsePenetrationThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_splitImpulseTurnErp_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_splitImpulseTurnErp = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_splitImpulseTurnErp_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_splitImpulseTurnErp); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_linearSlop_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_linearSlop = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_linearSlop_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_linearSlop); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_warmstartingFactor_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_warmstartingFactor = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_warmstartingFactor_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_warmstartingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_articulatedWarmstartingFactor_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_articulatedWarmstartingFactor = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_articulatedWarmstartingFactor_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_articulatedWarmstartingFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_maxGyroscopicForce_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_maxGyroscopicForce = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_maxGyroscopicForce_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_maxGyroscopicForce); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_singleAxisRollingFrictionThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, float _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_singleAxisRollingFrictionThreshold = arg2; + +} + + +float _wrap_btContactSolverInfoFloatData_m_singleAxisRollingFrictionThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (float) ((arg1)->m_singleAxisRollingFrictionThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_numIterations_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numIterations = arg2; + +} + + +intgo _wrap_btContactSolverInfoFloatData_m_numIterations_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_numIterations); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_solverMode_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_solverMode = arg2; + +} + + +intgo _wrap_btContactSolverInfoFloatData_m_solverMode_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_solverMode); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_restingContactRestitutionThreshold_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_restingContactRestitutionThreshold = arg2; + +} + + +intgo _wrap_btContactSolverInfoFloatData_m_restingContactRestitutionThreshold_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_restingContactRestitutionThreshold); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_minimumSolverBatchSize_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_minimumSolverBatchSize = arg2; + +} + + +intgo _wrap_btContactSolverInfoFloatData_m_minimumSolverBatchSize_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_minimumSolverBatchSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btContactSolverInfoFloatData_m_splitImpulse_set_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0, intgo _swig_go_1) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + int arg2 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_splitImpulse = arg2; + +} + + +intgo _wrap_btContactSolverInfoFloatData_m_splitImpulse_get_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + result = (int) ((arg1)->m_splitImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +btContactSolverInfoFloatData *_wrap_new_btContactSolverInfoFloatData_mbt_e879218550ba2e2b() { + btContactSolverInfoFloatData *result = 0 ; + btContactSolverInfoFloatData *_swig_go_result; + + + result = (btContactSolverInfoFloatData *)new btContactSolverInfoFloatData(); + *(btContactSolverInfoFloatData **)&_swig_go_result = (btContactSolverInfoFloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btContactSolverInfoFloatData_mbt_e879218550ba2e2b(btContactSolverInfoFloatData *_swig_go_0) { + btContactSolverInfoFloatData *arg1 = (btContactSolverInfoFloatData *) 0 ; + + arg1 = *(btContactSolverInfoFloatData **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_BT_SIMPLE_DYNAMICS_WORLD_mbt_e879218550ba2e2b() { + btDynamicsWorldType result; + intgo _swig_go_result; + + + result = BT_SIMPLE_DYNAMICS_WORLD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_DISCRETE_DYNAMICS_WORLD_mbt_e879218550ba2e2b() { + btDynamicsWorldType result; + intgo _swig_go_result; + + + result = BT_DISCRETE_DYNAMICS_WORLD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONTINUOUS_DYNAMICS_WORLD_mbt_e879218550ba2e2b() { + btDynamicsWorldType result; + intgo _swig_go_result; + + + result = BT_CONTINUOUS_DYNAMICS_WORLD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_SOFT_RIGID_DYNAMICS_WORLD_mbt_e879218550ba2e2b() { + btDynamicsWorldType result; + intgo _swig_go_result; + + + result = BT_SOFT_RIGID_DYNAMICS_WORLD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_GPU_DYNAMICS_WORLD_mbt_e879218550ba2e2b() { + btDynamicsWorldType result; + intgo _swig_go_result; + + + result = BT_GPU_DYNAMICS_WORLD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_SOFT_MULTIBODY_DYNAMICS_WORLD_mbt_e879218550ba2e2b() { + btDynamicsWorldType result; + intgo _swig_go_result; + + + result = BT_SOFT_MULTIBODY_DYNAMICS_WORLD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_mbt_e879218550ba2e2b() { + btDynamicsWorldType result; + intgo _swig_go_result; + + + result = BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_delete_btDynamicsWorld_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_btDynamicsWorld_stepSimulation__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, float _swig_go_1, intgo _swig_go_2, float _swig_go_3) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btScalar arg2 ; + int arg3 ; + btScalar arg4 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + result = (int)(arg1)->stepSimulation(arg2,arg3,arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btDynamicsWorld_stepSimulation__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, float _swig_go_1, intgo _swig_go_2) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btScalar arg2 ; + int arg3 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (int)(arg1)->stepSimulation(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btDynamicsWorld_stepSimulation__SWIG_2_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, float _swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btScalar arg2 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (int)(arg1)->stepSimulation(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDynamicsWorld_debugDrawWorld_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + (arg1)->debugDrawWorld(); + +} + + +void _wrap_btDynamicsWorld_addConstraint__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btTypedConstraint *_swig_go_1, bool _swig_go_2) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btTypedConstraint *arg2 = (btTypedConstraint *) 0 ; + bool arg3 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btTypedConstraint **)&_swig_go_1; + arg3 = (bool)_swig_go_2; + + (arg1)->addConstraint(arg2,arg3); + +} + + +void _wrap_btDynamicsWorld_addConstraint__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btTypedConstraint *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btTypedConstraint *arg2 = (btTypedConstraint *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btTypedConstraint **)&_swig_go_1; + + (arg1)->addConstraint(arg2); + +} + + +void _wrap_btDynamicsWorld_removeConstraint_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btTypedConstraint *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btTypedConstraint *arg2 = (btTypedConstraint *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btTypedConstraint **)&_swig_go_1; + + (arg1)->removeConstraint(arg2); + +} + + +void _wrap_btDynamicsWorld_addAction_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->addAction(arg2); + +} + + +void _wrap_btDynamicsWorld_removeAction_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->removeAction(arg2); + +} + + +void _wrap_btDynamicsWorld_setGravity_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btVector3 *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setGravity((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btDynamicsWorld_getGravity_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + result = ((btDynamicsWorld const *)arg1)->getGravity(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btDynamicsWorld_synchronizeMotionStates_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + (arg1)->synchronizeMotionStates(); + +} + + +void _wrap_btDynamicsWorld_addRigidBody__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btRigidBody *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btRigidBody *arg2 = (btRigidBody *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + + (arg1)->addRigidBody(arg2); + +} + + +void _wrap_btDynamicsWorld_addRigidBody__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btRigidBody *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btRigidBody *arg2 = (btRigidBody *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->addRigidBody(arg2,arg3,arg4); + +} + + +void _wrap_btDynamicsWorld_removeRigidBody_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btRigidBody *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btRigidBody *arg2 = (btRigidBody *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + + (arg1)->removeRigidBody(arg2); + +} + + +void _wrap_btDynamicsWorld_setConstraintSolver_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btConstraintSolver *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btConstraintSolver *arg2 = (btConstraintSolver *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btConstraintSolver **)&_swig_go_1; + + (arg1)->setConstraintSolver(arg2); + +} + + +btConstraintSolver *_wrap_btDynamicsWorld_getConstraintSolver_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btConstraintSolver *result = 0 ; + btConstraintSolver *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + result = (btConstraintSolver *)(arg1)->getConstraintSolver(); + *(btConstraintSolver **)&_swig_go_result = (btConstraintSolver *)result; + return _swig_go_result; +} + + +intgo _wrap_btDynamicsWorld_getNumConstraints_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + result = (int)((btDynamicsWorld const *)arg1)->getNumConstraints(); + _swig_go_result = result; + return _swig_go_result; +} + + +btTypedConstraint *_wrap_btDynamicsWorld_getConstraint__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, intgo _swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + int arg2 ; + btTypedConstraint *result = 0 ; + btTypedConstraint *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btTypedConstraint *)(arg1)->getConstraint(arg2); + *(btTypedConstraint **)&_swig_go_result = (btTypedConstraint *)result; + return _swig_go_result; +} + + +btTypedConstraint *_wrap_btDynamicsWorld_getConstraint__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, intgo _swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + int arg2 ; + btTypedConstraint *result = 0 ; + btTypedConstraint *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btTypedConstraint *)((btDynamicsWorld const *)arg1)->getConstraint(arg2); + *(btTypedConstraint **)&_swig_go_result = (btTypedConstraint *)result; + return _swig_go_result; +} + + +intgo _wrap_btDynamicsWorld_getWorldType_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btDynamicsWorldType result; + intgo _swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + result = (btDynamicsWorldType)((btDynamicsWorld const *)arg1)->getWorldType(); + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btDynamicsWorld_clearForces_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + (arg1)->clearForces(); + +} + + +void _wrap_btDynamicsWorld_setInternalTickCallback__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, void* _swig_go_1, void *_swig_go_2, bool _swig_go_3) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btInternalTickCallback arg2 = (btInternalTickCallback) 0 ; + void *arg3 = (void *) 0 ; + bool arg4 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btInternalTickCallback *)&_swig_go_1; + arg3 = *(void **)&_swig_go_2; + arg4 = (bool)_swig_go_3; + + (arg1)->setInternalTickCallback(arg2,arg3,arg4); + +} + + +void _wrap_btDynamicsWorld_setInternalTickCallback__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, void* _swig_go_1, void *_swig_go_2) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btInternalTickCallback arg2 = (btInternalTickCallback) 0 ; + void *arg3 = (void *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btInternalTickCallback *)&_swig_go_1; + arg3 = *(void **)&_swig_go_2; + + (arg1)->setInternalTickCallback(arg2,arg3); + +} + + +void _wrap_btDynamicsWorld_setInternalTickCallback__SWIG_2_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, void* _swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btInternalTickCallback arg2 = (btInternalTickCallback) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btInternalTickCallback *)&_swig_go_1; + + (arg1)->setInternalTickCallback(arg2); + +} + + +void _wrap_btDynamicsWorld_setWorldUserInfo_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, void *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + (arg1)->setWorldUserInfo(arg2); + +} + + +void *_wrap_btDynamicsWorld_getWorldUserInfo_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + result = (void *)((btDynamicsWorld const *)arg1)->getWorldUserInfo(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +btContactSolverInfo *_wrap_btDynamicsWorld_getSolverInfo__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btContactSolverInfo *result = 0 ; + btContactSolverInfo *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + result = (btContactSolverInfo *) &(arg1)->getSolverInfo(); + *(btContactSolverInfo **)&_swig_go_result = result; + return _swig_go_result; +} + + +btContactSolverInfo *_wrap_btDynamicsWorld_getSolverInfo__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btContactSolverInfo *result = 0 ; + btContactSolverInfo *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + result = (btContactSolverInfo *) &((btDynamicsWorld const *)arg1)->getSolverInfo(); + *(btContactSolverInfo **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDynamicsWorld_addVehicle_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->addVehicle(arg2); + +} + + +void _wrap_btDynamicsWorld_removeVehicle_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->removeVehicle(arg2); + +} + + +void _wrap_btDynamicsWorld_addCharacter_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->addCharacter(arg2); + +} + + +void _wrap_btDynamicsWorld_removeCharacter_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->removeCharacter(arg2); + +} + + +void _wrap_btDynamicsWorld_setBroadphase_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btBroadphaseInterface *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btBroadphaseInterface *arg2 = (btBroadphaseInterface *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btBroadphaseInterface **)&_swig_go_1; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->setBroadphase(arg2); + +} + + +btBroadphaseInterface *_wrap_btDynamicsWorld_getBroadphase__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btBroadphaseInterface *result = 0 ; + btBroadphaseInterface *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (btBroadphaseInterface *)((btCollisionWorld const *)swig_b0)->getBroadphase(); + *(btBroadphaseInterface **)&_swig_go_result = (btBroadphaseInterface *)result; + return _swig_go_result; +} + + +btBroadphaseInterface *_wrap_btDynamicsWorld_getBroadphase__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btBroadphaseInterface *result = 0 ; + btBroadphaseInterface *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (btBroadphaseInterface *)(swig_b0)->getBroadphase(); + *(btBroadphaseInterface **)&_swig_go_result = (btBroadphaseInterface *)result; + return _swig_go_result; +} + + +btOverlappingPairCache *_wrap_btDynamicsWorld_getPairCache_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btOverlappingPairCache *result = 0 ; + btOverlappingPairCache *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (btOverlappingPairCache *)(swig_b0)->getPairCache(); + *(btOverlappingPairCache **)&_swig_go_result = (btOverlappingPairCache *)result; + return _swig_go_result; +} + + +btDispatcher *_wrap_btDynamicsWorld_getDispatcher__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btDispatcher *result = 0 ; + btDispatcher *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (btDispatcher *)(swig_b0)->getDispatcher(); + *(btDispatcher **)&_swig_go_result = (btDispatcher *)result; + return _swig_go_result; +} + + +btDispatcher *_wrap_btDynamicsWorld_getDispatcher__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btDispatcher *result = 0 ; + btDispatcher *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (btDispatcher *)((btCollisionWorld const *)swig_b0)->getDispatcher(); + *(btDispatcher **)&_swig_go_result = (btDispatcher *)result; + return _swig_go_result; +} + + +void _wrap_btDynamicsWorld_updateSingleAabb_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->updateSingleAabb(arg2); + +} + + +void _wrap_btDynamicsWorld_updateAabbs_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->updateAabbs(); + +} + + +void _wrap_btDynamicsWorld_computeOverlappingPairs_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->computeOverlappingPairs(); + +} + + +void _wrap_btDynamicsWorld_setDebugDrawer_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btIDebugDraw *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btIDebugDraw *arg2 = (btIDebugDraw *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btIDebugDraw **)&_swig_go_1; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->setDebugDrawer(arg2); + +} + + +btIDebugDraw *_wrap_btDynamicsWorld_getDebugDrawer_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btIDebugDraw *result = 0 ; + btIDebugDraw *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (btIDebugDraw *)(swig_b0)->getDebugDrawer(); + *(btIDebugDraw **)&_swig_go_result = (btIDebugDraw *)result; + return _swig_go_result; +} + + +void _wrap_btDynamicsWorld_debugDrawObject_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btTransform *_swig_go_1, btCollisionShape *_swig_go_2, btVector3 *_swig_go_3) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btTransform *arg2 = 0 ; + btCollisionShape *arg3 = (btCollisionShape *) 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btCollisionShape **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->debugDrawObject((btTransform const &)*arg2,(btCollisionShape const *)arg3,(btVector3 const &)*arg4); + +} + + +intgo _wrap_btDynamicsWorld_getNumCollisionObjects_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (int)((btCollisionWorld const *)swig_b0)->getNumCollisionObjects(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDynamicsWorld_rayTest_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btCollisionWorld::RayResultCallback *_swig_go_3) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btCollisionWorld::RayResultCallback *arg4 = 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btCollisionWorld::RayResultCallback **)&_swig_go_3; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + ((btCollisionWorld const *)swig_b0)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); + +} + + +void _wrap_btDynamicsWorld_convexSweepTest__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btConvexShape *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btCollisionWorld::ConvexResultCallback *_swig_go_4, float _swig_go_5) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btCollisionWorld::ConvexResultCallback *arg5 = 0 ; + btScalar arg6 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + ((btCollisionWorld const *)swig_b0)->convexSweepTest((btConvexShape const *)arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,*arg5,arg6); + +} + + +void _wrap_btDynamicsWorld_convexSweepTest__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btConvexShape *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btCollisionWorld::ConvexResultCallback *_swig_go_4) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btCollisionWorld::ConvexResultCallback *arg5 = 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_4; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + ((btCollisionWorld const *)swig_b0)->convexSweepTest((btConvexShape const *)arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,*arg5); + +} + + +void _wrap_btDynamicsWorld_contactTest_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionWorld::ContactResultCallback *_swig_go_2) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionWorld::ContactResultCallback *arg3 = 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionWorld::ContactResultCallback **)&_swig_go_2; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->contactTest(arg2,*arg3); + +} + + +void _wrap_btDynamicsWorld_contactPairTest_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btCollisionWorld::ContactResultCallback *_swig_go_3) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btCollisionWorld::ContactResultCallback *arg4 = 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btCollisionWorld::ContactResultCallback **)&_swig_go_3; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->contactPairTest(arg2,arg3,*arg4); + +} + + +void _wrap_btDynamicsWorld_rayTestSingle_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1, btCollisionObject *_swig_go_2, btCollisionShape *_swig_go_3, btTransform *_swig_go_4, btCollisionWorld::RayResultCallback *_swig_go_5) { + btTransform *arg1 = 0 ; + btTransform *arg2 = 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btCollisionShape *arg4 = (btCollisionShape *) 0 ; + btTransform *arg5 = 0 ; + btCollisionWorld::RayResultCallback *arg6 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btCollisionShape **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btCollisionWorld::RayResultCallback **)&_swig_go_5; + + btCollisionWorld::rayTestSingle((btTransform const &)*arg1,(btTransform const &)*arg2,arg3,(btCollisionShape const *)arg4,(btTransform const &)*arg5,*arg6); + +} + + +void _wrap_btDynamicsWorld_rayTestSingleInternal_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionWorld::RayResultCallback *_swig_go_3) { + btTransform *arg1 = 0 ; + btTransform *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionWorld::RayResultCallback *arg4 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionWorld::RayResultCallback **)&_swig_go_3; + + btCollisionWorld::rayTestSingleInternal((btTransform const &)*arg1,(btTransform const &)*arg2,(btCollisionObjectWrapper const *)arg3,*arg4); + +} + + +void _wrap_btDynamicsWorld_objectQuerySingle_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btCollisionObject *_swig_go_3, btCollisionShape *_swig_go_4, btTransform *_swig_go_5, btCollisionWorld::ConvexResultCallback *_swig_go_6, float _swig_go_7) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btCollisionObject *arg4 = (btCollisionObject *) 0 ; + btCollisionShape *arg5 = (btCollisionShape *) 0 ; + btTransform *arg6 = 0 ; + btCollisionWorld::ConvexResultCallback *arg7 = 0 ; + btScalar arg8 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btCollisionObject **)&_swig_go_3; + arg5 = *(btCollisionShape **)&_swig_go_4; + arg6 = *(btTransform **)&_swig_go_5; + arg7 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_6; + arg8 = (btScalar)_swig_go_7; + + btCollisionWorld::objectQuerySingle((btConvexShape const *)arg1,(btTransform const &)*arg2,(btTransform const &)*arg3,arg4,(btCollisionShape const *)arg5,(btTransform const &)*arg6,*arg7,arg8); + +} + + +void _wrap_btDynamicsWorld_objectQuerySingleInternal_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btCollisionObjectWrapper *_swig_go_3, btCollisionWorld::ConvexResultCallback *_swig_go_4, float _swig_go_5) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + btCollisionWorld::ConvexResultCallback *arg5 = 0 ; + btScalar arg6 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + arg5 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + btCollisionWorld::objectQuerySingleInternal((btConvexShape const *)arg1,(btTransform const &)*arg2,(btTransform const &)*arg3,(btCollisionObjectWrapper const *)arg4,*arg5,arg6); + +} + + +void _wrap_btDynamicsWorld_addCollisionObject__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->addCollisionObject(arg2,arg3,arg4); + +} + + +void _wrap_btDynamicsWorld_addCollisionObject__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1, intgo _swig_go_2) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + int arg3 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = (int)_swig_go_2; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->addCollisionObject(arg2,arg3); + +} + + +void _wrap_btDynamicsWorld_addCollisionObject__SWIG_2_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->addCollisionObject(arg2); + +} + + +void _wrap_btDynamicsWorld_refreshBroadphaseProxy_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->refreshBroadphaseProxy(arg2); + +} + + +btAlignedObjectArray< btCollisionObject * > *_wrap_btDynamicsWorld_getCollisionObjectArray__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btCollisionObjectArray *result = 0 ; + btAlignedObjectArray< btCollisionObject * > *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (btCollisionObjectArray *) &(swig_b0)->getCollisionObjectArray(); + *(btCollisionObjectArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btCollisionObject * > *_wrap_btDynamicsWorld_getCollisionObjectArray__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btCollisionObjectArray *result = 0 ; + btAlignedObjectArray< btCollisionObject * > *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (btCollisionObjectArray *) &((btCollisionWorld const *)swig_b0)->getCollisionObjectArray(); + *(btCollisionObjectArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDynamicsWorld_removeCollisionObject_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->removeCollisionObject(arg2); + +} + + +void _wrap_btDynamicsWorld_performDiscreteCollisionDetection_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->performDiscreteCollisionDetection(); + +} + + +btDispatcherInfo *_wrap_btDynamicsWorld_getDispatchInfo__SWIG_0_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btDispatcherInfo *result = 0 ; + btDispatcherInfo *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (btDispatcherInfo *) &(swig_b0)->getDispatchInfo(); + *(btDispatcherInfo **)&_swig_go_result = result; + return _swig_go_result; +} + + +btDispatcherInfo *_wrap_btDynamicsWorld_getDispatchInfo__SWIG_1_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btDispatcherInfo *result = 0 ; + btDispatcherInfo *_swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (btDispatcherInfo *) &((btCollisionWorld const *)swig_b0)->getDispatchInfo(); + *(btDispatcherInfo **)&_swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDynamicsWorld_getForceUpdateAllAabbs_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + result = (bool)((btCollisionWorld const *)swig_b0)->getForceUpdateAllAabbs(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDynamicsWorld_setForceUpdateAllAabbs_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, bool _swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + bool arg2 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->setForceUpdateAllAabbs(arg2); + +} + + +void _wrap_btDynamicsWorld_serialize_mbt_e879218550ba2e2b(btDynamicsWorld *_swig_go_0, btSerializer *_swig_go_1) { + btDynamicsWorld *arg1 = (btDynamicsWorld *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btDynamicsWorld **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btCollisionWorld *swig_b0 = (btCollisionWorld *)arg1; + (swig_b0)->serialize(arg2); + +} + + +void _wrap_btDynamicsWorldDoubleData_m_solverInfo_set_mbt_e879218550ba2e2b(btDynamicsWorldDoubleData *_swig_go_0, btContactSolverInfoDoubleData *_swig_go_1) { + btDynamicsWorldDoubleData *arg1 = (btDynamicsWorldDoubleData *) 0 ; + btContactSolverInfoDoubleData *arg2 = (btContactSolverInfoDoubleData *) 0 ; + + arg1 = *(btDynamicsWorldDoubleData **)&_swig_go_0; + arg2 = *(btContactSolverInfoDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_solverInfo = *arg2; + +} + + +btContactSolverInfoDoubleData *_wrap_btDynamicsWorldDoubleData_m_solverInfo_get_mbt_e879218550ba2e2b(btDynamicsWorldDoubleData *_swig_go_0) { + btDynamicsWorldDoubleData *arg1 = (btDynamicsWorldDoubleData *) 0 ; + btContactSolverInfoDoubleData *result = 0 ; + btContactSolverInfoDoubleData *_swig_go_result; + + arg1 = *(btDynamicsWorldDoubleData **)&_swig_go_0; + + result = (btContactSolverInfoDoubleData *)& ((arg1)->m_solverInfo); + *(btContactSolverInfoDoubleData **)&_swig_go_result = (btContactSolverInfoDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btDynamicsWorldDoubleData_m_gravity_set_mbt_e879218550ba2e2b(btDynamicsWorldDoubleData *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btDynamicsWorldDoubleData *arg1 = (btDynamicsWorldDoubleData *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btDynamicsWorldDoubleData **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_gravity = *arg2; + +} + + +btVector3DoubleData *_wrap_btDynamicsWorldDoubleData_m_gravity_get_mbt_e879218550ba2e2b(btDynamicsWorldDoubleData *_swig_go_0) { + btDynamicsWorldDoubleData *arg1 = (btDynamicsWorldDoubleData *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btDynamicsWorldDoubleData **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_gravity); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +btDynamicsWorldDoubleData *_wrap_new_btDynamicsWorldDoubleData_mbt_e879218550ba2e2b() { + btDynamicsWorldDoubleData *result = 0 ; + btDynamicsWorldDoubleData *_swig_go_result; + + + result = (btDynamicsWorldDoubleData *)new btDynamicsWorldDoubleData(); + *(btDynamicsWorldDoubleData **)&_swig_go_result = (btDynamicsWorldDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDynamicsWorldDoubleData_mbt_e879218550ba2e2b(btDynamicsWorldDoubleData *_swig_go_0) { + btDynamicsWorldDoubleData *arg1 = (btDynamicsWorldDoubleData *) 0 ; + + arg1 = *(btDynamicsWorldDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btDynamicsWorldFloatData_m_solverInfo_set_mbt_e879218550ba2e2b(btDynamicsWorldFloatData *_swig_go_0, btContactSolverInfoFloatData *_swig_go_1) { + btDynamicsWorldFloatData *arg1 = (btDynamicsWorldFloatData *) 0 ; + btContactSolverInfoFloatData *arg2 = (btContactSolverInfoFloatData *) 0 ; + + arg1 = *(btDynamicsWorldFloatData **)&_swig_go_0; + arg2 = *(btContactSolverInfoFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_solverInfo = *arg2; + +} + + +btContactSolverInfoFloatData *_wrap_btDynamicsWorldFloatData_m_solverInfo_get_mbt_e879218550ba2e2b(btDynamicsWorldFloatData *_swig_go_0) { + btDynamicsWorldFloatData *arg1 = (btDynamicsWorldFloatData *) 0 ; + btContactSolverInfoFloatData *result = 0 ; + btContactSolverInfoFloatData *_swig_go_result; + + arg1 = *(btDynamicsWorldFloatData **)&_swig_go_0; + + result = (btContactSolverInfoFloatData *)& ((arg1)->m_solverInfo); + *(btContactSolverInfoFloatData **)&_swig_go_result = (btContactSolverInfoFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btDynamicsWorldFloatData_m_gravity_set_mbt_e879218550ba2e2b(btDynamicsWorldFloatData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btDynamicsWorldFloatData *arg1 = (btDynamicsWorldFloatData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btDynamicsWorldFloatData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_gravity = *arg2; + +} + + +btVector3FloatData *_wrap_btDynamicsWorldFloatData_m_gravity_get_mbt_e879218550ba2e2b(btDynamicsWorldFloatData *_swig_go_0) { + btDynamicsWorldFloatData *arg1 = (btDynamicsWorldFloatData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btDynamicsWorldFloatData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_gravity); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +btDynamicsWorldFloatData *_wrap_new_btDynamicsWorldFloatData_mbt_e879218550ba2e2b() { + btDynamicsWorldFloatData *result = 0 ; + btDynamicsWorldFloatData *_swig_go_result; + + + result = (btDynamicsWorldFloatData *)new btDynamicsWorldFloatData(); + *(btDynamicsWorldFloatData **)&_swig_go_result = (btDynamicsWorldFloatData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDynamicsWorldFloatData_mbt_e879218550ba2e2b(btDynamicsWorldFloatData *_swig_go_0) { + btDynamicsWorldFloatData *arg1 = (btDynamicsWorldFloatData *) 0 ; + + arg1 = *(btDynamicsWorldFloatData **)&_swig_go_0; + + delete arg1; + +} + + +btDiscreteDynamicsWorld *_wrap_new_btDiscreteDynamicsWorld_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, btBroadphaseInterface *_swig_go_1, btConstraintSolver *_swig_go_2, btCollisionConfiguration *_swig_go_3) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btBroadphaseInterface *arg2 = (btBroadphaseInterface *) 0 ; + btConstraintSolver *arg3 = (btConstraintSolver *) 0 ; + btCollisionConfiguration *arg4 = (btCollisionConfiguration *) 0 ; + btDiscreteDynamicsWorld *result = 0 ; + btDiscreteDynamicsWorld *_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(btBroadphaseInterface **)&_swig_go_1; + arg3 = *(btConstraintSolver **)&_swig_go_2; + arg4 = *(btCollisionConfiguration **)&_swig_go_3; + + result = (btDiscreteDynamicsWorld *)new btDiscreteDynamicsWorld(arg1,arg2,arg3,arg4); + *(btDiscreteDynamicsWorld **)&_swig_go_result = (btDiscreteDynamicsWorld *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDiscreteDynamicsWorld_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_btDiscreteDynamicsWorld_stepSimulation__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, float _swig_go_1, intgo _swig_go_2, float _swig_go_3) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btScalar arg2 ; + int arg3 ; + btScalar arg4 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + result = (int)(arg1)->stepSimulation(arg2,arg3,arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btDiscreteDynamicsWorld_stepSimulation__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, float _swig_go_1, intgo _swig_go_2) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btScalar arg2 ; + int arg3 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (int)(arg1)->stepSimulation(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btDiscreteDynamicsWorld_stepSimulation__SWIG_2_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, float _swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btScalar arg2 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (int)(arg1)->stepSimulation(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_solveConstraints_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btContactSolverInfo *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btContactSolverInfo *arg2 = 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btContactSolverInfo **)&_swig_go_1; + + (arg1)->solveConstraints(*arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_synchronizeMotionStates_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + (arg1)->synchronizeMotionStates(); + +} + + +void _wrap_btDiscreteDynamicsWorld_synchronizeSingleMotionState_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btRigidBody *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btRigidBody *arg2 = (btRigidBody *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + + (arg1)->synchronizeSingleMotionState(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_addConstraint__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btTypedConstraint *_swig_go_1, bool _swig_go_2) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btTypedConstraint *arg2 = (btTypedConstraint *) 0 ; + bool arg3 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btTypedConstraint **)&_swig_go_1; + arg3 = (bool)_swig_go_2; + + (arg1)->addConstraint(arg2,arg3); + +} + + +void _wrap_btDiscreteDynamicsWorld_addConstraint__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btTypedConstraint *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btTypedConstraint *arg2 = (btTypedConstraint *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btTypedConstraint **)&_swig_go_1; + + (arg1)->addConstraint(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_removeConstraint_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btTypedConstraint *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btTypedConstraint *arg2 = (btTypedConstraint *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btTypedConstraint **)&_swig_go_1; + + (arg1)->removeConstraint(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_addAction_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->addAction(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_removeAction_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->removeAction(arg2); + +} + + +btSimulationIslandManager *_wrap_btDiscreteDynamicsWorld_getSimulationIslandManager__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btSimulationIslandManager *result = 0 ; + btSimulationIslandManager *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (btSimulationIslandManager *)(arg1)->getSimulationIslandManager(); + *(btSimulationIslandManager **)&_swig_go_result = (btSimulationIslandManager *)result; + return _swig_go_result; +} + + +btSimulationIslandManager *_wrap_btDiscreteDynamicsWorld_getSimulationIslandManager__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btSimulationIslandManager *result = 0 ; + btSimulationIslandManager *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (btSimulationIslandManager *)((btDiscreteDynamicsWorld const *)arg1)->getSimulationIslandManager(); + *(btSimulationIslandManager **)&_swig_go_result = (btSimulationIslandManager *)result; + return _swig_go_result; +} + + +btCollisionWorld *_wrap_btDiscreteDynamicsWorld_getCollisionWorld_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionWorld *result = 0 ; + btCollisionWorld *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (btCollisionWorld *)(arg1)->getCollisionWorld(); + *(btCollisionWorld **)&_swig_go_result = (btCollisionWorld *)result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_setGravity_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btVector3 *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setGravity((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btDiscreteDynamicsWorld_getGravity_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = ((btDiscreteDynamicsWorld const *)arg1)->getGravity(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_addCollisionObject__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->addCollisionObject(arg2,arg3,arg4); + +} + + +void _wrap_btDiscreteDynamicsWorld_addCollisionObject__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1, intgo _swig_go_2) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + int arg3 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->addCollisionObject(arg2,arg3); + +} + + +void _wrap_btDiscreteDynamicsWorld_addCollisionObject__SWIG_2_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + (arg1)->addCollisionObject(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_addRigidBody__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btRigidBody *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btRigidBody *arg2 = (btRigidBody *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + + (arg1)->addRigidBody(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_addRigidBody__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btRigidBody *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btRigidBody *arg2 = (btRigidBody *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->addRigidBody(arg2,arg3,arg4); + +} + + +void _wrap_btDiscreteDynamicsWorld_removeRigidBody_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btRigidBody *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btRigidBody *arg2 = (btRigidBody *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + + (arg1)->removeRigidBody(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_removeCollisionObject_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + (arg1)->removeCollisionObject(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_debugDrawConstraint_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btTypedConstraint *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btTypedConstraint *arg2 = (btTypedConstraint *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btTypedConstraint **)&_swig_go_1; + + (arg1)->debugDrawConstraint(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_debugDrawWorld_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + (arg1)->debugDrawWorld(); + +} + + +void _wrap_btDiscreteDynamicsWorld_setConstraintSolver_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btConstraintSolver *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btConstraintSolver *arg2 = (btConstraintSolver *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btConstraintSolver **)&_swig_go_1; + + (arg1)->setConstraintSolver(arg2); + +} + + +btConstraintSolver *_wrap_btDiscreteDynamicsWorld_getConstraintSolver_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btConstraintSolver *result = 0 ; + btConstraintSolver *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (btConstraintSolver *)(arg1)->getConstraintSolver(); + *(btConstraintSolver **)&_swig_go_result = (btConstraintSolver *)result; + return _swig_go_result; +} + + +intgo _wrap_btDiscreteDynamicsWorld_getNumConstraints_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (int)((btDiscreteDynamicsWorld const *)arg1)->getNumConstraints(); + _swig_go_result = result; + return _swig_go_result; +} + + +btTypedConstraint *_wrap_btDiscreteDynamicsWorld_getConstraint__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, intgo _swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + int arg2 ; + btTypedConstraint *result = 0 ; + btTypedConstraint *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btTypedConstraint *)(arg1)->getConstraint(arg2); + *(btTypedConstraint **)&_swig_go_result = (btTypedConstraint *)result; + return _swig_go_result; +} + + +btTypedConstraint *_wrap_btDiscreteDynamicsWorld_getConstraint__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, intgo _swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + int arg2 ; + btTypedConstraint *result = 0 ; + btTypedConstraint *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btTypedConstraint *)((btDiscreteDynamicsWorld const *)arg1)->getConstraint(arg2); + *(btTypedConstraint **)&_swig_go_result = (btTypedConstraint *)result; + return _swig_go_result; +} + + +intgo _wrap_btDiscreteDynamicsWorld_getWorldType_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btDynamicsWorldType result; + intgo _swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (btDynamicsWorldType)((btDiscreteDynamicsWorld const *)arg1)->getWorldType(); + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_clearForces_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + (arg1)->clearForces(); + +} + + +void _wrap_btDiscreteDynamicsWorld_applyGravity_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + (arg1)->applyGravity(); + +} + + +void _wrap_btDiscreteDynamicsWorld_setNumTasks_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, intgo _swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + int arg2 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setNumTasks(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_updateVehicles_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, float _swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btScalar arg2 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->updateVehicles(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_addVehicle_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->addVehicle(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_removeVehicle_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->removeVehicle(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_addCharacter_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->addCharacter(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_removeCharacter_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btActionInterface *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btActionInterface *arg2 = (btActionInterface *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btActionInterface **)&_swig_go_1; + + (arg1)->removeCharacter(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_setSynchronizeAllMotionStates_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, bool _swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + bool arg2 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setSynchronizeAllMotionStates(arg2); + +} + + +bool _wrap_btDiscreteDynamicsWorld_getSynchronizeAllMotionStates_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (bool)((btDiscreteDynamicsWorld const *)arg1)->getSynchronizeAllMotionStates(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_setApplySpeculativeContactRestitution_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, bool _swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + bool arg2 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setApplySpeculativeContactRestitution(arg2); + +} + + +bool _wrap_btDiscreteDynamicsWorld_getApplySpeculativeContactRestitution_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (bool)((btDiscreteDynamicsWorld const *)arg1)->getApplySpeculativeContactRestitution(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_serialize_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btSerializer *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + (arg1)->serialize(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_setLatencyMotionStateInterpolation_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, bool _swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + bool arg2 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setLatencyMotionStateInterpolation(arg2); + +} + + +bool _wrap_btDiscreteDynamicsWorld_getLatencyMotionStateInterpolation_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (bool)((btDiscreteDynamicsWorld const *)arg1)->getLatencyMotionStateInterpolation(); + _swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btRigidBody * > *_wrap_btDiscreteDynamicsWorld_getNonStaticRigidBodies__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btAlignedObjectArray< btRigidBody * > *result = 0 ; + btAlignedObjectArray< btRigidBody * > *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (btAlignedObjectArray< btRigidBody * > *) &(arg1)->getNonStaticRigidBodies(); + *(btAlignedObjectArray< btRigidBody * > **)&_swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btRigidBody * > *_wrap_btDiscreteDynamicsWorld_getNonStaticRigidBodies__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btAlignedObjectArray< btRigidBody * > *result = 0 ; + btAlignedObjectArray< btRigidBody * > *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + result = (btAlignedObjectArray< btRigidBody * > *) &((btDiscreteDynamicsWorld const *)arg1)->getNonStaticRigidBodies(); + *(btAlignedObjectArray< btRigidBody * > **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_setInternalTickCallback__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, void* _swig_go_1, void *_swig_go_2, bool _swig_go_3) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btInternalTickCallback arg2 = (btInternalTickCallback) 0 ; + void *arg3 = (void *) 0 ; + bool arg4 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btInternalTickCallback *)&_swig_go_1; + arg3 = *(void **)&_swig_go_2; + arg4 = (bool)_swig_go_3; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + (swig_b0)->setInternalTickCallback(arg2,arg3,arg4); + +} + + +void _wrap_btDiscreteDynamicsWorld_setInternalTickCallback__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, void* _swig_go_1, void *_swig_go_2) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btInternalTickCallback arg2 = (btInternalTickCallback) 0 ; + void *arg3 = (void *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btInternalTickCallback *)&_swig_go_1; + arg3 = *(void **)&_swig_go_2; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + (swig_b0)->setInternalTickCallback(arg2,arg3); + +} + + +void _wrap_btDiscreteDynamicsWorld_setInternalTickCallback__SWIG_2_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, void* _swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btInternalTickCallback arg2 = (btInternalTickCallback) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btInternalTickCallback *)&_swig_go_1; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + (swig_b0)->setInternalTickCallback(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_setWorldUserInfo_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, void *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + (swig_b0)->setWorldUserInfo(arg2); + +} + + +void *_wrap_btDiscreteDynamicsWorld_getWorldUserInfo_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + result = (void *)((btDynamicsWorld const *)swig_b0)->getWorldUserInfo(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +btContactSolverInfo *_wrap_btDiscreteDynamicsWorld_getSolverInfo__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btContactSolverInfo *result = 0 ; + btContactSolverInfo *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + result = (btContactSolverInfo *) &(swig_b0)->getSolverInfo(); + *(btContactSolverInfo **)&_swig_go_result = result; + return _swig_go_result; +} + + +btContactSolverInfo *_wrap_btDiscreteDynamicsWorld_getSolverInfo__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btContactSolverInfo *result = 0 ; + btContactSolverInfo *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + result = (btContactSolverInfo *) &((btDynamicsWorld const *)swig_b0)->getSolverInfo(); + *(btContactSolverInfo **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_setBroadphase_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btBroadphaseInterface *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btBroadphaseInterface *arg2 = (btBroadphaseInterface *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btBroadphaseInterface **)&_swig_go_1; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->setBroadphase(arg2); + +} + + +btBroadphaseInterface *_wrap_btDiscreteDynamicsWorld_getBroadphase__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btBroadphaseInterface *result = 0 ; + btBroadphaseInterface *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (btBroadphaseInterface *)((btCollisionWorld const *)swig_b1)->getBroadphase(); + *(btBroadphaseInterface **)&_swig_go_result = (btBroadphaseInterface *)result; + return _swig_go_result; +} + + +btBroadphaseInterface *_wrap_btDiscreteDynamicsWorld_getBroadphase__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btBroadphaseInterface *result = 0 ; + btBroadphaseInterface *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (btBroadphaseInterface *)(swig_b1)->getBroadphase(); + *(btBroadphaseInterface **)&_swig_go_result = (btBroadphaseInterface *)result; + return _swig_go_result; +} + + +btOverlappingPairCache *_wrap_btDiscreteDynamicsWorld_getPairCache_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btOverlappingPairCache *result = 0 ; + btOverlappingPairCache *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (btOverlappingPairCache *)(swig_b1)->getPairCache(); + *(btOverlappingPairCache **)&_swig_go_result = (btOverlappingPairCache *)result; + return _swig_go_result; +} + + +btDispatcher *_wrap_btDiscreteDynamicsWorld_getDispatcher__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btDispatcher *result = 0 ; + btDispatcher *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (btDispatcher *)(swig_b1)->getDispatcher(); + *(btDispatcher **)&_swig_go_result = (btDispatcher *)result; + return _swig_go_result; +} + + +btDispatcher *_wrap_btDiscreteDynamicsWorld_getDispatcher__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btDispatcher *result = 0 ; + btDispatcher *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (btDispatcher *)((btCollisionWorld const *)swig_b1)->getDispatcher(); + *(btDispatcher **)&_swig_go_result = (btDispatcher *)result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_updateSingleAabb_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->updateSingleAabb(arg2); + +} + + +void _wrap_btDiscreteDynamicsWorld_updateAabbs_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->updateAabbs(); + +} + + +void _wrap_btDiscreteDynamicsWorld_computeOverlappingPairs_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->computeOverlappingPairs(); + +} + + +void _wrap_btDiscreteDynamicsWorld_setDebugDrawer_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btIDebugDraw *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btIDebugDraw *arg2 = (btIDebugDraw *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btIDebugDraw **)&_swig_go_1; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->setDebugDrawer(arg2); + +} + + +btIDebugDraw *_wrap_btDiscreteDynamicsWorld_getDebugDrawer_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btIDebugDraw *result = 0 ; + btIDebugDraw *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (btIDebugDraw *)(swig_b1)->getDebugDrawer(); + *(btIDebugDraw **)&_swig_go_result = (btIDebugDraw *)result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_debugDrawObject_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btTransform *_swig_go_1, btCollisionShape *_swig_go_2, btVector3 *_swig_go_3) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btTransform *arg2 = 0 ; + btCollisionShape *arg3 = (btCollisionShape *) 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btCollisionShape **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->debugDrawObject((btTransform const &)*arg2,(btCollisionShape const *)arg3,(btVector3 const &)*arg4); + +} + + +intgo _wrap_btDiscreteDynamicsWorld_getNumCollisionObjects_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (int)((btCollisionWorld const *)swig_b1)->getNumCollisionObjects(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_rayTest_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btCollisionWorld::RayResultCallback *_swig_go_3) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btCollisionWorld::RayResultCallback *arg4 = 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btCollisionWorld::RayResultCallback **)&_swig_go_3; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + ((btCollisionWorld const *)swig_b1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); + +} + + +void _wrap_btDiscreteDynamicsWorld_convexSweepTest__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btConvexShape *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btCollisionWorld::ConvexResultCallback *_swig_go_4, float _swig_go_5) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btCollisionWorld::ConvexResultCallback *arg5 = 0 ; + btScalar arg6 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + ((btCollisionWorld const *)swig_b1)->convexSweepTest((btConvexShape const *)arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,*arg5,arg6); + +} + + +void _wrap_btDiscreteDynamicsWorld_convexSweepTest__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btConvexShape *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btCollisionWorld::ConvexResultCallback *_swig_go_4) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btCollisionWorld::ConvexResultCallback *arg5 = 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_4; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + ((btCollisionWorld const *)swig_b1)->convexSweepTest((btConvexShape const *)arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,*arg5); + +} + + +void _wrap_btDiscreteDynamicsWorld_contactTest_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionWorld::ContactResultCallback *_swig_go_2) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionWorld::ContactResultCallback *arg3 = 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionWorld::ContactResultCallback **)&_swig_go_2; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->contactTest(arg2,*arg3); + +} + + +void _wrap_btDiscreteDynamicsWorld_contactPairTest_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btCollisionWorld::ContactResultCallback *_swig_go_3) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btCollisionWorld::ContactResultCallback *arg4 = 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btCollisionWorld::ContactResultCallback **)&_swig_go_3; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->contactPairTest(arg2,arg3,*arg4); + +} + + +void _wrap_btDiscreteDynamicsWorld_rayTestSingle_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1, btCollisionObject *_swig_go_2, btCollisionShape *_swig_go_3, btTransform *_swig_go_4, btCollisionWorld::RayResultCallback *_swig_go_5) { + btTransform *arg1 = 0 ; + btTransform *arg2 = 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btCollisionShape *arg4 = (btCollisionShape *) 0 ; + btTransform *arg5 = 0 ; + btCollisionWorld::RayResultCallback *arg6 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btCollisionShape **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btCollisionWorld::RayResultCallback **)&_swig_go_5; + + btCollisionWorld::rayTestSingle((btTransform const &)*arg1,(btTransform const &)*arg2,arg3,(btCollisionShape const *)arg4,(btTransform const &)*arg5,*arg6); + +} + + +void _wrap_btDiscreteDynamicsWorld_rayTestSingleInternal_mbt_e879218550ba2e2b(btTransform *_swig_go_0, btTransform *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionWorld::RayResultCallback *_swig_go_3) { + btTransform *arg1 = 0 ; + btTransform *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionWorld::RayResultCallback *arg4 = 0 ; + + arg1 = *(btTransform **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionWorld::RayResultCallback **)&_swig_go_3; + + btCollisionWorld::rayTestSingleInternal((btTransform const &)*arg1,(btTransform const &)*arg2,(btCollisionObjectWrapper const *)arg3,*arg4); + +} + + +void _wrap_btDiscreteDynamicsWorld_objectQuerySingle_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btCollisionObject *_swig_go_3, btCollisionShape *_swig_go_4, btTransform *_swig_go_5, btCollisionWorld::ConvexResultCallback *_swig_go_6, float _swig_go_7) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btCollisionObject *arg4 = (btCollisionObject *) 0 ; + btCollisionShape *arg5 = (btCollisionShape *) 0 ; + btTransform *arg6 = 0 ; + btCollisionWorld::ConvexResultCallback *arg7 = 0 ; + btScalar arg8 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btCollisionObject **)&_swig_go_3; + arg5 = *(btCollisionShape **)&_swig_go_4; + arg6 = *(btTransform **)&_swig_go_5; + arg7 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_6; + arg8 = (btScalar)_swig_go_7; + + btCollisionWorld::objectQuerySingle((btConvexShape const *)arg1,(btTransform const &)*arg2,(btTransform const &)*arg3,arg4,(btCollisionShape const *)arg5,(btTransform const &)*arg6,*arg7,arg8); + +} + + +void _wrap_btDiscreteDynamicsWorld_objectQuerySingleInternal_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btCollisionObjectWrapper *_swig_go_3, btCollisionWorld::ConvexResultCallback *_swig_go_4, float _swig_go_5) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + btCollisionWorld::ConvexResultCallback *arg5 = 0 ; + btScalar arg6 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + arg5 = *(btCollisionWorld::ConvexResultCallback **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + btCollisionWorld::objectQuerySingleInternal((btConvexShape const *)arg1,(btTransform const &)*arg2,(btTransform const &)*arg3,(btCollisionObjectWrapper const *)arg4,*arg5,arg6); + +} + + +void _wrap_btDiscreteDynamicsWorld_refreshBroadphaseProxy_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, btCollisionObject *_swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->refreshBroadphaseProxy(arg2); + +} + + +btAlignedObjectArray< btCollisionObject * > *_wrap_btDiscreteDynamicsWorld_getCollisionObjectArray__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionObjectArray *result = 0 ; + btAlignedObjectArray< btCollisionObject * > *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (btCollisionObjectArray *) &(swig_b1)->getCollisionObjectArray(); + *(btCollisionObjectArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btCollisionObject * > *_wrap_btDiscreteDynamicsWorld_getCollisionObjectArray__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btCollisionObjectArray *result = 0 ; + btAlignedObjectArray< btCollisionObject * > *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (btCollisionObjectArray *) &((btCollisionWorld const *)swig_b1)->getCollisionObjectArray(); + *(btCollisionObjectArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_performDiscreteCollisionDetection_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->performDiscreteCollisionDetection(); + +} + + +btDispatcherInfo *_wrap_btDiscreteDynamicsWorld_getDispatchInfo__SWIG_0_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btDispatcherInfo *result = 0 ; + btDispatcherInfo *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (btDispatcherInfo *) &(swig_b1)->getDispatchInfo(); + *(btDispatcherInfo **)&_swig_go_result = result; + return _swig_go_result; +} + + +btDispatcherInfo *_wrap_btDiscreteDynamicsWorld_getDispatchInfo__SWIG_1_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + btDispatcherInfo *result = 0 ; + btDispatcherInfo *_swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (btDispatcherInfo *) &((btCollisionWorld const *)swig_b1)->getDispatchInfo(); + *(btDispatcherInfo **)&_swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btDiscreteDynamicsWorld_getForceUpdateAllAabbs_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + result = (bool)((btCollisionWorld const *)swig_b1)->getForceUpdateAllAabbs(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDiscreteDynamicsWorld_setForceUpdateAllAabbs_mbt_e879218550ba2e2b(btDiscreteDynamicsWorld *_swig_go_0, bool _swig_go_1) { + btDiscreteDynamicsWorld *arg1 = (btDiscreteDynamicsWorld *) 0 ; + bool arg2 ; + + arg1 = *(btDiscreteDynamicsWorld **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btDynamicsWorld *swig_b0 = (btDynamicsWorld *)arg1; + btCollisionWorld *swig_b1 = (btCollisionWorld *)swig_b0; + (swig_b1)->setForceUpdateAllAabbs(arg2); + +} + + +void _wrap_btElement_m_id_set_mbt_e879218550ba2e2b(btElement *_swig_go_0, intgo _swig_go_1) { + btElement *arg1 = (btElement *) 0 ; + int arg2 ; + + arg1 = *(btElement **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_id = arg2; + +} + + +intgo _wrap_btElement_m_id_get_mbt_e879218550ba2e2b(btElement *_swig_go_0) { + btElement *arg1 = (btElement *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btElement **)&_swig_go_0; + + result = (int) ((arg1)->m_id); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btElement_m_sz_set_mbt_e879218550ba2e2b(btElement *_swig_go_0, intgo _swig_go_1) { + btElement *arg1 = (btElement *) 0 ; + int arg2 ; + + arg1 = *(btElement **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_sz = arg2; + +} + + +intgo _wrap_btElement_m_sz_get_mbt_e879218550ba2e2b(btElement *_swig_go_0) { + btElement *arg1 = (btElement *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btElement **)&_swig_go_0; + + result = (int) ((arg1)->m_sz); + _swig_go_result = result; + return _swig_go_result; +} + + +btElement *_wrap_new_btElement_mbt_e879218550ba2e2b() { + btElement *result = 0 ; + btElement *_swig_go_result; + + + result = (btElement *)new btElement(); + *(btElement **)&_swig_go_result = (btElement *)result; + return _swig_go_result; +} + + +void _wrap_delete_btElement_mbt_e879218550ba2e2b(btElement *_swig_go_0) { + btElement *arg1 = (btElement *) 0 ; + + arg1 = *(btElement **)&_swig_go_0; + + delete arg1; + +} + + +btUnionFind *_wrap_new_btUnionFind_mbt_e879218550ba2e2b() { + btUnionFind *result = 0 ; + btUnionFind *_swig_go_result; + + + result = (btUnionFind *)new btUnionFind(); + *(btUnionFind **)&_swig_go_result = (btUnionFind *)result; + return _swig_go_result; +} + + +void _wrap_delete_btUnionFind_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + + arg1 = *(btUnionFind **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btUnionFind_sortIslands_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + + arg1 = *(btUnionFind **)&_swig_go_0; + + (arg1)->sortIslands(); + +} + + +void _wrap_btUnionFind_reset_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0, intgo _swig_go_1) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + int arg2 ; + + arg1 = *(btUnionFind **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->reset(arg2); + +} + + +intgo _wrap_btUnionFind_getNumElements_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btUnionFind **)&_swig_go_0; + + result = (int)((btUnionFind const *)arg1)->getNumElements(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btUnionFind_isRoot_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0, intgo _swig_go_1) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btUnionFind **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (bool)((btUnionFind const *)arg1)->isRoot(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btElement *_wrap_btUnionFind_getElement__SWIG_0_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0, intgo _swig_go_1) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + int arg2 ; + btElement *result = 0 ; + btElement *_swig_go_result; + + arg1 = *(btUnionFind **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btElement *) &(arg1)->getElement(arg2); + *(btElement **)&_swig_go_result = result; + return _swig_go_result; +} + + +btElement *_wrap_btUnionFind_getElement__SWIG_1_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0, intgo _swig_go_1) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + int arg2 ; + btElement *result = 0 ; + btElement *_swig_go_result; + + arg1 = *(btUnionFind **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btElement *) &((btUnionFind const *)arg1)->getElement(arg2); + *(btElement **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btUnionFind_allocate_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0, intgo _swig_go_1) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + int arg2 ; + + arg1 = *(btUnionFind **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->allocate(arg2); + +} + + +void _wrap_btUnionFind_Free_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + + arg1 = *(btUnionFind **)&_swig_go_0; + + (arg1)->Free(); + +} + + +intgo _wrap_btUnionFind_find__SWIG_0_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + int arg2 ; + int arg3 ; + int result; + intgo _swig_go_result; + + arg1 = *(btUnionFind **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (int)(arg1)->find(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btUnionFind_unite_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btUnionFind **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->unite(arg2,arg3); + +} + + +intgo _wrap_btUnionFind_find__SWIG_1_mbt_e879218550ba2e2b(btUnionFind *_swig_go_0, intgo _swig_go_1) { + btUnionFind *arg1 = (btUnionFind *) 0 ; + int arg2 ; + int result; + intgo _swig_go_result; + + arg1 = *(btUnionFind **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (int)(arg1)->find(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btSimulationIslandManager *_wrap_new_btSimulationIslandManager_mbt_e879218550ba2e2b() { + btSimulationIslandManager *result = 0 ; + btSimulationIslandManager *_swig_go_result; + + + result = (btSimulationIslandManager *)new btSimulationIslandManager(); + *(btSimulationIslandManager **)&_swig_go_result = (btSimulationIslandManager *)result; + return _swig_go_result; +} + + +void _wrap_delete_btSimulationIslandManager_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btSimulationIslandManager_initUnionFind_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0, intgo _swig_go_1) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + int arg2 ; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->initUnionFind(arg2); + +} + + +btUnionFind *_wrap_btSimulationIslandManager_getUnionFind_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + btUnionFind *result = 0 ; + btUnionFind *_swig_go_result; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + + result = (btUnionFind *) &(arg1)->getUnionFind(); + *(btUnionFind **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSimulationIslandManager_updateActivationState_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0, btCollisionWorld *_swig_go_1, btDispatcher *_swig_go_2) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + btCollisionWorld *arg2 = (btCollisionWorld *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + arg2 = *(btCollisionWorld **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + (arg1)->updateActivationState(arg2,arg3); + +} + + +void _wrap_btSimulationIslandManager_storeIslandActivationState_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0, btCollisionWorld *_swig_go_1) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + btCollisionWorld *arg2 = (btCollisionWorld *) 0 ; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + arg2 = *(btCollisionWorld **)&_swig_go_1; + + (arg1)->storeIslandActivationState(arg2); + +} + + +void _wrap_btSimulationIslandManager_findUnions_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0, btDispatcher *_swig_go_1, btCollisionWorld *_swig_go_2) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + btCollisionWorld *arg3 = (btCollisionWorld *) 0 ; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + arg3 = *(btCollisionWorld **)&_swig_go_2; + + (arg1)->findUnions(arg2,arg3); + +} + + +void _wrap_btSimulationIslandManager_buildAndProcessIslands_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0, btDispatcher *_swig_go_1, btCollisionWorld *_swig_go_2, btSimulationIslandManager::IslandCallback *_swig_go_3) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + btCollisionWorld *arg3 = (btCollisionWorld *) 0 ; + btSimulationIslandManager::IslandCallback *arg4 = (btSimulationIslandManager::IslandCallback *) 0 ; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + arg3 = *(btCollisionWorld **)&_swig_go_2; + arg4 = *(btSimulationIslandManager::IslandCallback **)&_swig_go_3; + + (arg1)->buildAndProcessIslands(arg2,arg3,arg4); + +} + + +void _wrap_btSimulationIslandManager_buildIslands_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0, btDispatcher *_swig_go_1, btCollisionWorld *_swig_go_2) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + btCollisionWorld *arg3 = (btCollisionWorld *) 0 ; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + arg3 = *(btCollisionWorld **)&_swig_go_2; + + (arg1)->buildIslands(arg2,arg3); + +} + + +void _wrap_btSimulationIslandManager_processIslands_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0, btDispatcher *_swig_go_1, btCollisionWorld *_swig_go_2, btSimulationIslandManager::IslandCallback *_swig_go_3) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + btCollisionWorld *arg3 = (btCollisionWorld *) 0 ; + btSimulationIslandManager::IslandCallback *arg4 = (btSimulationIslandManager::IslandCallback *) 0 ; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + arg3 = *(btCollisionWorld **)&_swig_go_2; + arg4 = *(btSimulationIslandManager::IslandCallback **)&_swig_go_3; + + (arg1)->processIslands(arg2,arg3,arg4); + +} + + +bool _wrap_btSimulationIslandManager_getSplitIslands_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + + result = (bool)(arg1)->getSplitIslands(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSimulationIslandManager_setSplitIslands_mbt_e879218550ba2e2b(btSimulationIslandManager *_swig_go_0, bool _swig_go_1) { + btSimulationIslandManager *arg1 = (btSimulationIslandManager *) 0 ; + bool arg2 ; + + arg1 = *(btSimulationIslandManager **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setSplitIslands(arg2); + +} + + +intgo _wrap_BT_SEQUENTIAL_IMPULSE_SOLVER_mbt_e879218550ba2e2b() { + btConstraintSolverType result; + intgo _swig_go_result; + + + result = BT_SEQUENTIAL_IMPULSE_SOLVER; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_MLCP_SOLVER_mbt_e879218550ba2e2b() { + btConstraintSolverType result; + intgo _swig_go_result; + + + result = BT_MLCP_SOLVER; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_NNCG_SOLVER_mbt_e879218550ba2e2b() { + btConstraintSolverType result; + intgo _swig_go_result; + + + result = BT_NNCG_SOLVER; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_MULTIBODY_SOLVER_mbt_e879218550ba2e2b() { + btConstraintSolverType result; + intgo _swig_go_result; + + + result = BT_MULTIBODY_SOLVER; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_BLOCK_SOLVER_mbt_e879218550ba2e2b() { + btConstraintSolverType result; + intgo _swig_go_result; + + + result = BT_BLOCK_SOLVER; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_delete_btConstraintSolver_mbt_e879218550ba2e2b(btConstraintSolver *_swig_go_0) { + btConstraintSolver *arg1 = (btConstraintSolver *) 0 ; + + arg1 = *(btConstraintSolver **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConstraintSolver_prepareSolve_mbt_e879218550ba2e2b(btConstraintSolver *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btConstraintSolver *arg1 = (btConstraintSolver *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btConstraintSolver **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->prepareSolve(arg2,arg3); + +} + + +float _wrap_btConstraintSolver_solveGroup_mbt_e879218550ba2e2b(btConstraintSolver *_swig_go_0, btCollisionObject **_swig_go_1, intgo _swig_go_2, btPersistentManifold **_swig_go_3, intgo _swig_go_4, btTypedConstraint **_swig_go_5, intgo _swig_go_6, btContactSolverInfo *_swig_go_7, btIDebugDraw *_swig_go_8, btDispatcher *_swig_go_9) { + btConstraintSolver *arg1 = (btConstraintSolver *) 0 ; + btCollisionObject **arg2 = (btCollisionObject **) 0 ; + int arg3 ; + btPersistentManifold **arg4 = (btPersistentManifold **) 0 ; + int arg5 ; + btTypedConstraint **arg6 = (btTypedConstraint **) 0 ; + int arg7 ; + btContactSolverInfo *arg8 = 0 ; + btIDebugDraw *arg9 = (btIDebugDraw *) 0 ; + btDispatcher *arg10 = (btDispatcher *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConstraintSolver **)&_swig_go_0; + arg2 = *(btCollisionObject ***)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = *(btPersistentManifold ***)&_swig_go_3; + arg5 = (int)_swig_go_4; + arg6 = *(btTypedConstraint ***)&_swig_go_5; + arg7 = (int)_swig_go_6; + arg8 = *(btContactSolverInfo **)&_swig_go_7; + arg9 = *(btIDebugDraw **)&_swig_go_8; + arg10 = *(btDispatcher **)&_swig_go_9; + + result = (btScalar)(arg1)->solveGroup(arg2,arg3,arg4,arg5,arg6,arg7,(btContactSolverInfo const &)*arg8,arg9,arg10); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConstraintSolver_allSolved_mbt_e879218550ba2e2b(btConstraintSolver *_swig_go_0, btContactSolverInfo *_swig_go_1, btIDebugDraw *_swig_go_2) { + btConstraintSolver *arg1 = (btConstraintSolver *) 0 ; + btContactSolverInfo *arg2 = 0 ; + btIDebugDraw *arg3 = (btIDebugDraw *) 0 ; + + arg1 = *(btConstraintSolver **)&_swig_go_0; + arg2 = *(btContactSolverInfo **)&_swig_go_1; + arg3 = *(btIDebugDraw **)&_swig_go_2; + + (arg1)->allSolved((btContactSolverInfo const &)*arg2,arg3); + +} + + +void _wrap_btConstraintSolver_reset_mbt_e879218550ba2e2b(btConstraintSolver *_swig_go_0) { + btConstraintSolver *arg1 = (btConstraintSolver *) 0 ; + + arg1 = *(btConstraintSolver **)&_swig_go_0; + + (arg1)->reset(); + +} + + +intgo _wrap_btConstraintSolver_getSolverType_mbt_e879218550ba2e2b(btConstraintSolver *_swig_go_0) { + btConstraintSolver *arg1 = (btConstraintSolver *) 0 ; + btConstraintSolverType result; + intgo _swig_go_result; + + arg1 = *(btConstraintSolver **)&_swig_go_0; + + result = (btConstraintSolverType)((btConstraintSolver const *)arg1)->getSolverType(); + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +btSolverAnalyticsData *_wrap_new_btSolverAnalyticsData_mbt_e879218550ba2e2b() { + btSolverAnalyticsData *result = 0 ; + btSolverAnalyticsData *_swig_go_result; + + + result = (btSolverAnalyticsData *)new btSolverAnalyticsData(); + *(btSolverAnalyticsData **)&_swig_go_result = (btSolverAnalyticsData *)result; + return _swig_go_result; +} + + +void _wrap_btSolverAnalyticsData_m_islandId_set_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0, intgo _swig_go_1) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + int arg2 ; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_islandId = arg2; + +} + + +intgo _wrap_btSolverAnalyticsData_m_islandId_get_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + + result = (int) ((arg1)->m_islandId); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverAnalyticsData_m_numBodies_set_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0, intgo _swig_go_1) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + int arg2 ; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numBodies = arg2; + +} + + +intgo _wrap_btSolverAnalyticsData_m_numBodies_get_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + + result = (int) ((arg1)->m_numBodies); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverAnalyticsData_m_numContactManifolds_set_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0, intgo _swig_go_1) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + int arg2 ; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numContactManifolds = arg2; + +} + + +intgo _wrap_btSolverAnalyticsData_m_numContactManifolds_get_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + + result = (int) ((arg1)->m_numContactManifolds); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverAnalyticsData_m_numSolverCalls_set_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0, intgo _swig_go_1) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + int arg2 ; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numSolverCalls = arg2; + +} + + +intgo _wrap_btSolverAnalyticsData_m_numSolverCalls_get_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + + result = (int) ((arg1)->m_numSolverCalls); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverAnalyticsData_m_numIterationsUsed_set_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0, intgo _swig_go_1) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + int arg2 ; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numIterationsUsed = arg2; + +} + + +intgo _wrap_btSolverAnalyticsData_m_numIterationsUsed_get_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + + result = (int) ((arg1)->m_numIterationsUsed); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSolverAnalyticsData_m_remainingLeastSquaresResidual_set_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0, double _swig_go_1) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + double arg2 ; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_remainingLeastSquaresResidual = arg2; + +} + + +double _wrap_btSolverAnalyticsData_m_remainingLeastSquaresResidual_get_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + + result = (double) ((arg1)->m_remainingLeastSquaresResidual); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btSolverAnalyticsData_mbt_e879218550ba2e2b(btSolverAnalyticsData *_swig_go_0) { + btSolverAnalyticsData *arg1 = (btSolverAnalyticsData *) 0 ; + + arg1 = *(btSolverAnalyticsData **)&_swig_go_0; + + delete arg1; + +} + + +btSequentialImpulseConstraintSolver *_wrap_new_btSequentialImpulseConstraintSolver_mbt_e879218550ba2e2b() { + btSequentialImpulseConstraintSolver *result = 0 ; + btSequentialImpulseConstraintSolver *_swig_go_result; + + + result = (btSequentialImpulseConstraintSolver *)new btSequentialImpulseConstraintSolver(); + *(btSequentialImpulseConstraintSolver **)&_swig_go_result = (btSequentialImpulseConstraintSolver *)result; + return _swig_go_result; +} + + +void _wrap_delete_btSequentialImpulseConstraintSolver_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + + delete arg1; + +} + + +float _wrap_btSequentialImpulseConstraintSolver_solveGroup_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0, btCollisionObject **_swig_go_1, intgo _swig_go_2, btPersistentManifold **_swig_go_3, intgo _swig_go_4, btTypedConstraint **_swig_go_5, intgo _swig_go_6, btContactSolverInfo *_swig_go_7, btIDebugDraw *_swig_go_8, btDispatcher *_swig_go_9) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btCollisionObject **arg2 = (btCollisionObject **) 0 ; + int arg3 ; + btPersistentManifold **arg4 = (btPersistentManifold **) 0 ; + int arg5 ; + btTypedConstraint **arg6 = (btTypedConstraint **) 0 ; + int arg7 ; + btContactSolverInfo *arg8 = 0 ; + btIDebugDraw *arg9 = (btIDebugDraw *) 0 ; + btDispatcher *arg10 = (btDispatcher *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + arg2 = *(btCollisionObject ***)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = *(btPersistentManifold ***)&_swig_go_3; + arg5 = (int)_swig_go_4; + arg6 = *(btTypedConstraint ***)&_swig_go_5; + arg7 = (int)_swig_go_6; + arg8 = *(btContactSolverInfo **)&_swig_go_7; + arg9 = *(btIDebugDraw **)&_swig_go_8; + arg10 = *(btDispatcher **)&_swig_go_9; + + result = (btScalar)(arg1)->solveGroup(arg2,arg3,arg4,arg5,arg6,arg7,(btContactSolverInfo const &)*arg8,arg9,arg10); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSequentialImpulseConstraintSolver_reset_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + + (arg1)->reset(); + +} + + +long long _wrap_btSequentialImpulseConstraintSolver_btRand2_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + unsigned long result; + long long _swig_go_result; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + + result = (unsigned long)(arg1)->btRand2(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSequentialImpulseConstraintSolver_btRandInt2_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0, intgo _swig_go_1) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + int arg2 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (int)(arg1)->btRandInt2(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSequentialImpulseConstraintSolver_setRandSeed_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0, long long _swig_go_1) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + unsigned long arg2 ; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + arg2 = (unsigned long)_swig_go_1; + + (arg1)->setRandSeed(arg2); + +} + + +long long _wrap_btSequentialImpulseConstraintSolver_getRandSeed_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + unsigned long result; + long long _swig_go_result; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + + result = (unsigned long)((btSequentialImpulseConstraintSolver const *)arg1)->getRandSeed(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSequentialImpulseConstraintSolver_getSolverType_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btConstraintSolverType result; + intgo _swig_go_result; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + + result = (btConstraintSolverType)((btSequentialImpulseConstraintSolver const *)arg1)->getSolverType(); + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void* _wrap_btSequentialImpulseConstraintSolver_getActiveConstraintRowSolverGeneric_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btSingleConstraintRowSolver result; + void* _swig_go_result; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + + result = (btSingleConstraintRowSolver)(arg1)->getActiveConstraintRowSolverGeneric(); + *(btSingleConstraintRowSolver *)&_swig_go_result = (btSingleConstraintRowSolver)result; + return _swig_go_result; +} + + +void _wrap_btSequentialImpulseConstraintSolver_setConstraintRowSolverGeneric_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0, void* _swig_go_1) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btSingleConstraintRowSolver arg2 = (btSingleConstraintRowSolver) 0 ; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + arg2 = *(btSingleConstraintRowSolver *)&_swig_go_1; + + (arg1)->setConstraintRowSolverGeneric(arg2); + +} + + +void* _wrap_btSequentialImpulseConstraintSolver_getActiveConstraintRowSolverLowerLimit_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btSingleConstraintRowSolver result; + void* _swig_go_result; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + + result = (btSingleConstraintRowSolver)(arg1)->getActiveConstraintRowSolverLowerLimit(); + *(btSingleConstraintRowSolver *)&_swig_go_result = (btSingleConstraintRowSolver)result; + return _swig_go_result; +} + + +void _wrap_btSequentialImpulseConstraintSolver_setConstraintRowSolverLowerLimit_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0, void* _swig_go_1) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btSingleConstraintRowSolver arg2 = (btSingleConstraintRowSolver) 0 ; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + arg2 = *(btSingleConstraintRowSolver *)&_swig_go_1; + + (arg1)->setConstraintRowSolverLowerLimit(arg2); + +} + + +void* _wrap_btSequentialImpulseConstraintSolver_getScalarConstraintRowSolverGeneric_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btSingleConstraintRowSolver result; + void* _swig_go_result; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + + result = (btSingleConstraintRowSolver)(arg1)->getScalarConstraintRowSolverGeneric(); + *(btSingleConstraintRowSolver *)&_swig_go_result = (btSingleConstraintRowSolver)result; + return _swig_go_result; +} + + +void* _wrap_btSequentialImpulseConstraintSolver_getScalarConstraintRowSolverLowerLimit_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btSingleConstraintRowSolver result; + void* _swig_go_result; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + + result = (btSingleConstraintRowSolver)(arg1)->getScalarConstraintRowSolverLowerLimit(); + *(btSingleConstraintRowSolver *)&_swig_go_result = (btSingleConstraintRowSolver)result; + return _swig_go_result; +} + + +void _wrap_btSequentialImpulseConstraintSolver_m_analyticsData_set_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0, btSolverAnalyticsData *_swig_go_1) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btSolverAnalyticsData *arg2 = (btSolverAnalyticsData *) 0 ; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + arg2 = *(btSolverAnalyticsData **)&_swig_go_1; + + if (arg1) (arg1)->m_analyticsData = *arg2; + +} + + +btSolverAnalyticsData *_wrap_btSequentialImpulseConstraintSolver_m_analyticsData_get_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btSolverAnalyticsData *result = 0 ; + btSolverAnalyticsData *_swig_go_result; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + + result = (btSolverAnalyticsData *)& ((arg1)->m_analyticsData); + *(btSolverAnalyticsData **)&_swig_go_result = (btSolverAnalyticsData *)result; + return _swig_go_result; +} + + +void _wrap_btSequentialImpulseConstraintSolver_prepareSolve_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + btConstraintSolver *swig_b0 = (btConstraintSolver *)arg1; + (swig_b0)->prepareSolve(arg2,arg3); + +} + + +void _wrap_btSequentialImpulseConstraintSolver_allSolved_mbt_e879218550ba2e2b(btSequentialImpulseConstraintSolver *_swig_go_0, btContactSolverInfo *_swig_go_1, btIDebugDraw *_swig_go_2) { + btSequentialImpulseConstraintSolver *arg1 = (btSequentialImpulseConstraintSolver *) 0 ; + btContactSolverInfo *arg2 = 0 ; + btIDebugDraw *arg3 = (btIDebugDraw *) 0 ; + + arg1 = *(btSequentialImpulseConstraintSolver **)&_swig_go_0; + arg2 = *(btContactSolverInfo **)&_swig_go_1; + arg3 = *(btIDebugDraw **)&_swig_go_2; + + btConstraintSolver *swig_b0 = (btConstraintSolver *)arg1; + (swig_b0)->allSolved((btContactSolverInfo const &)*arg2,arg3); + +} + + +intgo _wrap_BT_CONETWIST_FLAGS_LIN_CFM_mbt_e879218550ba2e2b() { + btConeTwistFlags result; + intgo _swig_go_result; + + + result = BT_CONETWIST_FLAGS_LIN_CFM; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONETWIST_FLAGS_LIN_ERP_mbt_e879218550ba2e2b() { + btConeTwistFlags result; + intgo _swig_go_result; + + + result = BT_CONETWIST_FLAGS_LIN_ERP; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_CONETWIST_FLAGS_ANG_CFM_mbt_e879218550ba2e2b() { + btConeTwistFlags result; + intgo _swig_go_result; + + + result = BT_CONETWIST_FLAGS_ANG_CFM; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +btConeTwistConstraint *_wrap_new_btConeTwistConstraint__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btRigidBody *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3) { + btRigidBody *arg1 = 0 ; + btRigidBody *arg2 = 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btConeTwistConstraint *result = 0 ; + btConeTwistConstraint *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + + result = (btConeTwistConstraint *)new btConeTwistConstraint(*arg1,*arg2,(btTransform const &)*arg3,(btTransform const &)*arg4); + *(btConeTwistConstraint **)&_swig_go_result = (btConeTwistConstraint *)result; + return _swig_go_result; +} + + +btConeTwistConstraint *_wrap_new_btConeTwistConstraint__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btTransform *_swig_go_1) { + btRigidBody *arg1 = 0 ; + btTransform *arg2 = 0 ; + btConeTwistConstraint *result = 0 ; + btConeTwistConstraint *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + result = (btConeTwistConstraint *)new btConeTwistConstraint(*arg1,(btTransform const &)*arg2); + *(btConeTwistConstraint **)&_swig_go_result = (btConeTwistConstraint *)result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_buildJacobian_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + (arg1)->buildJacobian(); + +} + + +void _wrap_btConeTwistConstraint_getInfo1_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo1 *_swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTypedConstraint::btConstraintInfo1 *arg2 = (btTypedConstraint::btConstraintInfo1 *) 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo1 **)&_swig_go_1; + + (arg1)->getInfo1(arg2); + +} + + +void _wrap_btConeTwistConstraint_getInfo1NonVirtual_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo1 *_swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTypedConstraint::btConstraintInfo1 *arg2 = (btTypedConstraint::btConstraintInfo1 *) 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo1 **)&_swig_go_1; + + (arg1)->getInfo1NonVirtual(arg2); + +} + + +void _wrap_btConeTwistConstraint_getInfo2_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo2 *_swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTypedConstraint::btConstraintInfo2 *arg2 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_1; + + (arg1)->getInfo2(arg2); + +} + + +void _wrap_btConeTwistConstraint_getInfo2NonVirtual_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo2 *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btMatrix3x3 *_swig_go_4, btMatrix3x3 *_swig_go_5) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTypedConstraint::btConstraintInfo2 *arg2 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btMatrix3x3 *arg5 = 0 ; + btMatrix3x3 *arg6 = 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btMatrix3x3 **)&_swig_go_4; + arg6 = *(btMatrix3x3 **)&_swig_go_5; + + (arg1)->getInfo2NonVirtual(arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btMatrix3x3 const &)*arg5,(btMatrix3x3 const &)*arg6); + +} + + +void _wrap_btConeTwistConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btSolverBody *_swig_go_1, btSolverBody *_swig_go_2, float _swig_go_3) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btSolverBody *arg2 = 0 ; + btSolverBody *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btSolverBody **)&_swig_go_1; + arg3 = *(btSolverBody **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->solveConstraintObsolete(*arg2,*arg3,arg4); + +} + + +void _wrap_btConeTwistConstraint_updateRHS_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->updateRHS(arg2); + +} + + +btRigidBody *_wrap_btConeTwistConstraint_getRigidBodyA_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btRigidBody *) &((btConeTwistConstraint const *)arg1)->getRigidBodyA(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btConeTwistConstraint_getRigidBodyB_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btRigidBody *) &((btConeTwistConstraint const *)arg1)->getRigidBodyB(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setAngularOnly_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, bool _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setAngularOnly(arg2); + +} + + +bool _wrap_btConeTwistConstraint_getAngularOnly_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (bool)((btConeTwistConstraint const *)arg1)->getAngularOnly(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setLimit__SWIG_0_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setLimit(arg2,arg3); + +} + + +float _wrap_btConeTwistConstraint_getLimit_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, intgo _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getLimit(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setLimit__SWIG_1_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar arg4 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + + (arg1)->setLimit(arg2,arg3,arg4,arg5,arg6,arg7); + +} + + +void _wrap_btConeTwistConstraint_setLimit__SWIG_2_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4, float _swig_go_5) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar arg4 ; + btScalar arg5 ; + btScalar arg6 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + (arg1)->setLimit(arg2,arg3,arg4,arg5,arg6); + +} + + +void _wrap_btConeTwistConstraint_setLimit__SWIG_3_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3, float _swig_go_4) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar arg4 ; + btScalar arg5 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + + (arg1)->setLimit(arg2,arg3,arg4,arg5); + +} + + +void _wrap_btConeTwistConstraint_setLimit__SWIG_4_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1, float _swig_go_2, float _swig_go_3) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btScalar arg4 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->setLimit(arg2,arg3,arg4); + +} + + +btTransform *_wrap_btConeTwistConstraint_getAFrame_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btTransform *) &((btConeTwistConstraint const *)arg1)->getAFrame(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btConeTwistConstraint_getBFrame_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btTransform *) &((btConeTwistConstraint const *)arg1)->getBFrame(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConeTwistConstraint_getSolveTwistLimit_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (int)(arg1)->getSolveTwistLimit(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConeTwistConstraint_getSolveSwingLimit_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (int)(arg1)->getSolveSwingLimit(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getTwistLimitSign_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)(arg1)->getTwistLimitSign(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_calcAngleInfo_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + (arg1)->calcAngleInfo(); + +} + + +void _wrap_btConeTwistConstraint_calcAngleInfo2_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2, btMatrix3x3 *_swig_go_3, btMatrix3x3 *_swig_go_4) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + btMatrix3x3 *arg4 = 0 ; + btMatrix3x3 *arg5 = 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btMatrix3x3 **)&_swig_go_3; + arg5 = *(btMatrix3x3 **)&_swig_go_4; + + (arg1)->calcAngleInfo2((btTransform const &)*arg2,(btTransform const &)*arg3,(btMatrix3x3 const &)*arg4,(btMatrix3x3 const &)*arg5); + +} + + +float _wrap_btConeTwistConstraint_getSwingSpan1_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getSwingSpan1(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getSwingSpan2_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getSwingSpan2(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getTwistSpan_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getTwistSpan(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getLimitSoftness_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getLimitSoftness(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getBiasFactor_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getBiasFactor(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getRelaxationFactor_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getRelaxationFactor(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getTwistAngle_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getTwistAngle(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConeTwistConstraint_isPastSwingLimit_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (bool)(arg1)->isPastSwingLimit(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getDamping_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getDamping(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setDamping_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setDamping(arg2); + +} + + +void _wrap_btConeTwistConstraint_enableMotor_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, bool _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->enableMotor(arg2); + +} + + +bool _wrap_btConeTwistConstraint_isMotorEnabled_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (bool)((btConeTwistConstraint const *)arg1)->isMotorEnabled(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getMaxMotorImpulse_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getMaxMotorImpulse(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConeTwistConstraint_isMaxMotorImpulseNormalized_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (bool)((btConeTwistConstraint const *)arg1)->isMaxMotorImpulseNormalized(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setMaxMotorImpulse_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setMaxMotorImpulse(arg2); + +} + + +void _wrap_btConeTwistConstraint_setMaxMotorImpulseNormalized_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setMaxMotorImpulseNormalized(arg2); + +} + + +float _wrap_btConeTwistConstraint_getFixThresh_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btScalar)(arg1)->getFixThresh(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setFixThresh_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setFixThresh(arg2); + +} + + +void _wrap_btConeTwistConstraint_setMotorTarget_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btQuaternion *_swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btQuaternion *arg2 = 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + (arg1)->setMotorTarget((btQuaternion const &)*arg2); + +} + + +btQuaternion *_wrap_btConeTwistConstraint_getMotorTarget_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btQuaternion *result = 0 ; + btQuaternion *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btQuaternion *) &((btConeTwistConstraint const *)arg1)->getMotorTarget(); + *(btQuaternion **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setMotorTargetInConstraintSpace_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btQuaternion *_swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btQuaternion *arg2 = 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + + (arg1)->setMotorTargetInConstraintSpace((btQuaternion const &)*arg2); + +} + + +btVector3 *_wrap_btConeTwistConstraint_GetPointForAngle_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1, float _swig_go_2) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = ((btConeTwistConstraint const *)arg1)->GetPointForAngle(arg2,arg3); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2, intgo _swig_go_3) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + int arg4 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->setParam(arg2,arg3,arg4); + +} + + +void _wrap_btConeTwistConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setParam(arg2,arg3); + +} + + +void _wrap_btConeTwistConstraint_setFrames_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + + (arg1)->setFrames((btTransform const &)*arg2,(btTransform const &)*arg3); + +} + + +btTransform *_wrap_btConeTwistConstraint_getFrameOffsetA_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btTransform *) &((btConeTwistConstraint const *)arg1)->getFrameOffsetA(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btConeTwistConstraint_getFrameOffsetB_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (btTransform *) &((btConeTwistConstraint const *)arg1)->getFrameOffsetB(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int arg2 ; + int arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getParam(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, intgo _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btScalar)((btConeTwistConstraint const *)arg1)->getParam(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConeTwistConstraint_getFlags_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (int)((btConeTwistConstraint const *)arg1)->getFlags(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConeTwistConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + result = (int)((btConeTwistConstraint const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btConeTwistConstraint_serialize_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btConeTwistConstraint const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_delete_btConeTwistConstraint_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + delete arg1; + +} + + +btRigidBody *_wrap_btConeTwistConstraint_getFixedBody_mbt_e879218550ba2e2b() { + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + + result = (btRigidBody *) &btTypedConstraint::getFixedBody(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConeTwistConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (int)((btTypedConstraint const *)swig_b0)->getOverrideNumSolverIterations(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, intgo _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setOverrideNumSolverIterations(arg2); + +} + + +void _wrap_btConeTwistConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btAlignedObjectArray< btSolverConstraint > *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3, float _swig_go_4) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btConstraintArray *arg2 = 0 ; + int arg3 ; + int arg4 ; + btScalar arg5 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btConstraintArray **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setupSolverConstraint(*arg2,arg3,arg4,arg5); + +} + + +void _wrap_btConeTwistConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->internalSetAppliedImpulse(arg2); + +} + + +float _wrap_btConeTwistConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btScalar)(swig_b0)->internalGetAppliedImpulse(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btConeTwistConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btScalar)((btTypedConstraint const *)swig_b0)->getBreakingImpulseThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setBreakingImpulseThreshold(arg2); + +} + + +bool _wrap_btConeTwistConstraint_isEnabled_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (bool)((btTypedConstraint const *)swig_b0)->isEnabled(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setEnabled_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, bool _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setEnabled(arg2); + +} + + +intgo _wrap_btConeTwistConstraint_getUserConstraintType_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (int)((btTypedConstraint const *)swig_b0)->getUserConstraintType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setUserConstraintType_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, intgo _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setUserConstraintType(arg2); + +} + + +void _wrap_btConeTwistConstraint_setUserConstraintId_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, intgo _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setUserConstraintId(arg2); + +} + + +intgo _wrap_btConeTwistConstraint_getUserConstraintId_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (int)((btTypedConstraint const *)swig_b0)->getUserConstraintId(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, void *_swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setUserConstraintPtr(arg2); + +} + + +void *_wrap_btConeTwistConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (void *)(swig_b0)->getUserConstraintPtr(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setJointFeedback_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, btJointFeedback *_swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btJointFeedback *arg2 = (btJointFeedback *) 0 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = *(btJointFeedback **)&_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setJointFeedback(arg2); + +} + + +btJointFeedback *_wrap_btConeTwistConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btJointFeedback *result = 0 ; + btJointFeedback *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btJointFeedback *)((btTypedConstraint const *)swig_b0)->getJointFeedback(); + *(btJointFeedback **)&_swig_go_result = (btJointFeedback *)result; + return _swig_go_result; +} + + +btJointFeedback *_wrap_btConeTwistConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btJointFeedback *result = 0 ; + btJointFeedback *_swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btJointFeedback *)(swig_b0)->getJointFeedback(); + *(btJointFeedback **)&_swig_go_result = (btJointFeedback *)result; + return _swig_go_result; +} + + +intgo _wrap_btConeTwistConstraint_getUid_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (int)((btTypedConstraint const *)swig_b0)->getUid(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btConeTwistConstraint_needsFeedback_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (bool)((btTypedConstraint const *)swig_b0)->needsFeedback(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_enableFeedback_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, bool _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->enableFeedback(arg2); + +} + + +float _wrap_btConeTwistConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btScalar)((btTypedConstraint const *)swig_b0)->getAppliedImpulse(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConeTwistConstraint_getConstraintType_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btTypedConstraintType result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btTypedConstraintType)((btTypedConstraint const *)swig_b0)->getConstraintType(); + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, float _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setDbgDrawSize(arg2); + +} + + +float _wrap_btConeTwistConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btScalar)(swig_b0)->getDbgDrawSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtConeTwistConstraint_M_objectType_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0, intgo _swig_go_1) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int arg2 ; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + btTypedObject *swig_b1 = (btTypedObject *)swig_b0; + if (swig_b1) (swig_b1)->m_objectType = arg2; + +} + + +intgo _wrap_GetbtConeTwistConstraint_M_objectType_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + btTypedObject *swig_b1 = (btTypedObject *)swig_b0; + result = (int) ((swig_b1)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btConeTwistConstraint_getObjectType_mbt_e879218550ba2e2b(btConeTwistConstraint *_swig_go_0) { + btConeTwistConstraint *arg1 = (btConeTwistConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConeTwistConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + btTypedObject *swig_b1 = (btTypedObject *)swig_b0; + result = (int)((btTypedObject const *)swig_b1)->getObjectType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintDoubleData_m_typeConstraintData_set_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0, btTypedConstraintDoubleData *_swig_go_1) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + btTypedConstraintDoubleData *arg2 = (btTypedConstraintDoubleData *) 0 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + arg2 = *(btTypedConstraintDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_typeConstraintData = *arg2; + +} + + +btTypedConstraintDoubleData *_wrap_btConeTwistConstraintDoubleData_m_typeConstraintData_get_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + btTypedConstraintDoubleData *result = 0 ; + btTypedConstraintDoubleData *_swig_go_result; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + result = (btTypedConstraintDoubleData *)& ((arg1)->m_typeConstraintData); + *(btTypedConstraintDoubleData **)&_swig_go_result = (btTypedConstraintDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintDoubleData_m_rbAFrame_set_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0, btTransformDoubleData *_swig_go_1) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + btTransformDoubleData *arg2 = (btTransformDoubleData *) 0 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + arg2 = *(btTransformDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbAFrame = *arg2; + +} + + +btTransformDoubleData *_wrap_btConeTwistConstraintDoubleData_m_rbAFrame_get_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + btTransformDoubleData *result = 0 ; + btTransformDoubleData *_swig_go_result; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + result = (btTransformDoubleData *)& ((arg1)->m_rbAFrame); + *(btTransformDoubleData **)&_swig_go_result = (btTransformDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintDoubleData_m_rbBFrame_set_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0, btTransformDoubleData *_swig_go_1) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + btTransformDoubleData *arg2 = (btTransformDoubleData *) 0 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + arg2 = *(btTransformDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbBFrame = *arg2; + +} + + +btTransformDoubleData *_wrap_btConeTwistConstraintDoubleData_m_rbBFrame_get_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + btTransformDoubleData *result = 0 ; + btTransformDoubleData *_swig_go_result; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + result = (btTransformDoubleData *)& ((arg1)->m_rbBFrame); + *(btTransformDoubleData **)&_swig_go_result = (btTransformDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintDoubleData_m_swingSpan1_set_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0, double _swig_go_1) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_swingSpan1 = arg2; + +} + + +double _wrap_btConeTwistConstraintDoubleData_m_swingSpan1_get_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_swingSpan1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintDoubleData_m_swingSpan2_set_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0, double _swig_go_1) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_swingSpan2 = arg2; + +} + + +double _wrap_btConeTwistConstraintDoubleData_m_swingSpan2_get_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_swingSpan2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintDoubleData_m_twistSpan_set_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0, double _swig_go_1) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_twistSpan = arg2; + +} + + +double _wrap_btConeTwistConstraintDoubleData_m_twistSpan_get_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_twistSpan); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintDoubleData_m_limitSoftness_set_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0, double _swig_go_1) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_limitSoftness = arg2; + +} + + +double _wrap_btConeTwistConstraintDoubleData_m_limitSoftness_get_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_limitSoftness); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintDoubleData_m_biasFactor_set_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0, double _swig_go_1) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_biasFactor = arg2; + +} + + +double _wrap_btConeTwistConstraintDoubleData_m_biasFactor_get_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_biasFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintDoubleData_m_relaxationFactor_set_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0, double _swig_go_1) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_relaxationFactor = arg2; + +} + + +double _wrap_btConeTwistConstraintDoubleData_m_relaxationFactor_get_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_relaxationFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintDoubleData_m_damping_set_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0, double _swig_go_1) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double arg2 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + arg2 = (double)_swig_go_1; + + if (arg1) (arg1)->m_damping = arg2; + +} + + +double _wrap_btConeTwistConstraintDoubleData_m_damping_get_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + double result; + double _swig_go_result; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + result = (double) ((arg1)->m_damping); + _swig_go_result = result; + return _swig_go_result; +} + + +btConeTwistConstraintDoubleData *_wrap_new_btConeTwistConstraintDoubleData_mbt_e879218550ba2e2b() { + btConeTwistConstraintDoubleData *result = 0 ; + btConeTwistConstraintDoubleData *_swig_go_result; + + + result = (btConeTwistConstraintDoubleData *)new btConeTwistConstraintDoubleData(); + *(btConeTwistConstraintDoubleData **)&_swig_go_result = (btConeTwistConstraintDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btConeTwistConstraintDoubleData_mbt_e879218550ba2e2b(btConeTwistConstraintDoubleData *_swig_go_0) { + btConeTwistConstraintDoubleData *arg1 = (btConeTwistConstraintDoubleData *) 0 ; + + arg1 = *(btConeTwistConstraintDoubleData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConeTwistConstraintData_m_typeConstraintData_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, btTypedConstraintData *_swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + btTypedConstraintData *arg2 = (btTypedConstraintData *) 0 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + arg2 = *(btTypedConstraintData **)&_swig_go_1; + + if (arg1) (arg1)->m_typeConstraintData = *arg2; + +} + + +btTypedConstraintData *_wrap_btConeTwistConstraintData_m_typeConstraintData_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + btTypedConstraintData *result = 0 ; + btTypedConstraintData *_swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (btTypedConstraintData *)& ((arg1)->m_typeConstraintData); + *(btTypedConstraintData **)&_swig_go_result = (btTypedConstraintData *)result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintData_m_rbAFrame_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, btTransformFloatData *_swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + btTransformFloatData *arg2 = (btTransformFloatData *) 0 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + arg2 = *(btTransformFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbAFrame = *arg2; + +} + + +btTransformFloatData *_wrap_btConeTwistConstraintData_m_rbAFrame_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + btTransformFloatData *result = 0 ; + btTransformFloatData *_swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (btTransformFloatData *)& ((arg1)->m_rbAFrame); + *(btTransformFloatData **)&_swig_go_result = (btTransformFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintData_m_rbBFrame_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, btTransformFloatData *_swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + btTransformFloatData *arg2 = (btTransformFloatData *) 0 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + arg2 = *(btTransformFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbBFrame = *arg2; + +} + + +btTransformFloatData *_wrap_btConeTwistConstraintData_m_rbBFrame_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + btTransformFloatData *result = 0 ; + btTransformFloatData *_swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (btTransformFloatData *)& ((arg1)->m_rbBFrame); + *(btTransformFloatData **)&_swig_go_result = (btTransformFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintData_m_swingSpan1_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, float _swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float arg2 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_swingSpan1 = arg2; + +} + + +float _wrap_btConeTwistConstraintData_m_swingSpan1_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (float) ((arg1)->m_swingSpan1); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintData_m_swingSpan2_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, float _swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float arg2 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_swingSpan2 = arg2; + +} + + +float _wrap_btConeTwistConstraintData_m_swingSpan2_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (float) ((arg1)->m_swingSpan2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintData_m_twistSpan_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, float _swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float arg2 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_twistSpan = arg2; + +} + + +float _wrap_btConeTwistConstraintData_m_twistSpan_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (float) ((arg1)->m_twistSpan); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintData_m_limitSoftness_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, float _swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float arg2 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_limitSoftness = arg2; + +} + + +float _wrap_btConeTwistConstraintData_m_limitSoftness_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (float) ((arg1)->m_limitSoftness); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintData_m_biasFactor_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, float _swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float arg2 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_biasFactor = arg2; + +} + + +float _wrap_btConeTwistConstraintData_m_biasFactor_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (float) ((arg1)->m_biasFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintData_m_relaxationFactor_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, float _swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float arg2 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_relaxationFactor = arg2; + +} + + +float _wrap_btConeTwistConstraintData_m_relaxationFactor_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (float) ((arg1)->m_relaxationFactor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintData_m_damping_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, float _swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float arg2 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_damping = arg2; + +} + + +float _wrap_btConeTwistConstraintData_m_damping_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (float) ((arg1)->m_damping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConeTwistConstraintData_m_pad_set_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0, _gostring_ _swig_go_1) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_pad, (const char *)arg2, 4-1); + arg1->m_pad[4-1] = 0; + } else { + arg1->m_pad[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btConeTwistConstraintData_m_pad_get_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_pad); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btConeTwistConstraintData *_wrap_new_btConeTwistConstraintData_mbt_e879218550ba2e2b() { + btConeTwistConstraintData *result = 0 ; + btConeTwistConstraintData *_swig_go_result; + + + result = (btConeTwistConstraintData *)new btConeTwistConstraintData(); + *(btConeTwistConstraintData **)&_swig_go_result = (btConeTwistConstraintData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btConeTwistConstraintData_mbt_e879218550ba2e2b(btConeTwistConstraintData *_swig_go_0) { + btConeTwistConstraintData *arg1 = (btConeTwistConstraintData *) 0 ; + + arg1 = *(btConeTwistConstraintData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btRotationalLimitMotor_m_loLimit_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_loLimit = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_loLimit_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_loLimit); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_hiLimit_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_hiLimit = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_hiLimit_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_hiLimit); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_targetVelocity_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_targetVelocity = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_targetVelocity_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_targetVelocity); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_maxMotorForce_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_maxMotorForce = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_maxMotorForce_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_maxMotorForce); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_maxLimitForce_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_maxLimitForce = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_maxLimitForce_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_maxLimitForce); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_damping_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_damping = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_damping_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_damping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_limitSoftness_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_limitSoftness = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_limitSoftness_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_limitSoftness); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_normalCFM_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_normalCFM = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_normalCFM_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_normalCFM); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_stopERP_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_stopERP = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_stopERP_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_stopERP); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_stopCFM_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_stopCFM = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_stopCFM_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_stopCFM); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_bounce_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_bounce = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_bounce_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_bounce); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_enableMotor_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, bool _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + bool arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_enableMotor = arg2; + +} + + +bool _wrap_btRotationalLimitMotor_m_enableMotor_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (bool) ((arg1)->m_enableMotor); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_currentLimitError_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_currentLimitError = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_currentLimitError_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_currentLimitError); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_currentPosition_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_currentPosition = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_currentPosition_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_currentPosition); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_currentLimit_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, intgo _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + int arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_currentLimit = arg2; + +} + + +intgo _wrap_btRotationalLimitMotor_m_currentLimit_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (int) ((arg1)->m_currentLimit); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btRotationalLimitMotor_m_accumulatedImpulse_set_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_accumulatedImpulse = arg2; + +} + + +float _wrap_btRotationalLimitMotor_m_accumulatedImpulse_get_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_accumulatedImpulse); + _swig_go_result = result; + return _swig_go_result; +} + + +btRotationalLimitMotor *_wrap_new_btRotationalLimitMotor__SWIG_0_mbt_e879218550ba2e2b() { + btRotationalLimitMotor *result = 0 ; + btRotationalLimitMotor *_swig_go_result; + + + result = (btRotationalLimitMotor *)new btRotationalLimitMotor(); + *(btRotationalLimitMotor **)&_swig_go_result = (btRotationalLimitMotor *)result; + return _swig_go_result; +} + + +btRotationalLimitMotor *_wrap_new_btRotationalLimitMotor__SWIG_1_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = 0 ; + btRotationalLimitMotor *result = 0 ; + btRotationalLimitMotor *_swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (btRotationalLimitMotor *)new btRotationalLimitMotor((btRotationalLimitMotor const &)*arg1); + *(btRotationalLimitMotor **)&_swig_go_result = (btRotationalLimitMotor *)result; + return _swig_go_result; +} + + +bool _wrap_btRotationalLimitMotor_isLimited_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (bool)((btRotationalLimitMotor const *)arg1)->isLimited(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btRotationalLimitMotor_needApplyTorques_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + result = (bool)((btRotationalLimitMotor const *)arg1)->needApplyTorques(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btRotationalLimitMotor_testLimitValue_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + int result; + intgo _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (int)(arg1)->testLimitValue(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btRotationalLimitMotor_solveAngularLimits_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2, float _swig_go_3, btRigidBody *_swig_go_4, btRigidBody *_swig_go_5) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + btRigidBody *arg5 = (btRigidBody *) 0 ; + btRigidBody *arg6 = (btRigidBody *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = *(btRigidBody **)&_swig_go_4; + arg6 = *(btRigidBody **)&_swig_go_5; + + result = (btScalar)(arg1)->solveAngularLimits(arg2,*arg3,arg4,arg5,arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btRotationalLimitMotor_mbt_e879218550ba2e2b(btRotationalLimitMotor *_swig_go_0) { + btRotationalLimitMotor *arg1 = (btRotationalLimitMotor *) 0 ; + + arg1 = *(btRotationalLimitMotor **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btTranslationalLimitMotor_m_lowerLimit_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, btVector3 *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_lowerLimit = *arg2; + +} + + +btVector3 *_wrap_btTranslationalLimitMotor_m_lowerLimit_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_lowerLimit); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_upperLimit_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, btVector3 *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_upperLimit = *arg2; + +} + + +btVector3 *_wrap_btTranslationalLimitMotor_m_upperLimit_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_upperLimit); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_accumulatedImpulse_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, btVector3 *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_accumulatedImpulse = *arg2; + +} + + +btVector3 *_wrap_btTranslationalLimitMotor_m_accumulatedImpulse_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_accumulatedImpulse); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_limitSoftness_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, float _swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_limitSoftness = arg2; + +} + + +float _wrap_btTranslationalLimitMotor_m_limitSoftness_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_limitSoftness); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_damping_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, float _swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_damping = arg2; + +} + + +float _wrap_btTranslationalLimitMotor_m_damping_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_damping); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_restitution_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, float _swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btScalar arg2 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_restitution = arg2; + +} + + +float _wrap_btTranslationalLimitMotor_m_restitution_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_restitution); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_normalCFM_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, btVector3 *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_normalCFM = *arg2; + +} + + +btVector3 *_wrap_btTranslationalLimitMotor_m_normalCFM_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_normalCFM); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_stopERP_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, btVector3 *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_stopERP = *arg2; + +} + + +btVector3 *_wrap_btTranslationalLimitMotor_m_stopERP_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_stopERP); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_stopCFM_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, btVector3 *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_stopCFM = *arg2; + +} + + +btVector3 *_wrap_btTranslationalLimitMotor_m_stopCFM_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_stopCFM); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_enableMotor_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, bool *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + bool *arg2 = (bool *) (bool *)0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(bool **)&_swig_go_1; + + { + size_t ii; + bool *b = (bool *) arg1->m_enableMotor; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((bool *) arg2 + ii); + } + +} + + +bool *_wrap_btTranslationalLimitMotor_m_enableMotor_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + bool *result = 0 ; + bool *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (bool *)(bool *) ((arg1)->m_enableMotor); + *(bool **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_targetVelocity_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, btVector3 *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_targetVelocity = *arg2; + +} + + +btVector3 *_wrap_btTranslationalLimitMotor_m_targetVelocity_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_targetVelocity); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_maxMotorForce_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, btVector3 *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_maxMotorForce = *arg2; + +} + + +btVector3 *_wrap_btTranslationalLimitMotor_m_maxMotorForce_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_maxMotorForce); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_currentLimitError_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, btVector3 *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_currentLimitError = *arg2; + +} + + +btVector3 *_wrap_btTranslationalLimitMotor_m_currentLimitError_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_currentLimitError); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_currentLinearDiff_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, btVector3 *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_currentLinearDiff = *arg2; + +} + + +btVector3 *_wrap_btTranslationalLimitMotor_m_currentLinearDiff_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_currentLinearDiff); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btTranslationalLimitMotor_m_currentLimit_set_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, intgo *_swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_currentLimit; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btTranslationalLimitMotor_m_currentLimit_get_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_currentLimit); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTranslationalLimitMotor *_wrap_new_btTranslationalLimitMotor__SWIG_0_mbt_e879218550ba2e2b() { + btTranslationalLimitMotor *result = 0 ; + btTranslationalLimitMotor *_swig_go_result; + + + result = (btTranslationalLimitMotor *)new btTranslationalLimitMotor(); + *(btTranslationalLimitMotor **)&_swig_go_result = (btTranslationalLimitMotor *)result; + return _swig_go_result; +} + + +btTranslationalLimitMotor *_wrap_new_btTranslationalLimitMotor__SWIG_1_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = 0 ; + btTranslationalLimitMotor *result = 0 ; + btTranslationalLimitMotor *_swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + result = (btTranslationalLimitMotor *)new btTranslationalLimitMotor((btTranslationalLimitMotor const &)*arg1); + *(btTranslationalLimitMotor **)&_swig_go_result = (btTranslationalLimitMotor *)result; + return _swig_go_result; +} + + +bool _wrap_btTranslationalLimitMotor_isLimited_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, intgo _swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (bool)((btTranslationalLimitMotor const *)arg1)->isLimited(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btTranslationalLimitMotor_needApplyForce_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, intgo _swig_go_1) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (bool)((btTranslationalLimitMotor const *)arg1)->needApplyForce(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btTranslationalLimitMotor_testLimitValue_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, intgo _swig_go_1, float _swig_go_2) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + int arg2 ; + btScalar arg3 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = (int)(arg1)->testLimitValue(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btTranslationalLimitMotor_solveLinearAxis_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0, float _swig_go_1, float _swig_go_2, btRigidBody *_swig_go_3, btVector3 *_swig_go_4, btRigidBody *_swig_go_5, btVector3 *_swig_go_6, intgo _swig_go_7, btVector3 *_swig_go_8, btVector3 *_swig_go_9) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + btRigidBody *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btRigidBody *arg6 = 0 ; + btVector3 *arg7 = 0 ; + int arg8 ; + btVector3 *arg9 = 0 ; + btVector3 *arg10 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = *(btRigidBody **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btRigidBody **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = (int)_swig_go_7; + arg9 = *(btVector3 **)&_swig_go_8; + arg10 = *(btVector3 **)&_swig_go_9; + + result = (btScalar)(arg1)->solveLinearAxis(arg2,arg3,*arg4,(btVector3 const &)*arg5,*arg6,(btVector3 const &)*arg7,arg8,(btVector3 const &)*arg9,(btVector3 const &)*arg10); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btTranslationalLimitMotor_mbt_e879218550ba2e2b(btTranslationalLimitMotor *_swig_go_0) { + btTranslationalLimitMotor *arg1 = (btTranslationalLimitMotor *) 0 ; + + arg1 = *(btTranslationalLimitMotor **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_BT_6DOF_FLAGS_CFM_NORM_mbt_e879218550ba2e2b() { + bt6DofFlags result; + intgo _swig_go_result; + + + result = BT_6DOF_FLAGS_CFM_NORM; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_6DOF_FLAGS_CFM_STOP_mbt_e879218550ba2e2b() { + bt6DofFlags result; + intgo _swig_go_result; + + + result = BT_6DOF_FLAGS_CFM_STOP; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +intgo _wrap_BT_6DOF_FLAGS_ERP_STOP_mbt_e879218550ba2e2b() { + bt6DofFlags result; + intgo _swig_go_result; + + + result = BT_6DOF_FLAGS_ERP_STOP; + + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_m_useSolveConstraintObsolete_set_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, bool _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_useSolveConstraintObsolete = arg2; + +} + + +bool _wrap_btGeneric6DofConstraint_m_useSolveConstraintObsolete_get_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (bool) ((arg1)->m_useSolveConstraintObsolete); + _swig_go_result = result; + return _swig_go_result; +} + + +btGeneric6DofConstraint *_wrap_new_btGeneric6DofConstraint__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btRigidBody *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, bool _swig_go_4) { + btRigidBody *arg1 = 0 ; + btRigidBody *arg2 = 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + bool arg5 ; + btGeneric6DofConstraint *result = 0 ; + btGeneric6DofConstraint *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + + result = (btGeneric6DofConstraint *)new btGeneric6DofConstraint(*arg1,*arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,arg5); + *(btGeneric6DofConstraint **)&_swig_go_result = (btGeneric6DofConstraint *)result; + return _swig_go_result; +} + + +btGeneric6DofConstraint *_wrap_new_btGeneric6DofConstraint__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btTransform *_swig_go_1, bool _swig_go_2) { + btRigidBody *arg1 = 0 ; + btTransform *arg2 = 0 ; + bool arg3 ; + btGeneric6DofConstraint *result = 0 ; + btGeneric6DofConstraint *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = (bool)_swig_go_2; + + result = (btGeneric6DofConstraint *)new btGeneric6DofConstraint(*arg1,(btTransform const &)*arg2,arg3); + *(btGeneric6DofConstraint **)&_swig_go_result = (btGeneric6DofConstraint *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_calculateTransforms__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + + (arg1)->calculateTransforms((btTransform const &)*arg2,(btTransform const &)*arg3); + +} + + +void _wrap_btGeneric6DofConstraint_calculateTransforms__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + (arg1)->calculateTransforms(); + +} + + +btTransform *_wrap_btGeneric6DofConstraint_getCalculatedTransformA_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (btTransform *) &((btGeneric6DofConstraint const *)arg1)->getCalculatedTransformA(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btGeneric6DofConstraint_getCalculatedTransformB_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (btTransform *) &((btGeneric6DofConstraint const *)arg1)->getCalculatedTransformB(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btGeneric6DofConstraint_getFrameOffsetA__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (btTransform *) &((btGeneric6DofConstraint const *)arg1)->getFrameOffsetA(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btGeneric6DofConstraint_getFrameOffsetB__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (btTransform *) &((btGeneric6DofConstraint const *)arg1)->getFrameOffsetB(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btGeneric6DofConstraint_getFrameOffsetA__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (btTransform *) &(arg1)->getFrameOffsetA(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btGeneric6DofConstraint_getFrameOffsetB__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (btTransform *) &(arg1)->getFrameOffsetB(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_buildJacobian_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + (arg1)->buildJacobian(); + +} + + +void _wrap_btGeneric6DofConstraint_getInfo1_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo1 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTypedConstraint::btConstraintInfo1 *arg2 = (btTypedConstraint::btConstraintInfo1 *) 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo1 **)&_swig_go_1; + + (arg1)->getInfo1(arg2); + +} + + +void _wrap_btGeneric6DofConstraint_getInfo1NonVirtual_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo1 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTypedConstraint::btConstraintInfo1 *arg2 = (btTypedConstraint::btConstraintInfo1 *) 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo1 **)&_swig_go_1; + + (arg1)->getInfo1NonVirtual(arg2); + +} + + +void _wrap_btGeneric6DofConstraint_getInfo2_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo2 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTypedConstraint::btConstraintInfo2 *arg2 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_1; + + (arg1)->getInfo2(arg2); + +} + + +void _wrap_btGeneric6DofConstraint_getInfo2NonVirtual_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo2 *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTypedConstraint::btConstraintInfo2 *arg2 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + + (arg1)->getInfo2NonVirtual(arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8); + +} + + +void _wrap_btGeneric6DofConstraint_updateRHS_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, float _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->updateRHS(arg2); + +} + + +btVector3 *_wrap_btGeneric6DofConstraint_getAxis_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = ((btGeneric6DofConstraint const *)arg1)->getAxis(arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btGeneric6DofConstraint_getAngle_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btScalar)((btGeneric6DofConstraint const *)arg1)->getAngle(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGeneric6DofConstraint_getRelativePivotPosition_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btScalar)((btGeneric6DofConstraint const *)arg1)->getRelativePivotPosition(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setFrames_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + + (arg1)->setFrames((btTransform const &)*arg2,(btTransform const &)*arg3); + +} + + +bool _wrap_btGeneric6DofConstraint_testAngularLimitMotor_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (bool)(arg1)->testAngularLimitMotor(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setLinearLowerLimit_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLinearLowerLimit((btVector3 const &)*arg2); + +} + + +void _wrap_btGeneric6DofConstraint_getLinearLowerLimit_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + ((btGeneric6DofConstraint const *)arg1)->getLinearLowerLimit(*arg2); + +} + + +void _wrap_btGeneric6DofConstraint_setLinearUpperLimit_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLinearUpperLimit((btVector3 const &)*arg2); + +} + + +void _wrap_btGeneric6DofConstraint_getLinearUpperLimit_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + ((btGeneric6DofConstraint const *)arg1)->getLinearUpperLimit(*arg2); + +} + + +void _wrap_btGeneric6DofConstraint_setAngularLowerLimit_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setAngularLowerLimit((btVector3 const &)*arg2); + +} + + +void _wrap_btGeneric6DofConstraint_getAngularLowerLimit_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + ((btGeneric6DofConstraint const *)arg1)->getAngularLowerLimit(*arg2); + +} + + +void _wrap_btGeneric6DofConstraint_setAngularUpperLimit_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setAngularUpperLimit((btVector3 const &)*arg2); + +} + + +void _wrap_btGeneric6DofConstraint_getAngularUpperLimit_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + ((btGeneric6DofConstraint const *)arg1)->getAngularUpperLimit(*arg2); + +} + + +btRotationalLimitMotor *_wrap_btGeneric6DofConstraint_getRotationalLimitMotor_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + btRotationalLimitMotor *result = 0 ; + btRotationalLimitMotor *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btRotationalLimitMotor *)(arg1)->getRotationalLimitMotor(arg2); + *(btRotationalLimitMotor **)&_swig_go_result = (btRotationalLimitMotor *)result; + return _swig_go_result; +} + + +btTranslationalLimitMotor *_wrap_btGeneric6DofConstraint_getTranslationalLimitMotor_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTranslationalLimitMotor *result = 0 ; + btTranslationalLimitMotor *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (btTranslationalLimitMotor *)(arg1)->getTranslationalLimitMotor(); + *(btTranslationalLimitMotor **)&_swig_go_result = (btTranslationalLimitMotor *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setLimit_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2, float _swig_go_3) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + btScalar arg4 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + (arg1)->setLimit(arg2,arg3,arg4); + +} + + +bool _wrap_btGeneric6DofConstraint_isLimited_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (bool)((btGeneric6DofConstraint const *)arg1)->isLimited(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_calcAnchorPos_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + (arg1)->calcAnchorPos(); + +} + + +intgo _wrap_btGeneric6DofConstraint_get_limit_motor_info2__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btRotationalLimitMotor *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7, btTypedConstraint::btConstraintInfo2 *_swig_go_8, intgo _swig_go_9, btVector3 *_swig_go_10, intgo _swig_go_11, intgo _swig_go_12) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btRotationalLimitMotor *arg2 = (btRotationalLimitMotor *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + btTypedConstraint::btConstraintInfo2 *arg9 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + int arg10 ; + btVector3 *arg11 = 0 ; + int arg12 ; + int arg13 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btRotationalLimitMotor **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_8; + arg10 = (int)_swig_go_9; + arg11 = *(btVector3 **)&_swig_go_10; + arg12 = (int)_swig_go_11; + arg13 = (int)_swig_go_12; + + result = (int)(arg1)->get_limit_motor_info2(arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8,arg9,arg10,*arg11,arg12,arg13); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofConstraint_get_limit_motor_info2__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btRotationalLimitMotor *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7, btTypedConstraint::btConstraintInfo2 *_swig_go_8, intgo _swig_go_9, btVector3 *_swig_go_10, intgo _swig_go_11) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btRotationalLimitMotor *arg2 = (btRotationalLimitMotor *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + btTypedConstraint::btConstraintInfo2 *arg9 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + int arg10 ; + btVector3 *arg11 = 0 ; + int arg12 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btRotationalLimitMotor **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_8; + arg10 = (int)_swig_go_9; + arg11 = *(btVector3 **)&_swig_go_10; + arg12 = (int)_swig_go_11; + + result = (int)(arg1)->get_limit_motor_info2(arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8,arg9,arg10,*arg11,arg12); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btGeneric6DofConstraint_getUseFrameOffset_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (bool)((btGeneric6DofConstraint const *)arg1)->getUseFrameOffset(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setUseFrameOffset_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, bool _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setUseFrameOffset(arg2); + +} + + +bool _wrap_btGeneric6DofConstraint_getUseLinearReferenceFrameA_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (bool)((btGeneric6DofConstraint const *)arg1)->getUseLinearReferenceFrameA(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setUseLinearReferenceFrameA_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, bool _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setUseLinearReferenceFrameA(arg2); + +} + + +void _wrap_btGeneric6DofConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2, intgo _swig_go_3) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + int arg4 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->setParam(arg2,arg3,arg4); + +} + + +void _wrap_btGeneric6DofConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setParam(arg2,arg3); + +} + + +float _wrap_btGeneric6DofConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + int arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btScalar)((btGeneric6DofConstraint const *)arg1)->getParam(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGeneric6DofConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btScalar)((btGeneric6DofConstraint const *)arg1)->getParam(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setAxis_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->setAxis((btVector3 const &)*arg2,(btVector3 const &)*arg3); + +} + + +intgo _wrap_btGeneric6DofConstraint_getFlags_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (int)((btGeneric6DofConstraint const *)arg1)->getFlags(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + result = (int)((btGeneric6DofConstraint const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btGeneric6DofConstraint_serialize_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btGeneric6DofConstraint const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_delete_btGeneric6DofConstraint_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + delete arg1; + +} + + +btRigidBody *_wrap_btGeneric6DofConstraint_getFixedBody_mbt_e879218550ba2e2b() { + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + + result = (btRigidBody *) &btTypedConstraint::getFixedBody(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (int)((btTypedConstraint const *)swig_b0)->getOverrideNumSolverIterations(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setOverrideNumSolverIterations(arg2); + +} + + +void _wrap_btGeneric6DofConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btAlignedObjectArray< btSolverConstraint > *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3, float _swig_go_4) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btConstraintArray *arg2 = 0 ; + int arg3 ; + int arg4 ; + btScalar arg5 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btConstraintArray **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setupSolverConstraint(*arg2,arg3,arg4,arg5); + +} + + +void _wrap_btGeneric6DofConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, float _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->internalSetAppliedImpulse(arg2); + +} + + +float _wrap_btGeneric6DofConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btScalar)(swig_b0)->internalGetAppliedImpulse(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGeneric6DofConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btScalar)((btTypedConstraint const *)swig_b0)->getBreakingImpulseThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, float _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setBreakingImpulseThreshold(arg2); + +} + + +bool _wrap_btGeneric6DofConstraint_isEnabled_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (bool)((btTypedConstraint const *)swig_b0)->isEnabled(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setEnabled_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, bool _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setEnabled(arg2); + +} + + +void _wrap_btGeneric6DofConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btSolverBody *_swig_go_1, btSolverBody *_swig_go_2, float _swig_go_3) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btSolverBody *arg2 = 0 ; + btSolverBody *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btSolverBody **)&_swig_go_1; + arg3 = *(btSolverBody **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->solveConstraintObsolete(*arg2,*arg3,arg4); + +} + + +btRigidBody *_wrap_btGeneric6DofConstraint_getRigidBodyA__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btRigidBody *) &((btTypedConstraint const *)swig_b0)->getRigidBodyA(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btGeneric6DofConstraint_getRigidBodyA__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btRigidBody *) &(swig_b0)->getRigidBodyA(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btGeneric6DofConstraint_getRigidBodyB__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btRigidBody *) &((btTypedConstraint const *)swig_b0)->getRigidBodyB(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btGeneric6DofConstraint_getRigidBodyB__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btRigidBody *) &(swig_b0)->getRigidBodyB(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofConstraint_getUserConstraintType_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (int)((btTypedConstraint const *)swig_b0)->getUserConstraintType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setUserConstraintType_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setUserConstraintType(arg2); + +} + + +void _wrap_btGeneric6DofConstraint_setUserConstraintId_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setUserConstraintId(arg2); + +} + + +intgo _wrap_btGeneric6DofConstraint_getUserConstraintId_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (int)((btTypedConstraint const *)swig_b0)->getUserConstraintId(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, void *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setUserConstraintPtr(arg2); + +} + + +void *_wrap_btGeneric6DofConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (void *)(swig_b0)->getUserConstraintPtr(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setJointFeedback_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, btJointFeedback *_swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btJointFeedback *arg2 = (btJointFeedback *) 0 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = *(btJointFeedback **)&_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setJointFeedback(arg2); + +} + + +btJointFeedback *_wrap_btGeneric6DofConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btJointFeedback *result = 0 ; + btJointFeedback *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btJointFeedback *)((btTypedConstraint const *)swig_b0)->getJointFeedback(); + *(btJointFeedback **)&_swig_go_result = (btJointFeedback *)result; + return _swig_go_result; +} + + +btJointFeedback *_wrap_btGeneric6DofConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btJointFeedback *result = 0 ; + btJointFeedback *_swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btJointFeedback *)(swig_b0)->getJointFeedback(); + *(btJointFeedback **)&_swig_go_result = (btJointFeedback *)result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofConstraint_getUid_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (int)((btTypedConstraint const *)swig_b0)->getUid(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btGeneric6DofConstraint_needsFeedback_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (bool)((btTypedConstraint const *)swig_b0)->needsFeedback(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_enableFeedback_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, bool _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->enableFeedback(arg2); + +} + + +float _wrap_btGeneric6DofConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btScalar)((btTypedConstraint const *)swig_b0)->getAppliedImpulse(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofConstraint_getConstraintType_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btTypedConstraintType result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btTypedConstraintType)((btTypedConstraint const *)swig_b0)->getConstraintType(); + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, float _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + (swig_b0)->setDbgDrawSize(arg2); + +} + + +float _wrap_btGeneric6DofConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + result = (btScalar)(swig_b0)->getDbgDrawSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtGeneric6DofConstraint_M_objectType_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + btTypedObject *swig_b1 = (btTypedObject *)swig_b0; + if (swig_b1) (swig_b1)->m_objectType = arg2; + +} + + +intgo _wrap_GetbtGeneric6DofConstraint_M_objectType_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + btTypedObject *swig_b1 = (btTypedObject *)swig_b0; + result = (int) ((swig_b1)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofConstraint_getObjectType_mbt_e879218550ba2e2b(btGeneric6DofConstraint *_swig_go_0) { + btGeneric6DofConstraint *arg1 = (btGeneric6DofConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraint **)&_swig_go_0; + + btTypedConstraint *swig_b0 = (btTypedConstraint *)arg1; + btTypedObject *swig_b1 = (btTypedObject *)swig_b0; + result = (int)((btTypedObject const *)swig_b1)->getObjectType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintData_m_typeConstraintData_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0, btTypedConstraintData *_swig_go_1) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btTypedConstraintData *arg2 = (btTypedConstraintData *) 0 ; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + arg2 = *(btTypedConstraintData **)&_swig_go_1; + + if (arg1) (arg1)->m_typeConstraintData = *arg2; + +} + + +btTypedConstraintData *_wrap_btGeneric6DofConstraintData_m_typeConstraintData_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btTypedConstraintData *result = 0 ; + btTypedConstraintData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + + result = (btTypedConstraintData *)& ((arg1)->m_typeConstraintData); + *(btTypedConstraintData **)&_swig_go_result = (btTypedConstraintData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintData_m_rbAFrame_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0, btTransformFloatData *_swig_go_1) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btTransformFloatData *arg2 = (btTransformFloatData *) 0 ; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + arg2 = *(btTransformFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbAFrame = *arg2; + +} + + +btTransformFloatData *_wrap_btGeneric6DofConstraintData_m_rbAFrame_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btTransformFloatData *result = 0 ; + btTransformFloatData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + + result = (btTransformFloatData *)& ((arg1)->m_rbAFrame); + *(btTransformFloatData **)&_swig_go_result = (btTransformFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintData_m_rbBFrame_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0, btTransformFloatData *_swig_go_1) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btTransformFloatData *arg2 = (btTransformFloatData *) 0 ; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + arg2 = *(btTransformFloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbBFrame = *arg2; + +} + + +btTransformFloatData *_wrap_btGeneric6DofConstraintData_m_rbBFrame_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btTransformFloatData *result = 0 ; + btTransformFloatData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + + result = (btTransformFloatData *)& ((arg1)->m_rbBFrame); + *(btTransformFloatData **)&_swig_go_result = (btTransformFloatData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintData_m_linearUpperLimit_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_linearUpperLimit = *arg2; + +} + + +btVector3FloatData *_wrap_btGeneric6DofConstraintData_m_linearUpperLimit_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_linearUpperLimit); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintData_m_linearLowerLimit_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_linearLowerLimit = *arg2; + +} + + +btVector3FloatData *_wrap_btGeneric6DofConstraintData_m_linearLowerLimit_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_linearLowerLimit); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintData_m_angularUpperLimit_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_angularUpperLimit = *arg2; + +} + + +btVector3FloatData *_wrap_btGeneric6DofConstraintData_m_angularUpperLimit_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_angularUpperLimit); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintData_m_angularLowerLimit_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_angularLowerLimit = *arg2; + +} + + +btVector3FloatData *_wrap_btGeneric6DofConstraintData_m_angularLowerLimit_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_angularLowerLimit); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintData_m_useLinearReferenceFrameA_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_useLinearReferenceFrameA = arg2; + +} + + +intgo _wrap_btGeneric6DofConstraintData_m_useLinearReferenceFrameA_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + + result = (int) ((arg1)->m_useLinearReferenceFrameA); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintData_m_useOffsetForConstraintFrame_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_useOffsetForConstraintFrame = arg2; + +} + + +intgo _wrap_btGeneric6DofConstraintData_m_useOffsetForConstraintFrame_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + + result = (int) ((arg1)->m_useOffsetForConstraintFrame); + _swig_go_result = result; + return _swig_go_result; +} + + +btGeneric6DofConstraintData *_wrap_new_btGeneric6DofConstraintData_mbt_e879218550ba2e2b() { + btGeneric6DofConstraintData *result = 0 ; + btGeneric6DofConstraintData *_swig_go_result; + + + result = (btGeneric6DofConstraintData *)new btGeneric6DofConstraintData(); + *(btGeneric6DofConstraintData **)&_swig_go_result = (btGeneric6DofConstraintData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btGeneric6DofConstraintData_mbt_e879218550ba2e2b(btGeneric6DofConstraintData *_swig_go_0) { + btGeneric6DofConstraintData *arg1 = (btGeneric6DofConstraintData *) 0 ; + + arg1 = *(btGeneric6DofConstraintData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btGeneric6DofConstraintDoubleData2_m_typeConstraintData_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0, btTypedConstraintDoubleData *_swig_go_1) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btTypedConstraintDoubleData *arg2 = (btTypedConstraintDoubleData *) 0 ; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(btTypedConstraintDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_typeConstraintData = *arg2; + +} + + +btTypedConstraintDoubleData *_wrap_btGeneric6DofConstraintDoubleData2_m_typeConstraintData_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btTypedConstraintDoubleData *result = 0 ; + btTypedConstraintDoubleData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + + result = (btTypedConstraintDoubleData *)& ((arg1)->m_typeConstraintData); + *(btTypedConstraintDoubleData **)&_swig_go_result = (btTypedConstraintDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintDoubleData2_m_rbAFrame_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0, btTransformDoubleData *_swig_go_1) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btTransformDoubleData *arg2 = (btTransformDoubleData *) 0 ; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(btTransformDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbAFrame = *arg2; + +} + + +btTransformDoubleData *_wrap_btGeneric6DofConstraintDoubleData2_m_rbAFrame_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btTransformDoubleData *result = 0 ; + btTransformDoubleData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + + result = (btTransformDoubleData *)& ((arg1)->m_rbAFrame); + *(btTransformDoubleData **)&_swig_go_result = (btTransformDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintDoubleData2_m_rbBFrame_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0, btTransformDoubleData *_swig_go_1) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btTransformDoubleData *arg2 = (btTransformDoubleData *) 0 ; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(btTransformDoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_rbBFrame = *arg2; + +} + + +btTransformDoubleData *_wrap_btGeneric6DofConstraintDoubleData2_m_rbBFrame_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btTransformDoubleData *result = 0 ; + btTransformDoubleData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + + result = (btTransformDoubleData *)& ((arg1)->m_rbBFrame); + *(btTransformDoubleData **)&_swig_go_result = (btTransformDoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintDoubleData2_m_linearUpperLimit_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_linearUpperLimit = *arg2; + +} + + +btVector3DoubleData *_wrap_btGeneric6DofConstraintDoubleData2_m_linearUpperLimit_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_linearUpperLimit); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintDoubleData2_m_linearLowerLimit_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_linearLowerLimit = *arg2; + +} + + +btVector3DoubleData *_wrap_btGeneric6DofConstraintDoubleData2_m_linearLowerLimit_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_linearLowerLimit); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintDoubleData2_m_angularUpperLimit_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_angularUpperLimit = *arg2; + +} + + +btVector3DoubleData *_wrap_btGeneric6DofConstraintDoubleData2_m_angularUpperLimit_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_angularUpperLimit); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintDoubleData2_m_angularLowerLimit_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0, btVector3DoubleData *_swig_go_1) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(btVector3DoubleData **)&_swig_go_1; + + if (arg1) (arg1)->m_angularLowerLimit = *arg2; + +} + + +btVector3DoubleData *_wrap_btGeneric6DofConstraintDoubleData2_m_angularLowerLimit_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + btVector3DoubleData *result = 0 ; + btVector3DoubleData *_swig_go_result; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + + result = (btVector3DoubleData *)& ((arg1)->m_angularLowerLimit); + *(btVector3DoubleData **)&_swig_go_result = (btVector3DoubleData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintDoubleData2_m_useLinearReferenceFrameA_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_useLinearReferenceFrameA = arg2; + +} + + +intgo _wrap_btGeneric6DofConstraintDoubleData2_m_useLinearReferenceFrameA_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + + result = (int) ((arg1)->m_useLinearReferenceFrameA); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofConstraintDoubleData2_m_useOffsetForConstraintFrame_set_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_useOffsetForConstraintFrame = arg2; + +} + + +intgo _wrap_btGeneric6DofConstraintDoubleData2_m_useOffsetForConstraintFrame_get_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + + result = (int) ((arg1)->m_useOffsetForConstraintFrame); + _swig_go_result = result; + return _swig_go_result; +} + + +btGeneric6DofConstraintDoubleData2 *_wrap_new_btGeneric6DofConstraintDoubleData2_mbt_e879218550ba2e2b() { + btGeneric6DofConstraintDoubleData2 *result = 0 ; + btGeneric6DofConstraintDoubleData2 *_swig_go_result; + + + result = (btGeneric6DofConstraintDoubleData2 *)new btGeneric6DofConstraintDoubleData2(); + *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_result = (btGeneric6DofConstraintDoubleData2 *)result; + return _swig_go_result; +} + + +void _wrap_delete_btGeneric6DofConstraintDoubleData2_mbt_e879218550ba2e2b(btGeneric6DofConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofConstraintDoubleData2 *arg1 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + + arg1 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_btGetConstraintIslandId_mbt_e879218550ba2e2b(btTypedConstraint *_swig_go_0) { + btTypedConstraint *arg1 = (btTypedConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btTypedConstraint **)&_swig_go_0; + + result = (int)btGetConstraintIslandId((btTypedConstraint const *)arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +btSortConstraintOnIslandPredicate *_wrap_new_btSortConstraintOnIslandPredicate_mbt_e879218550ba2e2b() { + btSortConstraintOnIslandPredicate *result = 0 ; + btSortConstraintOnIslandPredicate *_swig_go_result; + + + result = (btSortConstraintOnIslandPredicate *)new btSortConstraintOnIslandPredicate(); + *(btSortConstraintOnIslandPredicate **)&_swig_go_result = (btSortConstraintOnIslandPredicate *)result; + return _swig_go_result; +} + + +void _wrap_delete_btSortConstraintOnIslandPredicate_mbt_e879218550ba2e2b(btSortConstraintOnIslandPredicate *_swig_go_0) { + btSortConstraintOnIslandPredicate *arg1 = (btSortConstraintOnIslandPredicate *) 0 ; + + arg1 = *(btSortConstraintOnIslandPredicate **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_InplaceSolverIslandCallback_m_solverInfo_set_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, btContactSolverInfo *_swig_go_1) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btContactSolverInfo *arg2 = (btContactSolverInfo *) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = *(btContactSolverInfo **)&_swig_go_1; + + if (arg1) (arg1)->m_solverInfo = arg2; + +} + + +btContactSolverInfo *_wrap_InplaceSolverIslandCallback_m_solverInfo_get_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btContactSolverInfo *result = 0 ; + btContactSolverInfo *_swig_go_result; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + result = (btContactSolverInfo *) ((arg1)->m_solverInfo); + *(btContactSolverInfo **)&_swig_go_result = (btContactSolverInfo *)result; + return _swig_go_result; +} + + +void _wrap_InplaceSolverIslandCallback_m_solver_set_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, btConstraintSolver *_swig_go_1) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btConstraintSolver *arg2 = (btConstraintSolver *) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = *(btConstraintSolver **)&_swig_go_1; + + if (arg1) (arg1)->m_solver = arg2; + +} + + +btConstraintSolver *_wrap_InplaceSolverIslandCallback_m_solver_get_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btConstraintSolver *result = 0 ; + btConstraintSolver *_swig_go_result; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + result = (btConstraintSolver *) ((arg1)->m_solver); + *(btConstraintSolver **)&_swig_go_result = (btConstraintSolver *)result; + return _swig_go_result; +} + + +void _wrap_InplaceSolverIslandCallback_m_sortedConstraints_set_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, btTypedConstraint **_swig_go_1) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btTypedConstraint **arg2 = (btTypedConstraint **) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = *(btTypedConstraint ***)&_swig_go_1; + + if (arg1) (arg1)->m_sortedConstraints = arg2; + +} + + +btTypedConstraint **_wrap_InplaceSolverIslandCallback_m_sortedConstraints_get_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btTypedConstraint **result = 0 ; + btTypedConstraint **_swig_go_result; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + result = (btTypedConstraint **) ((arg1)->m_sortedConstraints); + *(btTypedConstraint ***)&_swig_go_result = (btTypedConstraint **)result; + return _swig_go_result; +} + + +void _wrap_InplaceSolverIslandCallback_m_numConstraints_set_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, intgo _swig_go_1) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + int arg2 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_numConstraints = arg2; + +} + + +intgo _wrap_InplaceSolverIslandCallback_m_numConstraints_get_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + result = (int) ((arg1)->m_numConstraints); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_InplaceSolverIslandCallback_m_debugDrawer_set_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, btIDebugDraw *_swig_go_1) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btIDebugDraw *arg2 = (btIDebugDraw *) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = *(btIDebugDraw **)&_swig_go_1; + + if (arg1) (arg1)->m_debugDrawer = arg2; + +} + + +btIDebugDraw *_wrap_InplaceSolverIslandCallback_m_debugDrawer_get_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btIDebugDraw *result = 0 ; + btIDebugDraw *_swig_go_result; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + result = (btIDebugDraw *) ((arg1)->m_debugDrawer); + *(btIDebugDraw **)&_swig_go_result = (btIDebugDraw *)result; + return _swig_go_result; +} + + +void _wrap_InplaceSolverIslandCallback_m_dispatcher_set_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, btDispatcher *_swig_go_1) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + if (arg1) (arg1)->m_dispatcher = arg2; + +} + + +btDispatcher *_wrap_InplaceSolverIslandCallback_m_dispatcher_get_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btDispatcher *result = 0 ; + btDispatcher *_swig_go_result; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + result = (btDispatcher *) ((arg1)->m_dispatcher); + *(btDispatcher **)&_swig_go_result = (btDispatcher *)result; + return _swig_go_result; +} + + +void _wrap_InplaceSolverIslandCallback_m_bodies_set_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, btAlignedObjectArray< btCollisionObject * > *_swig_go_1) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btAlignedObjectArray< btCollisionObject * > *arg2 = (btAlignedObjectArray< btCollisionObject * > *) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btCollisionObject * > **)&_swig_go_1; + + if (arg1) (arg1)->m_bodies = *arg2; + +} + + +btAlignedObjectArray< btCollisionObject * > *_wrap_InplaceSolverIslandCallback_m_bodies_get_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btAlignedObjectArray< btCollisionObject * > *result = 0 ; + btAlignedObjectArray< btCollisionObject * > *_swig_go_result; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + result = (btAlignedObjectArray< btCollisionObject * > *)& ((arg1)->m_bodies); + *(btAlignedObjectArray< btCollisionObject * > **)&_swig_go_result = (btAlignedObjectArray< btCollisionObject * > *)result; + return _swig_go_result; +} + + +void _wrap_InplaceSolverIslandCallback_m_manifolds_set_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btAlignedObjectArray< btPersistentManifold * > *arg2 = (btAlignedObjectArray< btPersistentManifold * > *) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btPersistentManifold * > **)&_swig_go_1; + + if (arg1) (arg1)->m_manifolds = *arg2; + +} + + +btAlignedObjectArray< btPersistentManifold * > *_wrap_InplaceSolverIslandCallback_m_manifolds_get_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btAlignedObjectArray< btPersistentManifold * > *result = 0 ; + btAlignedObjectArray< btPersistentManifold * > *_swig_go_result; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + result = (btAlignedObjectArray< btPersistentManifold * > *)& ((arg1)->m_manifolds); + *(btAlignedObjectArray< btPersistentManifold * > **)&_swig_go_result = (btAlignedObjectArray< btPersistentManifold * > *)result; + return _swig_go_result; +} + + +void _wrap_InplaceSolverIslandCallback_m_constraints_set_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, btAlignedObjectArray< btTypedConstraint * > *_swig_go_1) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btAlignedObjectArray< btTypedConstraint * > *arg2 = (btAlignedObjectArray< btTypedConstraint * > *) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btTypedConstraint * > **)&_swig_go_1; + + if (arg1) (arg1)->m_constraints = *arg2; + +} + + +btAlignedObjectArray< btTypedConstraint * > *_wrap_InplaceSolverIslandCallback_m_constraints_get_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btAlignedObjectArray< btTypedConstraint * > *result = 0 ; + btAlignedObjectArray< btTypedConstraint * > *_swig_go_result; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + result = (btAlignedObjectArray< btTypedConstraint * > *)& ((arg1)->m_constraints); + *(btAlignedObjectArray< btTypedConstraint * > **)&_swig_go_result = (btAlignedObjectArray< btTypedConstraint * > *)result; + return _swig_go_result; +} + + +InplaceSolverIslandCallback *_wrap_new_InplaceSolverIslandCallback_mbt_e879218550ba2e2b(btConstraintSolver *_swig_go_0, btStackAlloc *_swig_go_1, btDispatcher *_swig_go_2) { + btConstraintSolver *arg1 = (btConstraintSolver *) 0 ; + btStackAlloc *arg2 = (btStackAlloc *) 0 ; + btDispatcher *arg3 = (btDispatcher *) 0 ; + InplaceSolverIslandCallback *result = 0 ; + InplaceSolverIslandCallback *_swig_go_result; + + arg1 = *(btConstraintSolver **)&_swig_go_0; + arg2 = *(btStackAlloc **)&_swig_go_1; + arg3 = *(btDispatcher **)&_swig_go_2; + + result = (InplaceSolverIslandCallback *)new InplaceSolverIslandCallback(arg1,arg2,arg3); + *(InplaceSolverIslandCallback **)&_swig_go_result = (InplaceSolverIslandCallback *)result; + return _swig_go_result; +} + + +void _wrap_InplaceSolverIslandCallback_setup_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, btContactSolverInfo *_swig_go_1, btTypedConstraint **_swig_go_2, intgo _swig_go_3, btIDebugDraw *_swig_go_4) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btContactSolverInfo *arg2 = (btContactSolverInfo *) 0 ; + btTypedConstraint **arg3 = (btTypedConstraint **) 0 ; + int arg4 ; + btIDebugDraw *arg5 = (btIDebugDraw *) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = *(btContactSolverInfo **)&_swig_go_1; + arg3 = *(btTypedConstraint ***)&_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btIDebugDraw **)&_swig_go_4; + + (arg1)->setup(arg2,arg3,arg4,arg5); + +} + + +void _wrap_InplaceSolverIslandCallback_processIsland_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0, btCollisionObject **_swig_go_1, intgo _swig_go_2, btPersistentManifold **_swig_go_3, intgo _swig_go_4, intgo _swig_go_5) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + btCollisionObject **arg2 = (btCollisionObject **) 0 ; + int arg3 ; + btPersistentManifold **arg4 = (btPersistentManifold **) 0 ; + int arg5 ; + int arg6 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + arg2 = *(btCollisionObject ***)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = *(btPersistentManifold ***)&_swig_go_3; + arg5 = (int)_swig_go_4; + arg6 = (int)_swig_go_5; + + (arg1)->processIsland(arg2,arg3,arg4,arg5,arg6); + +} + + +void _wrap_InplaceSolverIslandCallback_processConstraints_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + (arg1)->processConstraints(); + +} + + +void _wrap_delete_InplaceSolverIslandCallback_mbt_e879218550ba2e2b(InplaceSolverIslandCallback *_swig_go_0) { + InplaceSolverIslandCallback *arg1 = (InplaceSolverIslandCallback *) 0 ; + + arg1 = *(InplaceSolverIslandCallback **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btClosestNotMeConvexResultCallback_m_me_set_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0, btCollisionObject *_swig_go_1) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + + if (arg1) (arg1)->m_me = arg2; + +} + + +btCollisionObject *_wrap_btClosestNotMeConvexResultCallback_m_me_get_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + btCollisionObject *result = 0 ; + btCollisionObject *_swig_go_result; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + + result = (btCollisionObject *) ((arg1)->m_me); + *(btCollisionObject **)&_swig_go_result = (btCollisionObject *)result; + return _swig_go_result; +} + + +void _wrap_btClosestNotMeConvexResultCallback_m_allowedPenetration_set_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0, float _swig_go_1) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + btScalar arg2 ; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_allowedPenetration = arg2; + +} + + +float _wrap_btClosestNotMeConvexResultCallback_m_allowedPenetration_get_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_allowedPenetration); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btClosestNotMeConvexResultCallback_m_pairCache_set_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0, btOverlappingPairCache *_swig_go_1) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + btOverlappingPairCache *arg2 = (btOverlappingPairCache *) 0 ; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + arg2 = *(btOverlappingPairCache **)&_swig_go_1; + + if (arg1) (arg1)->m_pairCache = arg2; + +} + + +btOverlappingPairCache *_wrap_btClosestNotMeConvexResultCallback_m_pairCache_get_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + btOverlappingPairCache *result = 0 ; + btOverlappingPairCache *_swig_go_result; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + + result = (btOverlappingPairCache *) ((arg1)->m_pairCache); + *(btOverlappingPairCache **)&_swig_go_result = (btOverlappingPairCache *)result; + return _swig_go_result; +} + + +void _wrap_btClosestNotMeConvexResultCallback_m_dispatcher_set_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0, btDispatcher *_swig_go_1) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + if (arg1) (arg1)->m_dispatcher = arg2; + +} + + +btDispatcher *_wrap_btClosestNotMeConvexResultCallback_m_dispatcher_get_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + btDispatcher *result = 0 ; + btDispatcher *_swig_go_result; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + + result = (btDispatcher *) ((arg1)->m_dispatcher); + *(btDispatcher **)&_swig_go_result = (btDispatcher *)result; + return _swig_go_result; +} + + +btClosestNotMeConvexResultCallback *_wrap_new_btClosestNotMeConvexResultCallback_mbt_e879218550ba2e2b(btCollisionObject *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btOverlappingPairCache *_swig_go_3, btDispatcher *_swig_go_4) { + btCollisionObject *arg1 = (btCollisionObject *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btOverlappingPairCache *arg4 = (btOverlappingPairCache *) 0 ; + btDispatcher *arg5 = (btDispatcher *) 0 ; + btClosestNotMeConvexResultCallback *result = 0 ; + btClosestNotMeConvexResultCallback *_swig_go_result; + + arg1 = *(btCollisionObject **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btOverlappingPairCache **)&_swig_go_3; + arg5 = *(btDispatcher **)&_swig_go_4; + + result = (btClosestNotMeConvexResultCallback *)new btClosestNotMeConvexResultCallback(arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5); + *(btClosestNotMeConvexResultCallback **)&_swig_go_result = (btClosestNotMeConvexResultCallback *)result; + return _swig_go_result; +} + + +float _wrap_btClosestNotMeConvexResultCallback_addSingleResult_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0, btCollisionWorld::LocalConvexResult *_swig_go_1, bool _swig_go_2) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + btCollisionWorld::LocalConvexResult *arg2 = 0 ; + bool arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + arg2 = *(btCollisionWorld::LocalConvexResult **)&_swig_go_1; + arg3 = (bool)_swig_go_2; + + result = (btScalar)(arg1)->addSingleResult(*arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btClosestNotMeConvexResultCallback_needsCollision_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0, btBroadphaseProxy *_swig_go_1) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + arg2 = *(btBroadphaseProxy **)&_swig_go_1; + + result = (bool)((btClosestNotMeConvexResultCallback const *)arg1)->needsCollision(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btClosestNotMeConvexResultCallback_mbt_e879218550ba2e2b(btClosestNotMeConvexResultCallback *_swig_go_0) { + btClosestNotMeConvexResultCallback *arg1 = (btClosestNotMeConvexResultCallback *) 0 ; + + arg1 = *(btClosestNotMeConvexResultCallback **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_gNumClampedCcdMotions_set_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + + arg1 = (int)_swig_go_0; + + gNumClampedCcdMotions = arg1; + +} + + +intgo _wrap_gNumClampedCcdMotions_get_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)gNumClampedCcdMotions; + _swig_go_result = result; + return _swig_go_result; +} + + +btUnionFindElementSortPredicate *_wrap_new_btUnionFindElementSortPredicate_mbt_e879218550ba2e2b() { + btUnionFindElementSortPredicate *result = 0 ; + btUnionFindElementSortPredicate *_swig_go_result; + + + result = (btUnionFindElementSortPredicate *)new btUnionFindElementSortPredicate(); + *(btUnionFindElementSortPredicate **)&_swig_go_result = (btUnionFindElementSortPredicate *)result; + return _swig_go_result; +} + + +void _wrap_delete_btUnionFindElementSortPredicate_mbt_e879218550ba2e2b(btUnionFindElementSortPredicate *_swig_go_0) { + btUnionFindElementSortPredicate *arg1 = (btUnionFindElementSortPredicate *) 0 ; + + arg1 = *(btUnionFindElementSortPredicate **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_getIslandId_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + + result = (int)getIslandId((btPersistentManifold const *)arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +btPersistentManifoldSortPredicate *_wrap_new_btPersistentManifoldSortPredicate_mbt_e879218550ba2e2b() { + btPersistentManifoldSortPredicate *result = 0 ; + btPersistentManifoldSortPredicate *_swig_go_result; + + + result = (btPersistentManifoldSortPredicate *)new btPersistentManifoldSortPredicate(); + *(btPersistentManifoldSortPredicate **)&_swig_go_result = (btPersistentManifoldSortPredicate *)result; + return _swig_go_result; +} + + +void _wrap_delete_btPersistentManifoldSortPredicate_mbt_e879218550ba2e2b(btPersistentManifoldSortPredicate *_swig_go_0) { + btPersistentManifoldSortPredicate *arg1 = (btPersistentManifoldSortPredicate *) 0 ; + + arg1 = *(btPersistentManifoldSortPredicate **)&_swig_go_0; + + delete arg1; + +} + + +btPersistentManifoldSortPredicateDeterministic *_wrap_new_btPersistentManifoldSortPredicateDeterministic_mbt_e879218550ba2e2b() { + btPersistentManifoldSortPredicateDeterministic *result = 0 ; + btPersistentManifoldSortPredicateDeterministic *_swig_go_result; + + + result = (btPersistentManifoldSortPredicateDeterministic *)new btPersistentManifoldSortPredicateDeterministic(); + *(btPersistentManifoldSortPredicateDeterministic **)&_swig_go_result = (btPersistentManifoldSortPredicateDeterministic *)result; + return _swig_go_result; +} + + +void _wrap_delete_btPersistentManifoldSortPredicateDeterministic_mbt_e879218550ba2e2b(btPersistentManifoldSortPredicateDeterministic *_swig_go_0) { + btPersistentManifoldSortPredicateDeterministic *arg1 = (btPersistentManifoldSortPredicateDeterministic *) 0 ; + + arg1 = *(btPersistentManifoldSortPredicateDeterministic **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btGjkPairDetector_m_lastUsedMethod_set_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, intgo _swig_go_1) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + int arg2 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_lastUsedMethod = arg2; + +} + + +intgo _wrap_btGjkPairDetector_m_lastUsedMethod_get_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + + result = (int) ((arg1)->m_lastUsedMethod); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGjkPairDetector_m_curIter_set_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, intgo _swig_go_1) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + int arg2 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_curIter = arg2; + +} + + +intgo _wrap_btGjkPairDetector_m_curIter_get_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + + result = (int) ((arg1)->m_curIter); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGjkPairDetector_m_degenerateSimplex_set_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, intgo _swig_go_1) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + int arg2 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_degenerateSimplex = arg2; + +} + + +intgo _wrap_btGjkPairDetector_m_degenerateSimplex_get_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + + result = (int) ((arg1)->m_degenerateSimplex); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGjkPairDetector_m_catchDegeneracies_set_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, intgo _swig_go_1) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + int arg2 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_catchDegeneracies = arg2; + +} + + +intgo _wrap_btGjkPairDetector_m_catchDegeneracies_get_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + + result = (int) ((arg1)->m_catchDegeneracies); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGjkPairDetector_m_fixContactNormalDirection_set_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, intgo _swig_go_1) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + int arg2 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_fixContactNormalDirection = arg2; + +} + + +intgo _wrap_btGjkPairDetector_m_fixContactNormalDirection_get_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + + result = (int) ((arg1)->m_fixContactNormalDirection); + _swig_go_result = result; + return _swig_go_result; +} + + +btGjkPairDetector *_wrap_new_btGjkPairDetector__SWIG_0_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btConvexShape *_swig_go_1, btVoronoiSimplexSolver *_swig_go_2, btConvexPenetrationDepthSolver *_swig_go_3) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + btVoronoiSimplexSolver *arg3 = (btVoronoiSimplexSolver *) 0 ; + btConvexPenetrationDepthSolver *arg4 = (btConvexPenetrationDepthSolver *) 0 ; + btGjkPairDetector *result = 0 ; + btGjkPairDetector *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = *(btVoronoiSimplexSolver **)&_swig_go_2; + arg4 = *(btConvexPenetrationDepthSolver **)&_swig_go_3; + + result = (btGjkPairDetector *)new btGjkPairDetector((btConvexShape const *)arg1,(btConvexShape const *)arg2,arg3,arg4); + *(btGjkPairDetector **)&_swig_go_result = (btGjkPairDetector *)result; + return _swig_go_result; +} + + +btGjkPairDetector *_wrap_new_btGjkPairDetector__SWIG_1_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btConvexShape *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3, float _swig_go_4, float _swig_go_5, btVoronoiSimplexSolver *_swig_go_6, btConvexPenetrationDepthSolver *_swig_go_7) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + int arg3 ; + int arg4 ; + btScalar arg5 ; + btScalar arg6 ; + btVoronoiSimplexSolver *arg7 = (btVoronoiSimplexSolver *) 0 ; + btConvexPenetrationDepthSolver *arg8 = (btConvexPenetrationDepthSolver *) 0 ; + btGjkPairDetector *result = 0 ; + btGjkPairDetector *_swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = *(btVoronoiSimplexSolver **)&_swig_go_6; + arg8 = *(btConvexPenetrationDepthSolver **)&_swig_go_7; + + result = (btGjkPairDetector *)new btGjkPairDetector((btConvexShape const *)arg1,(btConvexShape const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); + *(btGjkPairDetector **)&_swig_go_result = (btGjkPairDetector *)result; + return _swig_go_result; +} + + +void _wrap_delete_btGjkPairDetector_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btGjkPairDetector_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, btDiscreteCollisionDetectorInterface::ClosestPointInput *_swig_go_1, btDiscreteCollisionDetectorInterface::Result *_swig_go_2, btIDebugDraw *_swig_go_3, bool _swig_go_4) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; + btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; + bool arg5 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&_swig_go_1; + arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_2; + arg4 = *(btIDebugDraw **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + + (arg1)->getClosestPoints((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4,arg5); + +} + + +void _wrap_btGjkPairDetector_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, btDiscreteCollisionDetectorInterface::ClosestPointInput *_swig_go_1, btDiscreteCollisionDetectorInterface::Result *_swig_go_2, btIDebugDraw *_swig_go_3) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; + btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&_swig_go_1; + arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_2; + arg4 = *(btIDebugDraw **)&_swig_go_3; + + (arg1)->getClosestPoints((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4); + +} + + +void _wrap_btGjkPairDetector_getClosestPointsNonVirtual_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, btDiscreteCollisionDetectorInterface::ClosestPointInput *_swig_go_1, btDiscreteCollisionDetectorInterface::Result *_swig_go_2, btIDebugDraw *_swig_go_3) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; + btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&_swig_go_1; + arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_2; + arg4 = *(btIDebugDraw **)&_swig_go_3; + + (arg1)->getClosestPointsNonVirtual((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4); + +} + + +void _wrap_btGjkPairDetector_setMinkowskiA_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, btConvexShape *_swig_go_1) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + + (arg1)->setMinkowskiA((btConvexShape const *)arg2); + +} + + +void _wrap_btGjkPairDetector_setMinkowskiB_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, btConvexShape *_swig_go_1) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + btConvexShape *arg2 = (btConvexShape *) 0 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = *(btConvexShape **)&_swig_go_1; + + (arg1)->setMinkowskiB((btConvexShape const *)arg2); + +} + + +void _wrap_btGjkPairDetector_setCachedSeparatingAxis_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, btVector3 *_swig_go_1) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setCachedSeparatingAxis((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btGjkPairDetector_getCachedSeparatingAxis_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + + result = (btVector3 *) &((btGjkPairDetector const *)arg1)->getCachedSeparatingAxis(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGjkPairDetector_getCachedSeparatingDistance_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + + result = (btScalar)((btGjkPairDetector const *)arg1)->getCachedSeparatingDistance(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGjkPairDetector_setPenetrationDepthSolver_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, btConvexPenetrationDepthSolver *_swig_go_1) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + btConvexPenetrationDepthSolver *arg2 = (btConvexPenetrationDepthSolver *) 0 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = *(btConvexPenetrationDepthSolver **)&_swig_go_1; + + (arg1)->setPenetrationDepthSolver(arg2); + +} + + +void _wrap_btGjkPairDetector_setIgnoreMargin_mbt_e879218550ba2e2b(btGjkPairDetector *_swig_go_0, bool _swig_go_1) { + btGjkPairDetector *arg1 = (btGjkPairDetector *) 0 ; + bool arg2 ; + + arg1 = *(btGjkPairDetector **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setIgnoreMargin(arg2); + +} + + +void _wrap_SupportVertexCallback_m_worldTrans_set_mbt_e879218550ba2e2b(SupportVertexCallback *_swig_go_0, btTransform *_swig_go_1) { + SupportVertexCallback *arg1 = (SupportVertexCallback *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(SupportVertexCallback **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_worldTrans = *arg2; + +} + + +btTransform *_wrap_SupportVertexCallback_m_worldTrans_get_mbt_e879218550ba2e2b(SupportVertexCallback *_swig_go_0) { + SupportVertexCallback *arg1 = (SupportVertexCallback *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(SupportVertexCallback **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_worldTrans); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_SupportVertexCallback_m_maxDot_set_mbt_e879218550ba2e2b(SupportVertexCallback *_swig_go_0, float _swig_go_1) { + SupportVertexCallback *arg1 = (SupportVertexCallback *) 0 ; + btScalar arg2 ; + + arg1 = *(SupportVertexCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_maxDot = arg2; + +} + + +float _wrap_SupportVertexCallback_m_maxDot_get_mbt_e879218550ba2e2b(SupportVertexCallback *_swig_go_0) { + SupportVertexCallback *arg1 = (SupportVertexCallback *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(SupportVertexCallback **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_maxDot); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SupportVertexCallback_m_supportVecLocal_set_mbt_e879218550ba2e2b(SupportVertexCallback *_swig_go_0, btVector3 *_swig_go_1) { + SupportVertexCallback *arg1 = (SupportVertexCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(SupportVertexCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_supportVecLocal = *arg2; + +} + + +btVector3 *_wrap_SupportVertexCallback_m_supportVecLocal_get_mbt_e879218550ba2e2b(SupportVertexCallback *_swig_go_0) { + SupportVertexCallback *arg1 = (SupportVertexCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(SupportVertexCallback **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_supportVecLocal); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +SupportVertexCallback *_wrap_new_SupportVertexCallback_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btTransform *_swig_go_1) { + btVector3 *arg1 = 0 ; + btTransform *arg2 = 0 ; + SupportVertexCallback *result = 0 ; + SupportVertexCallback *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + result = (SupportVertexCallback *)new SupportVertexCallback((btVector3 const &)*arg1,(btTransform const &)*arg2); + *(SupportVertexCallback **)&_swig_go_result = (SupportVertexCallback *)result; + return _swig_go_result; +} + + +void _wrap_SupportVertexCallback_processTriangle_mbt_e879218550ba2e2b(SupportVertexCallback *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + SupportVertexCallback *arg1 = (SupportVertexCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(SupportVertexCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->processTriangle(arg2,arg3,arg4); + +} + + +btVector3 *_wrap_SupportVertexCallback_GetSupportVertexWorldSpace_mbt_e879218550ba2e2b(SupportVertexCallback *_swig_go_0) { + SupportVertexCallback *arg1 = (SupportVertexCallback *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(SupportVertexCallback **)&_swig_go_0; + + result = (arg1)->GetSupportVertexWorldSpace(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_SupportVertexCallback_GetSupportVertexLocal_mbt_e879218550ba2e2b(SupportVertexCallback *_swig_go_0) { + SupportVertexCallback *arg1 = (SupportVertexCallback *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(SupportVertexCallback **)&_swig_go_0; + + result = (arg1)->GetSupportVertexLocal(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_delete_SupportVertexCallback_mbt_e879218550ba2e2b(SupportVertexCallback *_swig_go_0) { + SupportVertexCallback *arg1 = (SupportVertexCallback *) 0 ; + + arg1 = *(SupportVertexCallback **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_getQuantized_mbt_e879218550ba2e2b(float _swig_go_0) { + btScalar arg1 ; + int result; + intgo _swig_go_result; + + arg1 = (btScalar)_swig_go_0; + + result = (int)getQuantized(arg1); + _swig_go_result = result; + return _swig_go_result; +} + + +btHeightfieldTerrainShape::Range *_wrap_minmaxRange_mbt_e879218550ba2e2b(float _swig_go_0, float _swig_go_1, float _swig_go_2) { + btScalar arg1 ; + btScalar arg2 ; + btScalar arg3 ; + btHeightfieldTerrainShape::Range result; + btHeightfieldTerrainShape::Range *_swig_go_result; + + arg1 = (btScalar)_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = minmaxRange(arg1,arg2,arg3); + *(btHeightfieldTerrainShape::Range **)&_swig_go_result = new btHeightfieldTerrainShape::Range(result); + return _swig_go_result; +} + + +void _wrap_ProcessTrianglesAction_shape_set_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0, btHeightfieldTerrainShape *_swig_go_1) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + btHeightfieldTerrainShape *arg2 = (btHeightfieldTerrainShape *) 0 ; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + arg2 = *(btHeightfieldTerrainShape **)&_swig_go_1; + + if (arg1) (arg1)->shape = (btHeightfieldTerrainShape const *)arg2; + +} + + +btHeightfieldTerrainShape *_wrap_ProcessTrianglesAction_shape_get_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + btHeightfieldTerrainShape *result = 0 ; + btHeightfieldTerrainShape *_swig_go_result; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + + result = (btHeightfieldTerrainShape *) ((arg1)->shape); + *(btHeightfieldTerrainShape **)&_swig_go_result = (btHeightfieldTerrainShape *)result; + return _swig_go_result; +} + + +void _wrap_ProcessTrianglesAction_flipQuadEdges_set_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0, bool _swig_go_1) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + bool arg2 ; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->flipQuadEdges = arg2; + +} + + +bool _wrap_ProcessTrianglesAction_flipQuadEdges_get_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + + result = (bool) ((arg1)->flipQuadEdges); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_ProcessTrianglesAction_useDiamondSubdivision_set_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0, bool _swig_go_1) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + bool arg2 ; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->useDiamondSubdivision = arg2; + +} + + +bool _wrap_ProcessTrianglesAction_useDiamondSubdivision_get_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + + result = (bool) ((arg1)->useDiamondSubdivision); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_ProcessTrianglesAction_width_set_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0, intgo _swig_go_1) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + int arg2 ; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->width = arg2; + +} + + +intgo _wrap_ProcessTrianglesAction_width_get_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + + result = (int) ((arg1)->width); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_ProcessTrianglesAction_length_set_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0, intgo _swig_go_1) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + int arg2 ; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->length = arg2; + +} + + +intgo _wrap_ProcessTrianglesAction_length_get_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + + result = (int) ((arg1)->length); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_ProcessTrianglesAction_callback_set_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0, btTriangleCallback *_swig_go_1) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + btTriangleCallback *arg2 = (btTriangleCallback *) 0 ; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + arg2 = *(btTriangleCallback **)&_swig_go_1; + + if (arg1) (arg1)->callback = arg2; + +} + + +btTriangleCallback *_wrap_ProcessTrianglesAction_callback_get_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + btTriangleCallback *result = 0 ; + btTriangleCallback *_swig_go_result; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + + result = (btTriangleCallback *) ((arg1)->callback); + *(btTriangleCallback **)&_swig_go_result = (btTriangleCallback *)result; + return _swig_go_result; +} + + +void _wrap_ProcessTrianglesAction_exec_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + ((ProcessTrianglesAction const *)arg1)->exec(arg2,arg3); + +} + + +ProcessTrianglesAction *_wrap_new_ProcessTrianglesAction_mbt_e879218550ba2e2b() { + ProcessTrianglesAction *result = 0 ; + ProcessTrianglesAction *_swig_go_result; + + + result = (ProcessTrianglesAction *)new ProcessTrianglesAction(); + *(ProcessTrianglesAction **)&_swig_go_result = (ProcessTrianglesAction *)result; + return _swig_go_result; +} + + +void _wrap_delete_ProcessTrianglesAction_mbt_e879218550ba2e2b(ProcessTrianglesAction *_swig_go_0) { + ProcessTrianglesAction *arg1 = (ProcessTrianglesAction *) 0 ; + + arg1 = *(ProcessTrianglesAction **)&_swig_go_0; + + delete arg1; + +} + + +btAlignedObjectArray< btHeightfieldTerrainShape::Range > *_wrap_ProcessVBoundsAction_vbounds_get_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + btAlignedObjectArray< btHeightfieldTerrainShape::Range > *result = 0 ; + btAlignedObjectArray< btHeightfieldTerrainShape::Range > *_swig_go_result; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + + result = (btAlignedObjectArray< btHeightfieldTerrainShape::Range > *) &(btAlignedObjectArray< btHeightfieldTerrainShape::Range > const &) ((arg1)->vbounds); + *(btAlignedObjectArray< btHeightfieldTerrainShape::Range > **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_ProcessVBoundsAction_width_set_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0, intgo _swig_go_1) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + int arg2 ; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->width = arg2; + +} + + +intgo _wrap_ProcessVBoundsAction_width_get_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + + result = (int) ((arg1)->width); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_ProcessVBoundsAction_length_set_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0, intgo _swig_go_1) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + int arg2 ; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->length = arg2; + +} + + +intgo _wrap_ProcessVBoundsAction_length_get_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + + result = (int) ((arg1)->length); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_ProcessVBoundsAction_chunkSize_set_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0, intgo _swig_go_1) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + int arg2 ; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->chunkSize = arg2; + +} + + +intgo _wrap_ProcessVBoundsAction_chunkSize_get_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + + result = (int) ((arg1)->chunkSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_ProcessVBoundsAction_rayBegin_set_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0, btVector3 *_swig_go_1) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->rayBegin = *arg2; + +} + + +btVector3 *_wrap_ProcessVBoundsAction_rayBegin_get_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->rayBegin); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_ProcessVBoundsAction_rayEnd_set_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0, btVector3 *_swig_go_1) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->rayEnd = *arg2; + +} + + +btVector3 *_wrap_ProcessVBoundsAction_rayEnd_get_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->rayEnd); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_ProcessVBoundsAction_rayDir_set_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0, btVector3 *_swig_go_1) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->rayDir = *arg2; + +} + + +btVector3 *_wrap_ProcessVBoundsAction_rayDir_get_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->rayDir); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_ProcessVBoundsAction_m_indices_set_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0, intgo *_swig_go_1) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + int *arg2 = (int *) 0 ; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + if (arg1) (arg1)->m_indices = arg2; + +} + + +intgo *_wrap_ProcessVBoundsAction_m_indices_get_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + + result = (int *) ((arg1)->m_indices); + *(int **)&_swig_go_result = (int *)result; + return _swig_go_result; +} + + +void _wrap_ProcessVBoundsAction_processTriangles_set_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0, ProcessTrianglesAction *_swig_go_1) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + ProcessTrianglesAction *arg2 = (ProcessTrianglesAction *) 0 ; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + arg2 = *(ProcessTrianglesAction **)&_swig_go_1; + + if (arg1) (arg1)->processTriangles = *arg2; + +} + + +ProcessTrianglesAction *_wrap_ProcessVBoundsAction_processTriangles_get_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + ProcessTrianglesAction *result = 0 ; + ProcessTrianglesAction *_swig_go_result; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + + result = (ProcessTrianglesAction *)& ((arg1)->processTriangles); + *(ProcessTrianglesAction **)&_swig_go_result = (ProcessTrianglesAction *)result; + return _swig_go_result; +} + + +ProcessVBoundsAction *_wrap_new_ProcessVBoundsAction_mbt_e879218550ba2e2b(btAlignedObjectArray< btHeightfieldTerrainShape::Range > *_swig_go_0, intgo *_swig_go_1) { + btAlignedObjectArray< btHeightfieldTerrainShape::Range > *arg1 = 0 ; + int *arg2 = (int *) 0 ; + ProcessVBoundsAction *result = 0 ; + ProcessVBoundsAction *_swig_go_result; + + arg1 = *(btAlignedObjectArray< btHeightfieldTerrainShape::Range > **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + result = (ProcessVBoundsAction *)new ProcessVBoundsAction((btAlignedObjectArray< btHeightfieldTerrainShape::Range > const &)*arg1,arg2); + *(ProcessVBoundsAction **)&_swig_go_result = (ProcessVBoundsAction *)result; + return _swig_go_result; +} + + +void _wrap_delete_ProcessVBoundsAction_mbt_e879218550ba2e2b(ProcessVBoundsAction *_swig_go_0) { + ProcessVBoundsAction *arg1 = (ProcessVBoundsAction *) 0 ; + + arg1 = *(ProcessVBoundsAction **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_btGjkEpaSolver2_StackSizeRequirement_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)btGjkEpaSolver2::StackSizeRequirement(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btGjkEpaSolver2_Distance_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btConvexShape *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btGjkEpaSolver2::sResults *_swig_go_5) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btConvexShape *arg3 = (btConvexShape *) 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btGjkEpaSolver2::sResults *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btConvexShape **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btGjkEpaSolver2::sResults **)&_swig_go_5; + + result = (bool)btGjkEpaSolver2::Distance((btConvexShape const *)arg1,(btTransform const &)*arg2,(btConvexShape const *)arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btGjkEpaSolver2_Penetration__SWIG_0_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btConvexShape *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btGjkEpaSolver2::sResults *_swig_go_5, bool _swig_go_6) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btConvexShape *arg3 = (btConvexShape *) 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btGjkEpaSolver2::sResults *arg6 = 0 ; + bool arg7 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btConvexShape **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btGjkEpaSolver2::sResults **)&_swig_go_5; + arg7 = (bool)_swig_go_6; + + result = (bool)btGjkEpaSolver2::Penetration((btConvexShape const *)arg1,(btTransform const &)*arg2,(btConvexShape const *)arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5,*arg6,arg7); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btGjkEpaSolver2_Penetration__SWIG_1_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btConvexShape *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btGjkEpaSolver2::sResults *_swig_go_5) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btConvexShape *arg3 = (btConvexShape *) 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btGjkEpaSolver2::sResults *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btConvexShape **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btGjkEpaSolver2::sResults **)&_swig_go_5; + + result = (bool)btGjkEpaSolver2::Penetration((btConvexShape const *)arg1,(btTransform const &)*arg2,(btConvexShape const *)arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGjkEpaSolver2_SignedDistance__SWIG_0_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float _swig_go_1, btConvexShape *_swig_go_2, btTransform *_swig_go_3, btGjkEpaSolver2::sResults *_swig_go_4) { + btVector3 *arg1 = 0 ; + btScalar arg2 ; + btConvexShape *arg3 = (btConvexShape *) 0 ; + btTransform *arg4 = 0 ; + btGjkEpaSolver2::sResults *arg5 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btConvexShape **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btGjkEpaSolver2::sResults **)&_swig_go_4; + + result = (btScalar)btGjkEpaSolver2::SignedDistance((btVector3 const &)*arg1,arg2,(btConvexShape const *)arg3,(btTransform const &)*arg4,*arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btGjkEpaSolver2_SignedDistance__SWIG_1_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btConvexShape *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btGjkEpaSolver2::sResults *_swig_go_5) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btConvexShape *arg3 = (btConvexShape *) 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btGjkEpaSolver2::sResults *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btConvexShape **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btGjkEpaSolver2::sResults **)&_swig_go_5; + + result = (bool)btGjkEpaSolver2::SignedDistance((btConvexShape const *)arg1,(btTransform const &)*arg2,(btConvexShape const *)arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +btGjkEpaSolver2 *_wrap_new_btGjkEpaSolver2_mbt_e879218550ba2e2b() { + btGjkEpaSolver2 *result = 0 ; + btGjkEpaSolver2 *_swig_go_result; + + + result = (btGjkEpaSolver2 *)new btGjkEpaSolver2(); + *(btGjkEpaSolver2 **)&_swig_go_result = (btGjkEpaSolver2 *)result; + return _swig_go_result; +} + + +void _wrap_delete_btGjkEpaSolver2_mbt_e879218550ba2e2b(btGjkEpaSolver2 *_swig_go_0) { + btGjkEpaSolver2 *arg1 = (btGjkEpaSolver2 *) 0 ; + + arg1 = *(btGjkEpaSolver2 **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_EPA_MAX_FACES_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)((128*2)); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_MinkowskiDiff_m_shapes_set_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0, btConvexShape *(*_swig_go_1)[2]) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btConvexShape **arg2 = (btConvexShape **) (btConvexShape **)0 ; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + arg2 = *(btConvexShape ***)&_swig_go_1; + + { + size_t ii; + btConvexShape const * *b = (btConvexShape const * *) arg1->m_shapes; + for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((btConvexShape const * *) arg2 + ii); + } + +} + + +btConvexShape *(*_wrap_MinkowskiDiff_m_shapes_get_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0))[2] { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btConvexShape **result = 0 ; + btConvexShape *(*_swig_go_result)[2]; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + + result = (btConvexShape **)(btConvexShape **) ((arg1)->m_shapes); + *(btConvexShape ***)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_MinkowskiDiff_m_toshape1_set_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0, btMatrix3x3 *_swig_go_1) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btMatrix3x3 *arg2 = (btMatrix3x3 *) 0 ; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + arg2 = *(btMatrix3x3 **)&_swig_go_1; + + if (arg1) (arg1)->m_toshape1 = *arg2; + +} + + +btMatrix3x3 *_wrap_MinkowskiDiff_m_toshape1_get_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btMatrix3x3 *result = 0 ; + btMatrix3x3 *_swig_go_result; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + + result = (btMatrix3x3 *)& ((arg1)->m_toshape1); + *(btMatrix3x3 **)&_swig_go_result = (btMatrix3x3 *)result; + return _swig_go_result; +} + + +void _wrap_MinkowskiDiff_m_toshape0_set_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0, btTransform *_swig_go_1) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btTransform *arg2 = (btTransform *) 0 ; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + + if (arg1) (arg1)->m_toshape0 = *arg2; + +} + + +btTransform *_wrap_MinkowskiDiff_m_toshape0_get_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + + result = (btTransform *)& ((arg1)->m_toshape0); + *(btTransform **)&_swig_go_result = (btTransform *)result; + return _swig_go_result; +} + + +void _wrap_MinkowskiDiff_Ls_set_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0, void* _swig_go_1) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btVector3 (btConvexShape::*arg2)(btVector3 const &) const ; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + arg2 = *(btVector3 (btConvexShape::**)(btVector3 const &) const)_swig_go_1; + + if (arg1) (arg1)->Ls = (btVector3 (btConvexShape::*)(btVector3 const &) const)arg2; + +} + + +void* _wrap_MinkowskiDiff_Ls_get_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btVector3 (btConvexShape::*result)(btVector3 const &) const; + void* _swig_go_result; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + + result = (btVector3 (btConvexShape::*)(btVector3 const &) const) ((arg1)->Ls); + + struct swig_out_type { + intgo size; void* val; + } *swig_out; + swig_out = (struct swig_out_type*)malloc(sizeof(*swig_out)); + if (swig_out) { + swig_out->size = sizeof(btVector3 (btConvexShape::*)(btVector3 const &) const); + swig_out->val = malloc(swig_out->size); + if (swig_out->val) { + *(btVector3 (btConvexShape::**)(btVector3 const &) const)(swig_out->val) = result; + } + } + _swig_go_result = swig_out; + + return _swig_go_result; +} + + +gjkepa2_impl::MinkowskiDiff *_wrap_new_MinkowskiDiff_mbt_e879218550ba2e2b() { + gjkepa2_impl::MinkowskiDiff *result = 0 ; + gjkepa2_impl::MinkowskiDiff *_swig_go_result; + + + result = (gjkepa2_impl::MinkowskiDiff *)new gjkepa2_impl::MinkowskiDiff(); + *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_result = (gjkepa2_impl::MinkowskiDiff *)result; + return _swig_go_result; +} + + +void _wrap_MinkowskiDiff_EnableMargin_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0, bool _swig_go_1) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + bool arg2 ; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->EnableMargin(arg2); + +} + + +btVector3 *_wrap_MinkowskiDiff_Support0_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0, btVector3 *_swig_go_1) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((gjkepa2_impl::MinkowskiDiff const *)arg1)->Support0((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_MinkowskiDiff_Support1_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0, btVector3 *_swig_go_1) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((gjkepa2_impl::MinkowskiDiff const *)arg1)->Support1((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_MinkowskiDiff_Support__SWIG_0_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0, btVector3 *_swig_go_1) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((gjkepa2_impl::MinkowskiDiff const *)arg1)->Support((btVector3 const &)*arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +btVector3 *_wrap_MinkowskiDiff_Support__SWIG_1_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + btVector3 *arg2 = 0 ; + gjkepa2_impl::U arg3 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (gjkepa2_impl::U)_swig_go_2; + + result = ((gjkepa2_impl::MinkowskiDiff const *)arg1)->Support((btVector3 const &)*arg2,arg3); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_delete_MinkowskiDiff_mbt_e879218550ba2e2b(gjkepa2_impl::MinkowskiDiff *_swig_go_0) { + gjkepa2_impl::MinkowskiDiff *arg1 = (gjkepa2_impl::MinkowskiDiff *) 0 ; + + arg1 = *(gjkepa2_impl::MinkowskiDiff **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_GJK_m_shape_set_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, gjkepa2_impl::MinkowskiDiff *_swig_go_1) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::tShape *arg2 = (gjkepa2_impl::tShape *) 0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(gjkepa2_impl::tShape **)&_swig_go_1; + + if (arg1) (arg1)->m_shape = *arg2; + +} + + +gjkepa2_impl::MinkowskiDiff *_wrap_GJK_m_shape_get_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::tShape *result = 0 ; + gjkepa2_impl::MinkowskiDiff *_swig_go_result; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (gjkepa2_impl::tShape *)& ((arg1)->m_shape); + *(gjkepa2_impl::tShape **)&_swig_go_result = (gjkepa2_impl::tShape *)result; + return _swig_go_result; +} + + +void _wrap_GJK_m_ray_set_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, btVector3 *_swig_go_1) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_ray = *arg2; + +} + + +btVector3 *_wrap_GJK_m_ray_get_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_ray); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_GJK_m_distance_set_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, float _swig_go_1) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + btScalar arg2 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_distance = arg2; + +} + + +float _wrap_GJK_m_distance_get_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_distance); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GJK_m_simplices_set_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, gjkepa2_impl::GJK::sSimplex (*_swig_go_1)[2]) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::sSimplex *arg2 = (gjkepa2_impl::GJK::sSimplex *) (gjkepa2_impl::GJK::sSimplex *)0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(gjkepa2_impl::GJK::sSimplex **)&_swig_go_1; + + { + size_t ii; + gjkepa2_impl::GJK::sSimplex *b = (gjkepa2_impl::GJK::sSimplex *) arg1->m_simplices; + for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((gjkepa2_impl::GJK::sSimplex *) arg2 + ii); + } + +} + + +gjkepa2_impl::GJK::sSimplex (*_wrap_GJK_m_simplices_get_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0))[2] { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::sSimplex *result = 0 ; + gjkepa2_impl::GJK::sSimplex (*_swig_go_result)[2]; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (gjkepa2_impl::GJK::sSimplex *)(gjkepa2_impl::GJK::sSimplex *) ((arg1)->m_simplices); + *(gjkepa2_impl::GJK::sSimplex **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GJK_m_store_set_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, gjkepa2_impl::GJK::sSV (*_swig_go_1)[4]) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::sSV *arg2 = (gjkepa2_impl::GJK::sSV *) (gjkepa2_impl::GJK::sSV *)0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(gjkepa2_impl::GJK::sSV **)&_swig_go_1; + + { + size_t ii; + gjkepa2_impl::GJK::sSV *b = (gjkepa2_impl::GJK::sSV *) arg1->m_store; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((gjkepa2_impl::GJK::sSV *) arg2 + ii); + } + +} + + +gjkepa2_impl::GJK::sSV (*_wrap_GJK_m_store_get_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0))[4] { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::sSV *result = 0 ; + gjkepa2_impl::GJK::sSV (*_swig_go_result)[4]; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (gjkepa2_impl::GJK::sSV *)(gjkepa2_impl::GJK::sSV *) ((arg1)->m_store); + *(gjkepa2_impl::GJK::sSV **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GJK_m_free_set_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, gjkepa2_impl::GJK::sSV *(*_swig_go_1)[4]) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::sSV **arg2 = (gjkepa2_impl::GJK::sSV **) (gjkepa2_impl::GJK::sSV **)0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(gjkepa2_impl::GJK::sSV ***)&_swig_go_1; + + { + size_t ii; + gjkepa2_impl::GJK::sSV * *b = (gjkepa2_impl::GJK::sSV * *) arg1->m_free; + for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((gjkepa2_impl::GJK::sSV * *) arg2 + ii); + } + +} + + +gjkepa2_impl::GJK::sSV *(*_wrap_GJK_m_free_get_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0))[4] { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::sSV **result = 0 ; + gjkepa2_impl::GJK::sSV *(*_swig_go_result)[4]; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (gjkepa2_impl::GJK::sSV **)(gjkepa2_impl::GJK::sSV **) ((arg1)->m_free); + *(gjkepa2_impl::GJK::sSV ***)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GJK_m_nfree_set_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, intgo _swig_go_1) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::U arg2 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = (gjkepa2_impl::U)_swig_go_1; + + if (arg1) (arg1)->m_nfree = arg2; + +} + + +intgo _wrap_GJK_m_nfree_get_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::U result; + intgo _swig_go_result; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (gjkepa2_impl::U) ((arg1)->m_nfree); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GJK_m_current_set_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, intgo _swig_go_1) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::U arg2 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = (gjkepa2_impl::U)_swig_go_1; + + if (arg1) (arg1)->m_current = arg2; + +} + + +intgo _wrap_GJK_m_current_get_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::U result; + intgo _swig_go_result; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (gjkepa2_impl::U) ((arg1)->m_current); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GJK_m_simplex_set_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, gjkepa2_impl::GJK::sSimplex *_swig_go_1) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::sSimplex *arg2 = (gjkepa2_impl::GJK::sSimplex *) 0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(gjkepa2_impl::GJK::sSimplex **)&_swig_go_1; + + if (arg1) (arg1)->m_simplex = arg2; + +} + + +gjkepa2_impl::GJK::sSimplex *_wrap_GJK_m_simplex_get_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::sSimplex *result = 0 ; + gjkepa2_impl::GJK::sSimplex *_swig_go_result; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (gjkepa2_impl::GJK::sSimplex *) ((arg1)->m_simplex); + *(gjkepa2_impl::GJK::sSimplex **)&_swig_go_result = (gjkepa2_impl::GJK::sSimplex *)result; + return _swig_go_result; +} + + +void _wrap_GJK_m_status_set_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, gjkepa2_impl::GJK::eStatus::_ *_swig_go_1) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::eStatus::_ *arg2 = (gjkepa2_impl::GJK::eStatus::_ *) 0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(gjkepa2_impl::GJK::eStatus::_ **)&_swig_go_1; + + if (arg1) (arg1)->m_status = *arg2; + +} + + +gjkepa2_impl::GJK::eStatus::_ *_wrap_GJK_m_status_get_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::eStatus::_ *result = 0 ; + gjkepa2_impl::GJK::eStatus::_ *_swig_go_result; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (gjkepa2_impl::GJK::eStatus::_ *)& ((arg1)->m_status); + *(gjkepa2_impl::GJK::eStatus::_ **)&_swig_go_result = (gjkepa2_impl::GJK::eStatus::_ *)result; + return _swig_go_result; +} + + +gjkepa2_impl::GJK *_wrap_new_GJK_mbt_e879218550ba2e2b() { + gjkepa2_impl::GJK *result = 0 ; + gjkepa2_impl::GJK *_swig_go_result; + + + result = (gjkepa2_impl::GJK *)new gjkepa2_impl::GJK(); + *(gjkepa2_impl::GJK **)&_swig_go_result = (gjkepa2_impl::GJK *)result; + return _swig_go_result; +} + + +void _wrap_GJK_Initialize_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + (arg1)->Initialize(); + +} + + +gjkepa2_impl::GJK::eStatus::_ *_wrap_GJK_Evaluate_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, gjkepa2_impl::MinkowskiDiff *_swig_go_1, btVector3 *_swig_go_2) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::tShape *arg2 = 0 ; + btVector3 *arg3 = 0 ; + gjkepa2_impl::GJK::eStatus::_ result; + gjkepa2_impl::GJK::eStatus::_ *_swig_go_result; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(gjkepa2_impl::tShape **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (arg1)->Evaluate((gjkepa2_impl::tShape const &)*arg2,(btVector3 const &)*arg3); + *(gjkepa2_impl::GJK::eStatus::_ **)&_swig_go_result = new gjkepa2_impl::GJK::eStatus::_(result); + return _swig_go_result; +} + + +bool _wrap_GJK_EncloseOrigin_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + result = (bool)(arg1)->EncloseOrigin(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_GJK_getsupport_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, btVector3 *_swig_go_1, gjkepa2_impl::GJK::sSV *_swig_go_2) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + btVector3 *arg2 = 0 ; + gjkepa2_impl::GJK::sSV *arg3 = 0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(gjkepa2_impl::GJK::sSV **)&_swig_go_2; + + ((gjkepa2_impl::GJK const *)arg1)->getsupport((btVector3 const &)*arg2,*arg3); + +} + + +void _wrap_GJK_removevertice_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, gjkepa2_impl::GJK::sSimplex *_swig_go_1) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::sSimplex *arg2 = 0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(gjkepa2_impl::GJK::sSimplex **)&_swig_go_1; + + (arg1)->removevertice(*arg2); + +} + + +void _wrap_GJK_appendvertice_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0, gjkepa2_impl::GJK::sSimplex *_swig_go_1, btVector3 *_swig_go_2) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + gjkepa2_impl::GJK::sSimplex *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + arg2 = *(gjkepa2_impl::GJK::sSimplex **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->appendvertice(*arg2,(btVector3 const &)*arg3); + +} + + +float _wrap_GJK_det_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (btScalar)gjkepa2_impl::GJK::det((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_GJK_projectorigin__SWIG_0_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2, intgo *_swig_go_3) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = (btScalar *) 0 ; + gjkepa2_impl::U *arg4 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + arg4 = *(gjkepa2_impl::U **)&_swig_go_3; + + result = (btScalar)gjkepa2_impl::GJK::projectorigin((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_GJK_projectorigin__SWIG_1_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float *_swig_go_3, intgo *_swig_go_4) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar *arg4 = (btScalar *) 0 ; + gjkepa2_impl::U *arg5 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btScalar **)&_swig_go_3; + arg5 = *(gjkepa2_impl::U **)&_swig_go_4; + + result = (btScalar)gjkepa2_impl::GJK::projectorigin((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,*arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_GJK_projectorigin__SWIG_2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float *_swig_go_4, intgo *_swig_go_5) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar *arg5 = (btScalar *) 0 ; + gjkepa2_impl::U *arg6 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(gjkepa2_impl::U **)&_swig_go_5; + + result = (btScalar)gjkepa2_impl::GJK::projectorigin((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_GJK_mbt_e879218550ba2e2b(gjkepa2_impl::GJK *_swig_go_0) { + gjkepa2_impl::GJK *arg1 = (gjkepa2_impl::GJK *) 0 ; + + arg1 = *(gjkepa2_impl::GJK **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_EPA_m_status_set_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, gjkepa2_impl::EPA::eStatus::_ *_swig_go_1) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::eStatus::_ *arg2 = (gjkepa2_impl::EPA::eStatus::_ *) 0 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = *(gjkepa2_impl::EPA::eStatus::_ **)&_swig_go_1; + + if (arg1) (arg1)->m_status = *arg2; + +} + + +gjkepa2_impl::EPA::eStatus::_ *_wrap_EPA_m_status_get_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::eStatus::_ *result = 0 ; + gjkepa2_impl::EPA::eStatus::_ *_swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + result = (gjkepa2_impl::EPA::eStatus::_ *)& ((arg1)->m_status); + *(gjkepa2_impl::EPA::eStatus::_ **)&_swig_go_result = (gjkepa2_impl::EPA::eStatus::_ *)result; + return _swig_go_result; +} + + +void _wrap_EPA_m_result_set_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, gjkepa2_impl::GJK::sSimplex *_swig_go_1) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::GJK::sSimplex *arg2 = (gjkepa2_impl::GJK::sSimplex *) 0 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = *(gjkepa2_impl::GJK::sSimplex **)&_swig_go_1; + + if (arg1) (arg1)->m_result = *arg2; + +} + + +gjkepa2_impl::GJK::sSimplex *_wrap_EPA_m_result_get_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::GJK::sSimplex *result = 0 ; + gjkepa2_impl::GJK::sSimplex *_swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + result = (gjkepa2_impl::GJK::sSimplex *)& ((arg1)->m_result); + *(gjkepa2_impl::GJK::sSimplex **)&_swig_go_result = (gjkepa2_impl::GJK::sSimplex *)result; + return _swig_go_result; +} + + +void _wrap_EPA_m_normal_set_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, btVector3 *_swig_go_1) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_normal = *arg2; + +} + + +btVector3 *_wrap_EPA_m_normal_get_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_normal); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_EPA_m_depth_set_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, float _swig_go_1) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + btScalar arg2 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_depth = arg2; + +} + + +float _wrap_EPA_m_depth_get_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_depth); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_EPA_m_sv_store_set_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, gjkepa2_impl::GJK::sSV (*_swig_go_1)[128]) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sSV *arg2 = (gjkepa2_impl::EPA::sSV *) (gjkepa2_impl::EPA::sSV *)0 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = *(gjkepa2_impl::EPA::sSV **)&_swig_go_1; + + { + size_t ii; + gjkepa2_impl::EPA::sSV *b = (gjkepa2_impl::EPA::sSV *) arg1->m_sv_store; + for (ii = 0; ii < (size_t)128; ii++) b[ii] = *((gjkepa2_impl::EPA::sSV *) arg2 + ii); + } + +} + + +gjkepa2_impl::GJK::sSV (*_wrap_EPA_m_sv_store_get_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0))[128] { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sSV *result = 0 ; + gjkepa2_impl::GJK::sSV (*_swig_go_result)[128]; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + result = (gjkepa2_impl::EPA::sSV *)(gjkepa2_impl::EPA::sSV *) ((arg1)->m_sv_store); + *(gjkepa2_impl::EPA::sSV **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_EPA_m_fc_store_set_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, gjkepa2_impl::EPA::sFace (*_swig_go_1)[(128*2)]) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sFace *arg2 = (gjkepa2_impl::EPA::sFace *) (gjkepa2_impl::EPA::sFace *)0 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = *(gjkepa2_impl::EPA::sFace **)&_swig_go_1; + + { + size_t ii; + gjkepa2_impl::EPA::sFace *b = (gjkepa2_impl::EPA::sFace *) arg1->m_fc_store; + for (ii = 0; ii < (size_t)(128*2); ii++) b[ii] = *((gjkepa2_impl::EPA::sFace *) arg2 + ii); + } + +} + + +gjkepa2_impl::EPA::sFace (*_wrap_EPA_m_fc_store_get_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0))[(128*2)] { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sFace *result = 0 ; + gjkepa2_impl::EPA::sFace (*_swig_go_result)[(128*2)]; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + result = (gjkepa2_impl::EPA::sFace *)(gjkepa2_impl::EPA::sFace *) ((arg1)->m_fc_store); + *(gjkepa2_impl::EPA::sFace **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_EPA_m_nextsv_set_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, intgo _swig_go_1) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::U arg2 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = (gjkepa2_impl::U)_swig_go_1; + + if (arg1) (arg1)->m_nextsv = arg2; + +} + + +intgo _wrap_EPA_m_nextsv_get_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::U result; + intgo _swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + result = (gjkepa2_impl::U) ((arg1)->m_nextsv); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_EPA_m_hull_set_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, gjkepa2_impl::EPA::sList *_swig_go_1) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sList *arg2 = (gjkepa2_impl::EPA::sList *) 0 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = *(gjkepa2_impl::EPA::sList **)&_swig_go_1; + + if (arg1) (arg1)->m_hull = *arg2; + +} + + +gjkepa2_impl::EPA::sList *_wrap_EPA_m_hull_get_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sList *result = 0 ; + gjkepa2_impl::EPA::sList *_swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + result = (gjkepa2_impl::EPA::sList *)& ((arg1)->m_hull); + *(gjkepa2_impl::EPA::sList **)&_swig_go_result = (gjkepa2_impl::EPA::sList *)result; + return _swig_go_result; +} + + +void _wrap_EPA_m_stock_set_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, gjkepa2_impl::EPA::sList *_swig_go_1) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sList *arg2 = (gjkepa2_impl::EPA::sList *) 0 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = *(gjkepa2_impl::EPA::sList **)&_swig_go_1; + + if (arg1) (arg1)->m_stock = *arg2; + +} + + +gjkepa2_impl::EPA::sList *_wrap_EPA_m_stock_get_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sList *result = 0 ; + gjkepa2_impl::EPA::sList *_swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + result = (gjkepa2_impl::EPA::sList *)& ((arg1)->m_stock); + *(gjkepa2_impl::EPA::sList **)&_swig_go_result = (gjkepa2_impl::EPA::sList *)result; + return _swig_go_result; +} + + +gjkepa2_impl::EPA *_wrap_new_EPA_mbt_e879218550ba2e2b() { + gjkepa2_impl::EPA *result = 0 ; + gjkepa2_impl::EPA *_swig_go_result; + + + result = (gjkepa2_impl::EPA *)new gjkepa2_impl::EPA(); + *(gjkepa2_impl::EPA **)&_swig_go_result = (gjkepa2_impl::EPA *)result; + return _swig_go_result; +} + + +void _wrap_EPA_bind_mbt_e879218550ba2e2b(gjkepa2_impl::EPA::sFace *_swig_go_0, intgo _swig_go_1, gjkepa2_impl::EPA::sFace *_swig_go_2, intgo _swig_go_3) { + gjkepa2_impl::EPA::sFace *arg1 = (gjkepa2_impl::EPA::sFace *) 0 ; + gjkepa2_impl::U arg2 ; + gjkepa2_impl::EPA::sFace *arg3 = (gjkepa2_impl::EPA::sFace *) 0 ; + gjkepa2_impl::U arg4 ; + + arg1 = *(gjkepa2_impl::EPA::sFace **)&_swig_go_0; + arg2 = (gjkepa2_impl::U)_swig_go_1; + arg3 = *(gjkepa2_impl::EPA::sFace **)&_swig_go_2; + arg4 = (gjkepa2_impl::U)_swig_go_3; + + gjkepa2_impl::EPA::bind(arg1,arg2,arg3,arg4); + +} + + +void _wrap_EPA_append_mbt_e879218550ba2e2b(gjkepa2_impl::EPA::sList *_swig_go_0, gjkepa2_impl::EPA::sFace *_swig_go_1) { + gjkepa2_impl::EPA::sList *arg1 = 0 ; + gjkepa2_impl::EPA::sFace *arg2 = (gjkepa2_impl::EPA::sFace *) 0 ; + + arg1 = *(gjkepa2_impl::EPA::sList **)&_swig_go_0; + arg2 = *(gjkepa2_impl::EPA::sFace **)&_swig_go_1; + + gjkepa2_impl::EPA::append(*arg1,arg2); + +} + + +void _wrap_EPA_remove_mbt_e879218550ba2e2b(gjkepa2_impl::EPA::sList *_swig_go_0, gjkepa2_impl::EPA::sFace *_swig_go_1) { + gjkepa2_impl::EPA::sList *arg1 = 0 ; + gjkepa2_impl::EPA::sFace *arg2 = (gjkepa2_impl::EPA::sFace *) 0 ; + + arg1 = *(gjkepa2_impl::EPA::sList **)&_swig_go_0; + arg2 = *(gjkepa2_impl::EPA::sFace **)&_swig_go_1; + + gjkepa2_impl::EPA::remove(*arg1,arg2); + +} + + +void _wrap_EPA_Initialize_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + (arg1)->Initialize(); + +} + + +gjkepa2_impl::EPA::eStatus::_ *_wrap_EPA_Evaluate_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, gjkepa2_impl::GJK *_swig_go_1, btVector3 *_swig_go_2) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::GJK *arg2 = 0 ; + btVector3 *arg3 = 0 ; + gjkepa2_impl::EPA::eStatus::_ result; + gjkepa2_impl::EPA::eStatus::_ *_swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = *(gjkepa2_impl::GJK **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + result = (arg1)->Evaluate(*arg2,(btVector3 const &)*arg3); + *(gjkepa2_impl::EPA::eStatus::_ **)&_swig_go_result = new gjkepa2_impl::EPA::eStatus::_(result); + return _swig_go_result; +} + + +bool _wrap_EPA_getedgedist_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, gjkepa2_impl::EPA::sFace *_swig_go_1, gjkepa2_impl::GJK::sSV *_swig_go_2, gjkepa2_impl::GJK::sSV *_swig_go_3, float *_swig_go_4) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sFace *arg2 = (gjkepa2_impl::EPA::sFace *) 0 ; + gjkepa2_impl::EPA::sSV *arg3 = (gjkepa2_impl::EPA::sSV *) 0 ; + gjkepa2_impl::EPA::sSV *arg4 = (gjkepa2_impl::EPA::sSV *) 0 ; + btScalar *arg5 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = *(gjkepa2_impl::EPA::sFace **)&_swig_go_1; + arg3 = *(gjkepa2_impl::EPA::sSV **)&_swig_go_2; + arg4 = *(gjkepa2_impl::EPA::sSV **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + + result = (bool)(arg1)->getedgedist(arg2,arg3,arg4,*arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +gjkepa2_impl::EPA::sFace *_wrap_EPA_newface_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, gjkepa2_impl::GJK::sSV *_swig_go_1, gjkepa2_impl::GJK::sSV *_swig_go_2, gjkepa2_impl::GJK::sSV *_swig_go_3, bool _swig_go_4) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sSV *arg2 = (gjkepa2_impl::EPA::sSV *) 0 ; + gjkepa2_impl::EPA::sSV *arg3 = (gjkepa2_impl::EPA::sSV *) 0 ; + gjkepa2_impl::EPA::sSV *arg4 = (gjkepa2_impl::EPA::sSV *) 0 ; + bool arg5 ; + gjkepa2_impl::EPA::sFace *result = 0 ; + gjkepa2_impl::EPA::sFace *_swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = *(gjkepa2_impl::EPA::sSV **)&_swig_go_1; + arg3 = *(gjkepa2_impl::EPA::sSV **)&_swig_go_2; + arg4 = *(gjkepa2_impl::EPA::sSV **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + + result = (gjkepa2_impl::EPA::sFace *)(arg1)->newface(arg2,arg3,arg4,arg5); + *(gjkepa2_impl::EPA::sFace **)&_swig_go_result = (gjkepa2_impl::EPA::sFace *)result; + return _swig_go_result; +} + + +gjkepa2_impl::EPA::sFace *_wrap_EPA_findbest_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::EPA::sFace *result = 0 ; + gjkepa2_impl::EPA::sFace *_swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + result = (gjkepa2_impl::EPA::sFace *)(arg1)->findbest(); + *(gjkepa2_impl::EPA::sFace **)&_swig_go_result = (gjkepa2_impl::EPA::sFace *)result; + return _swig_go_result; +} + + +bool _wrap_EPA_expand_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0, intgo _swig_go_1, gjkepa2_impl::GJK::sSV *_swig_go_2, gjkepa2_impl::EPA::sFace *_swig_go_3, intgo _swig_go_4, gjkepa2_impl::EPA::sHorizon *_swig_go_5) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + gjkepa2_impl::U arg2 ; + gjkepa2_impl::EPA::sSV *arg3 = (gjkepa2_impl::EPA::sSV *) 0 ; + gjkepa2_impl::EPA::sFace *arg4 = (gjkepa2_impl::EPA::sFace *) 0 ; + gjkepa2_impl::U arg5 ; + gjkepa2_impl::EPA::sHorizon *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + arg2 = (gjkepa2_impl::U)_swig_go_1; + arg3 = *(gjkepa2_impl::EPA::sSV **)&_swig_go_2; + arg4 = *(gjkepa2_impl::EPA::sFace **)&_swig_go_3; + arg5 = (gjkepa2_impl::U)_swig_go_4; + arg6 = *(gjkepa2_impl::EPA::sHorizon **)&_swig_go_5; + + result = (bool)(arg1)->expand(arg2,arg3,arg4,arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_EPA_mbt_e879218550ba2e2b(gjkepa2_impl::EPA *_swig_go_0) { + gjkepa2_impl::EPA *arg1 = (gjkepa2_impl::EPA *) 0 ; + + arg1 = *(gjkepa2_impl::EPA **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_Initialize_mbt_e879218550ba2e2b(btConvexShape *_swig_go_0, btTransform *_swig_go_1, btConvexShape *_swig_go_2, btTransform *_swig_go_3, btGjkEpaSolver2::sResults *_swig_go_4, gjkepa2_impl::MinkowskiDiff *_swig_go_5, bool _swig_go_6) { + btConvexShape *arg1 = (btConvexShape *) 0 ; + btTransform *arg2 = 0 ; + btConvexShape *arg3 = (btConvexShape *) 0 ; + btTransform *arg4 = 0 ; + btGjkEpaSolver2::sResults *arg5 = 0 ; + gjkepa2_impl::tShape *arg6 = 0 ; + bool arg7 ; + + arg1 = *(btConvexShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btConvexShape **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btGjkEpaSolver2::sResults **)&_swig_go_4; + arg6 = *(gjkepa2_impl::tShape **)&_swig_go_5; + arg7 = (bool)_swig_go_6; + + gjkepa2_impl::Initialize((btConvexShape const *)arg1,(btTransform const &)*arg2,(btConvexShape const *)arg3,(btTransform const &)*arg4,*arg5,*arg6,arg7); + +} + + +void _wrap_delete_btCollisionConfiguration_mbt_e879218550ba2e2b(btCollisionConfiguration *_swig_go_0) { + btCollisionConfiguration *arg1 = (btCollisionConfiguration *) 0 ; + + arg1 = *(btCollisionConfiguration **)&_swig_go_0; + + delete arg1; + +} + + +btPoolAllocator *_wrap_btCollisionConfiguration_getPersistentManifoldPool_mbt_e879218550ba2e2b(btCollisionConfiguration *_swig_go_0) { + btCollisionConfiguration *arg1 = (btCollisionConfiguration *) 0 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = *(btCollisionConfiguration **)&_swig_go_0; + + result = (btPoolAllocator *)(arg1)->getPersistentManifoldPool(); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +btPoolAllocator *_wrap_btCollisionConfiguration_getCollisionAlgorithmPool_mbt_e879218550ba2e2b(btCollisionConfiguration *_swig_go_0) { + btCollisionConfiguration *arg1 = (btCollisionConfiguration *) 0 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = *(btCollisionConfiguration **)&_swig_go_0; + + result = (btPoolAllocator *)(arg1)->getCollisionAlgorithmPool(); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +btCollisionAlgorithmCreateFunc *_wrap_btCollisionConfiguration_getCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b(btCollisionConfiguration *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btCollisionConfiguration *arg1 = (btCollisionConfiguration *) 0 ; + int arg2 ; + int arg3 ; + btCollisionAlgorithmCreateFunc *result = 0 ; + btCollisionAlgorithmCreateFunc *_swig_go_result; + + arg1 = *(btCollisionConfiguration **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btCollisionAlgorithmCreateFunc *)(arg1)->getCollisionAlgorithmCreateFunc(arg2,arg3); + *(btCollisionAlgorithmCreateFunc **)&_swig_go_result = (btCollisionAlgorithmCreateFunc *)result; + return _swig_go_result; +} + + +btCollisionAlgorithmCreateFunc *_wrap_btCollisionConfiguration_getClosestPointsAlgorithmCreateFunc_mbt_e879218550ba2e2b(btCollisionConfiguration *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btCollisionConfiguration *arg1 = (btCollisionConfiguration *) 0 ; + int arg2 ; + int arg3 ; + btCollisionAlgorithmCreateFunc *result = 0 ; + btCollisionAlgorithmCreateFunc *_swig_go_result; + + arg1 = *(btCollisionConfiguration **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btCollisionAlgorithmCreateFunc *)(arg1)->getClosestPointsAlgorithmCreateFunc(arg2,arg3); + *(btCollisionAlgorithmCreateFunc **)&_swig_go_result = (btCollisionAlgorithmCreateFunc *)result; + return _swig_go_result; +} + + +void _wrap_btDefaultCollisionConstructionInfo_m_persistentManifoldPool_set_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0, btPoolAllocator *_swig_go_1) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + btPoolAllocator *arg2 = (btPoolAllocator *) 0 ; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + arg2 = *(btPoolAllocator **)&_swig_go_1; + + if (arg1) (arg1)->m_persistentManifoldPool = arg2; + +} + + +btPoolAllocator *_wrap_btDefaultCollisionConstructionInfo_m_persistentManifoldPool_get_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + + result = (btPoolAllocator *) ((arg1)->m_persistentManifoldPool); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +void _wrap_btDefaultCollisionConstructionInfo_m_collisionAlgorithmPool_set_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0, btPoolAllocator *_swig_go_1) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + btPoolAllocator *arg2 = (btPoolAllocator *) 0 ; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + arg2 = *(btPoolAllocator **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionAlgorithmPool = arg2; + +} + + +btPoolAllocator *_wrap_btDefaultCollisionConstructionInfo_m_collisionAlgorithmPool_get_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + + result = (btPoolAllocator *) ((arg1)->m_collisionAlgorithmPool); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +void _wrap_btDefaultCollisionConstructionInfo_m_defaultMaxPersistentManifoldPoolSize_set_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0, intgo _swig_go_1) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + int arg2 ; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_defaultMaxPersistentManifoldPoolSize = arg2; + +} + + +intgo _wrap_btDefaultCollisionConstructionInfo_m_defaultMaxPersistentManifoldPoolSize_get_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + + result = (int) ((arg1)->m_defaultMaxPersistentManifoldPoolSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDefaultCollisionConstructionInfo_m_defaultMaxCollisionAlgorithmPoolSize_set_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0, intgo _swig_go_1) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + int arg2 ; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_defaultMaxCollisionAlgorithmPoolSize = arg2; + +} + + +intgo _wrap_btDefaultCollisionConstructionInfo_m_defaultMaxCollisionAlgorithmPoolSize_get_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + + result = (int) ((arg1)->m_defaultMaxCollisionAlgorithmPoolSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDefaultCollisionConstructionInfo_m_customCollisionAlgorithmMaxElementSize_set_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0, intgo _swig_go_1) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + int arg2 ; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_customCollisionAlgorithmMaxElementSize = arg2; + +} + + +intgo _wrap_btDefaultCollisionConstructionInfo_m_customCollisionAlgorithmMaxElementSize_get_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + + result = (int) ((arg1)->m_customCollisionAlgorithmMaxElementSize); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btDefaultCollisionConstructionInfo_m_useEpaPenetrationAlgorithm_set_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0, intgo _swig_go_1) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + int arg2 ; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_useEpaPenetrationAlgorithm = arg2; + +} + + +intgo _wrap_btDefaultCollisionConstructionInfo_m_useEpaPenetrationAlgorithm_get_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + + result = (int) ((arg1)->m_useEpaPenetrationAlgorithm); + _swig_go_result = result; + return _swig_go_result; +} + + +btDefaultCollisionConstructionInfo *_wrap_new_btDefaultCollisionConstructionInfo_mbt_e879218550ba2e2b() { + btDefaultCollisionConstructionInfo *result = 0 ; + btDefaultCollisionConstructionInfo *_swig_go_result; + + + result = (btDefaultCollisionConstructionInfo *)new btDefaultCollisionConstructionInfo(); + *(btDefaultCollisionConstructionInfo **)&_swig_go_result = (btDefaultCollisionConstructionInfo *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDefaultCollisionConstructionInfo_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0) { + btDefaultCollisionConstructionInfo *arg1 = (btDefaultCollisionConstructionInfo *) 0 ; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + + delete arg1; + +} + + +btDefaultCollisionConfiguration *_wrap_new_btDefaultCollisionConfiguration__SWIG_0_mbt_e879218550ba2e2b(btDefaultCollisionConstructionInfo *_swig_go_0) { + btDefaultCollisionConstructionInfo *arg1 = 0 ; + btDefaultCollisionConfiguration *result = 0 ; + btDefaultCollisionConfiguration *_swig_go_result; + + arg1 = *(btDefaultCollisionConstructionInfo **)&_swig_go_0; + + result = (btDefaultCollisionConfiguration *)new btDefaultCollisionConfiguration((btDefaultCollisionConstructionInfo const &)*arg1); + *(btDefaultCollisionConfiguration **)&_swig_go_result = (btDefaultCollisionConfiguration *)result; + return _swig_go_result; +} + + +btDefaultCollisionConfiguration *_wrap_new_btDefaultCollisionConfiguration__SWIG_1_mbt_e879218550ba2e2b() { + btDefaultCollisionConfiguration *result = 0 ; + btDefaultCollisionConfiguration *_swig_go_result; + + + result = (btDefaultCollisionConfiguration *)new btDefaultCollisionConfiguration(); + *(btDefaultCollisionConfiguration **)&_swig_go_result = (btDefaultCollisionConfiguration *)result; + return _swig_go_result; +} + + +void _wrap_delete_btDefaultCollisionConfiguration_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + + delete arg1; + +} + + +btPoolAllocator *_wrap_btDefaultCollisionConfiguration_getPersistentManifoldPool_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + + result = (btPoolAllocator *)(arg1)->getPersistentManifoldPool(); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +btPoolAllocator *_wrap_btDefaultCollisionConfiguration_getCollisionAlgorithmPool_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + + result = (btPoolAllocator *)(arg1)->getCollisionAlgorithmPool(); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +btCollisionAlgorithmCreateFunc *_wrap_btDefaultCollisionConfiguration_getCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + int arg2 ; + int arg3 ; + btCollisionAlgorithmCreateFunc *result = 0 ; + btCollisionAlgorithmCreateFunc *_swig_go_result; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btCollisionAlgorithmCreateFunc *)(arg1)->getCollisionAlgorithmCreateFunc(arg2,arg3); + *(btCollisionAlgorithmCreateFunc **)&_swig_go_result = (btCollisionAlgorithmCreateFunc *)result; + return _swig_go_result; +} + + +btCollisionAlgorithmCreateFunc *_wrap_btDefaultCollisionConfiguration_getClosestPointsAlgorithmCreateFunc_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + int arg2 ; + int arg3 ; + btCollisionAlgorithmCreateFunc *result = 0 ; + btCollisionAlgorithmCreateFunc *_swig_go_result; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btCollisionAlgorithmCreateFunc *)(arg1)->getClosestPointsAlgorithmCreateFunc(arg2,arg3); + *(btCollisionAlgorithmCreateFunc **)&_swig_go_result = (btCollisionAlgorithmCreateFunc *)result; + return _swig_go_result; +} + + +void _wrap_btDefaultCollisionConfiguration_setConvexConvexMultipointIterations__SWIG_0_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->setConvexConvexMultipointIterations(arg2,arg3); + +} + + +void _wrap_btDefaultCollisionConfiguration_setConvexConvexMultipointIterations__SWIG_1_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0, intgo _swig_go_1) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + int arg2 ; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setConvexConvexMultipointIterations(arg2); + +} + + +void _wrap_btDefaultCollisionConfiguration_setConvexConvexMultipointIterations__SWIG_2_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + + (arg1)->setConvexConvexMultipointIterations(); + +} + + +void _wrap_btDefaultCollisionConfiguration_setPlaneConvexMultipointIterations__SWIG_0_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + (arg1)->setPlaneConvexMultipointIterations(arg2,arg3); + +} + + +void _wrap_btDefaultCollisionConfiguration_setPlaneConvexMultipointIterations__SWIG_1_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0, intgo _swig_go_1) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + int arg2 ; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setPlaneConvexMultipointIterations(arg2); + +} + + +void _wrap_btDefaultCollisionConfiguration_setPlaneConvexMultipointIterations__SWIG_2_mbt_e879218550ba2e2b(btDefaultCollisionConfiguration *_swig_go_0) { + btDefaultCollisionConfiguration *arg1 = (btDefaultCollisionConfiguration *) 0 ; + + arg1 = *(btDefaultCollisionConfiguration **)&_swig_go_0; + + (arg1)->setPlaneConvexMultipointIterations(); + +} + + +btCollisionAlgorithmConstructionInfo *_wrap_new_btCollisionAlgorithmConstructionInfo__SWIG_0_mbt_e879218550ba2e2b() { + btCollisionAlgorithmConstructionInfo *result = 0 ; + btCollisionAlgorithmConstructionInfo *_swig_go_result; + + + result = (btCollisionAlgorithmConstructionInfo *)new btCollisionAlgorithmConstructionInfo(); + *(btCollisionAlgorithmConstructionInfo **)&_swig_go_result = (btCollisionAlgorithmConstructionInfo *)result; + return _swig_go_result; +} + + +btCollisionAlgorithmConstructionInfo *_wrap_new_btCollisionAlgorithmConstructionInfo__SWIG_1_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, intgo _swig_go_1) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + int arg2 ; + btCollisionAlgorithmConstructionInfo *result = 0 ; + btCollisionAlgorithmConstructionInfo *_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btCollisionAlgorithmConstructionInfo *)new btCollisionAlgorithmConstructionInfo(arg1,arg2); + *(btCollisionAlgorithmConstructionInfo **)&_swig_go_result = (btCollisionAlgorithmConstructionInfo *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionAlgorithmConstructionInfo_m_dispatcher1_set_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0, btDispatcher *_swig_go_1) { + btCollisionAlgorithmConstructionInfo *arg1 = (btCollisionAlgorithmConstructionInfo *) 0 ; + btDispatcher *arg2 = (btDispatcher *) 0 ; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + arg2 = *(btDispatcher **)&_swig_go_1; + + if (arg1) (arg1)->m_dispatcher1 = arg2; + +} + + +btDispatcher *_wrap_btCollisionAlgorithmConstructionInfo_m_dispatcher1_get_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0) { + btCollisionAlgorithmConstructionInfo *arg1 = (btCollisionAlgorithmConstructionInfo *) 0 ; + btDispatcher *result = 0 ; + btDispatcher *_swig_go_result; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + + result = (btDispatcher *) ((arg1)->m_dispatcher1); + *(btDispatcher **)&_swig_go_result = (btDispatcher *)result; + return _swig_go_result; +} + + +void _wrap_btCollisionAlgorithmConstructionInfo_m_manifold_set_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0, btPersistentManifold *_swig_go_1) { + btCollisionAlgorithmConstructionInfo *arg1 = (btCollisionAlgorithmConstructionInfo *) 0 ; + btPersistentManifold *arg2 = (btPersistentManifold *) 0 ; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + arg2 = *(btPersistentManifold **)&_swig_go_1; + + if (arg1) (arg1)->m_manifold = arg2; + +} + + +btPersistentManifold *_wrap_btCollisionAlgorithmConstructionInfo_m_manifold_get_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0) { + btCollisionAlgorithmConstructionInfo *arg1 = (btCollisionAlgorithmConstructionInfo *) 0 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + + result = (btPersistentManifold *) ((arg1)->m_manifold); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCollisionAlgorithmConstructionInfo_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0) { + btCollisionAlgorithmConstructionInfo *arg1 = (btCollisionAlgorithmConstructionInfo *) 0 ; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_delete_btCollisionAlgorithm_mbt_e879218550ba2e2b(btCollisionAlgorithm *_swig_go_0) { + btCollisionAlgorithm *arg1 = (btCollisionAlgorithm *) 0 ; + + arg1 = *(btCollisionAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(btCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btCollisionAlgorithm *arg1 = (btCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btCollisionAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btCollisionAlgorithm *arg1 = (btCollisionAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btCollisionAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btCollisionAlgorithm *arg1 = (btCollisionAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +void _wrap_delete_btActivatingCollisionAlgorithm_mbt_e879218550ba2e2b(btActivatingCollisionAlgorithm *_swig_go_0) { + btActivatingCollisionAlgorithm *arg1 = (btActivatingCollisionAlgorithm *) 0 ; + + arg1 = *(btActivatingCollisionAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btActivatingCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(btActivatingCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btActivatingCollisionAlgorithm *arg1 = (btActivatingCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btActivatingCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + btCollisionAlgorithm *swig_b0 = (btCollisionAlgorithm *)arg1; + (swig_b0)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btActivatingCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btActivatingCollisionAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btActivatingCollisionAlgorithm *arg1 = (btActivatingCollisionAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btActivatingCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + btCollisionAlgorithm *swig_b0 = (btCollisionAlgorithm *)arg1; + result = (btScalar)(swig_b0)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btActivatingCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btActivatingCollisionAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btActivatingCollisionAlgorithm *arg1 = (btActivatingCollisionAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btActivatingCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + btCollisionAlgorithm *swig_b0 = (btCollisionAlgorithm *)arg1; + (swig_b0)->getAllContactManifolds(*arg2); + +} + + +void _wrap_btPolyhedralContactClipping_clipHullAgainstHull_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btConvexPolyhedron *_swig_go_1, btConvexPolyhedron *_swig_go_2, btTransform *_swig_go_3, btTransform *_swig_go_4, float _swig_go_5, float _swig_go_6, btAlignedObjectArray< btVector3 > *_swig_go_7, btAlignedObjectArray< btVector3 > *_swig_go_8, btDiscreteCollisionDetectorInterface::Result *_swig_go_9) { + btVector3 *arg1 = 0 ; + btConvexPolyhedron *arg2 = 0 ; + btConvexPolyhedron *arg3 = 0 ; + btTransform *arg4 = 0 ; + btTransform *arg5 = 0 ; + btScalar arg6 ; + btScalar arg7 ; + btVertexArray *arg8 = 0 ; + btVertexArray *arg9 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg10 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btConvexPolyhedron **)&_swig_go_1; + arg3 = *(btConvexPolyhedron **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = *(btVertexArray **)&_swig_go_7; + arg9 = *(btVertexArray **)&_swig_go_8; + arg10 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_9; + + btPolyhedralContactClipping::clipHullAgainstHull((btVector3 const &)*arg1,(btConvexPolyhedron const &)*arg2,(btConvexPolyhedron const &)*arg3,(btTransform const &)*arg4,(btTransform const &)*arg5,arg6,arg7,*arg8,*arg9,*arg10); + +} + + +void _wrap_btPolyhedralContactClipping_clipFaceAgainstHull_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btConvexPolyhedron *_swig_go_1, btTransform *_swig_go_2, btAlignedObjectArray< btVector3 > *_swig_go_3, btAlignedObjectArray< btVector3 > *_swig_go_4, float _swig_go_5, float _swig_go_6, btDiscreteCollisionDetectorInterface::Result *_swig_go_7) { + btVector3 *arg1 = 0 ; + btConvexPolyhedron *arg2 = 0 ; + btTransform *arg3 = 0 ; + btVertexArray *arg4 = 0 ; + btVertexArray *arg5 = 0 ; + btScalar arg6 ; + btScalar arg7 ; + btDiscreteCollisionDetectorInterface::Result *arg8 = 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btConvexPolyhedron **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btVertexArray **)&_swig_go_3; + arg5 = *(btVertexArray **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_7; + + btPolyhedralContactClipping::clipFaceAgainstHull((btVector3 const &)*arg1,(btConvexPolyhedron const &)*arg2,(btTransform const &)*arg3,*arg4,*arg5,arg6,arg7,*arg8); + +} + + +bool _wrap_btPolyhedralContactClipping_findSeparatingAxis_mbt_e879218550ba2e2b(btConvexPolyhedron *_swig_go_0, btConvexPolyhedron *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btDiscreteCollisionDetectorInterface::Result *_swig_go_5) { + btConvexPolyhedron *arg1 = 0 ; + btConvexPolyhedron *arg2 = 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg6 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexPolyhedron **)&_swig_go_0; + arg2 = *(btConvexPolyhedron **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_5; + + result = (bool)btPolyhedralContactClipping::findSeparatingAxis((btConvexPolyhedron const &)*arg1,(btConvexPolyhedron const &)*arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,*arg5,*arg6); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPolyhedralContactClipping_clipFace_mbt_e879218550ba2e2b(btAlignedObjectArray< btVector3 > *_swig_go_0, btAlignedObjectArray< btVector3 > *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3) { + btVertexArray *arg1 = 0 ; + btVertexArray *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btVertexArray **)&_swig_go_0; + arg2 = *(btVertexArray **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + btPolyhedralContactClipping::clipFace((btAlignedObjectArray< btVector3 > const &)*arg1,*arg2,(btVector3 const &)*arg3,arg4); + +} + + +btPolyhedralContactClipping *_wrap_new_btPolyhedralContactClipping_mbt_e879218550ba2e2b() { + btPolyhedralContactClipping *result = 0 ; + btPolyhedralContactClipping *_swig_go_result; + + + result = (btPolyhedralContactClipping *)new btPolyhedralContactClipping(); + *(btPolyhedralContactClipping **)&_swig_go_result = (btPolyhedralContactClipping *)result; + return _swig_go_result; +} + + +void _wrap_delete_btPolyhedralContactClipping_mbt_e879218550ba2e2b(btPolyhedralContactClipping *_swig_go_0) { + btPolyhedralContactClipping *arg1 = (btPolyhedralContactClipping *) 0 ; + + arg1 = *(btPolyhedralContactClipping **)&_swig_go_0; + + delete arg1; + +} + + +btConvexConvexAlgorithm *_wrap_new_btConvexConvexAlgorithm_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btCollisionAlgorithmConstructionInfo *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionObjectWrapper *_swig_go_3, btConvexPenetrationDepthSolver *_swig_go_4, intgo _swig_go_5, intgo _swig_go_6) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btCollisionAlgorithmConstructionInfo *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + btConvexPenetrationDepthSolver *arg5 = (btConvexPenetrationDepthSolver *) 0 ; + int arg6 ; + int arg7 ; + btConvexConvexAlgorithm *result = 0 ; + btConvexConvexAlgorithm *_swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + arg5 = *(btConvexPenetrationDepthSolver **)&_swig_go_4; + arg6 = (int)_swig_go_5; + arg7 = (int)_swig_go_6; + + result = (btConvexConvexAlgorithm *)new btConvexConvexAlgorithm(arg1,(btCollisionAlgorithmConstructionInfo const &)*arg2,(btCollisionObjectWrapper const *)arg3,(btCollisionObjectWrapper const *)arg4,arg5,arg6,arg7); + *(btConvexConvexAlgorithm **)&_swig_go_result = (btConvexConvexAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_delete_btConvexConvexAlgorithm_mbt_e879218550ba2e2b(btConvexConvexAlgorithm *_swig_go_0) { + btConvexConvexAlgorithm *arg1 = (btConvexConvexAlgorithm *) 0 ; + + arg1 = *(btConvexConvexAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConvexConvexAlgorithm_processCollision_mbt_e879218550ba2e2b(btConvexConvexAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btConvexConvexAlgorithm *arg1 = (btConvexConvexAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btConvexConvexAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btConvexConvexAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btConvexConvexAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btConvexConvexAlgorithm *arg1 = (btConvexConvexAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexConvexAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexConvexAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btConvexConvexAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btConvexConvexAlgorithm *arg1 = (btConvexConvexAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btConvexConvexAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +void _wrap_btConvexConvexAlgorithm_setLowLevelOfDetail_mbt_e879218550ba2e2b(btConvexConvexAlgorithm *_swig_go_0, bool _swig_go_1) { + btConvexConvexAlgorithm *arg1 = (btConvexConvexAlgorithm *) 0 ; + bool arg2 ; + + arg1 = *(btConvexConvexAlgorithm **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + (arg1)->setLowLevelOfDetail(arg2); + +} + + +btPersistentManifold *_wrap_btConvexConvexAlgorithm_getManifold_mbt_e879218550ba2e2b(btConvexConvexAlgorithm *_swig_go_0) { + btConvexConvexAlgorithm *arg1 = (btConvexConvexAlgorithm *) 0 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btConvexConvexAlgorithm **)&_swig_go_0; + + result = (btPersistentManifold *)(arg1)->getManifold(); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +btEmptyAlgorithm *_wrap_new_btEmptyAlgorithm_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0) { + btCollisionAlgorithmConstructionInfo *arg1 = 0 ; + btEmptyAlgorithm *result = 0 ; + btEmptyAlgorithm *_swig_go_result; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + + result = (btEmptyAlgorithm *)new btEmptyAlgorithm((btCollisionAlgorithmConstructionInfo const &)*arg1); + *(btEmptyAlgorithm **)&_swig_go_result = (btEmptyAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_btEmptyAlgorithm_processCollision_mbt_e879218550ba2e2b(btEmptyAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btEmptyAlgorithm *arg1 = (btEmptyAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btEmptyAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btEmptyAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btEmptyAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btEmptyAlgorithm *arg1 = (btEmptyAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btEmptyAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btEmptyAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btEmptyAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btEmptyAlgorithm *arg1 = (btEmptyAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btEmptyAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +void _wrap_delete_btEmptyAlgorithm_mbt_e879218550ba2e2b(btEmptyAlgorithm *_swig_go_0) { + btEmptyAlgorithm *arg1 = (btEmptyAlgorithm *) 0 ; + + arg1 = *(btEmptyAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConvexTriangleCallback_m_triangleCount_set_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0, intgo _swig_go_1) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + int arg2 ; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_triangleCount = arg2; + +} + + +intgo _wrap_btConvexTriangleCallback_m_triangleCount_get_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + + result = (int) ((arg1)->m_triangleCount); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexTriangleCallback_m_manifoldPtr_set_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0, btPersistentManifold *_swig_go_1) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + btPersistentManifold *arg2 = (btPersistentManifold *) 0 ; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + arg2 = *(btPersistentManifold **)&_swig_go_1; + + if (arg1) (arg1)->m_manifoldPtr = arg2; + +} + + +btPersistentManifold *_wrap_btConvexTriangleCallback_m_manifoldPtr_get_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + btPersistentManifold *result = 0 ; + btPersistentManifold *_swig_go_result; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + + result = (btPersistentManifold *) ((arg1)->m_manifoldPtr); + *(btPersistentManifold **)&_swig_go_result = (btPersistentManifold *)result; + return _swig_go_result; +} + + +btConvexTriangleCallback *_wrap_new_btConvexTriangleCallback_mbt_e879218550ba2e2b(btDispatcher *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, bool _swig_go_3) { + btDispatcher *arg1 = (btDispatcher *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + bool arg4 ; + btConvexTriangleCallback *result = 0 ; + btConvexTriangleCallback *_swig_go_result; + + arg1 = *(btDispatcher **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = (bool)_swig_go_3; + + result = (btConvexTriangleCallback *)new btConvexTriangleCallback(arg1,(btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,arg4); + *(btConvexTriangleCallback **)&_swig_go_result = (btConvexTriangleCallback *)result; + return _swig_go_result; +} + + +void _wrap_btConvexTriangleCallback_setTimeStepAndCounters_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0, float _swig_go_1, btDispatcherInfo *_swig_go_2, btCollisionObjectWrapper *_swig_go_3, btCollisionObjectWrapper *_swig_go_4, btManifoldResult *_swig_go_5) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + btScalar arg2 ; + btDispatcherInfo *arg3 = 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg5 = (btCollisionObjectWrapper *) 0 ; + btManifoldResult *arg6 = (btManifoldResult *) 0 ; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btDispatcherInfo **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + arg5 = *(btCollisionObjectWrapper **)&_swig_go_4; + arg6 = *(btManifoldResult **)&_swig_go_5; + + (arg1)->setTimeStepAndCounters(arg2,(btDispatcherInfo const &)*arg3,(btCollisionObjectWrapper const *)arg4,(btCollisionObjectWrapper const *)arg5,arg6); + +} + + +void _wrap_btConvexTriangleCallback_clearWrapperData_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + + (arg1)->clearWrapperData(); + +} + + +void _wrap_delete_btConvexTriangleCallback_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConvexTriangleCallback_processTriangle_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0, btVector3 *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + int arg3 ; + int arg4 ; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + + (arg1)->processTriangle(arg2,arg3,arg4); + +} + + +void _wrap_btConvexTriangleCallback_clearCache_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + + (arg1)->clearCache(); + +} + + +btVector3 *_wrap_btConvexTriangleCallback_getAabbMin_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + + result = (btVector3 *) &((btConvexTriangleCallback const *)arg1)->getAabbMin(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btConvexTriangleCallback_getAabbMax_mbt_e879218550ba2e2b(btConvexTriangleCallback *_swig_go_0) { + btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btConvexTriangleCallback **)&_swig_go_0; + + result = (btVector3 *) &((btConvexTriangleCallback const *)arg1)->getAabbMax(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btConvexConcaveCollisionAlgorithm *_wrap_new_btConvexConcaveCollisionAlgorithm_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, bool _swig_go_3) { + btCollisionAlgorithmConstructionInfo *arg1 = 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + bool arg4 ; + btConvexConcaveCollisionAlgorithm *result = 0 ; + btConvexConcaveCollisionAlgorithm *_swig_go_result; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = (bool)_swig_go_3; + + result = (btConvexConcaveCollisionAlgorithm *)new btConvexConcaveCollisionAlgorithm((btCollisionAlgorithmConstructionInfo const &)*arg1,(btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,arg4); + *(btConvexConcaveCollisionAlgorithm **)&_swig_go_result = (btConvexConcaveCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_delete_btConvexConcaveCollisionAlgorithm_mbt_e879218550ba2e2b(btConvexConcaveCollisionAlgorithm *_swig_go_0) { + btConvexConcaveCollisionAlgorithm *arg1 = (btConvexConcaveCollisionAlgorithm *) 0 ; + + arg1 = *(btConvexConcaveCollisionAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConvexConcaveCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(btConvexConcaveCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btConvexConcaveCollisionAlgorithm *arg1 = (btConvexConcaveCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btConvexConcaveCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btConvexConcaveCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btConvexConcaveCollisionAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btConvexConcaveCollisionAlgorithm *arg1 = (btConvexConcaveCollisionAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexConcaveCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexConcaveCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btConvexConcaveCollisionAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btConvexConcaveCollisionAlgorithm *arg1 = (btConvexConcaveCollisionAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btConvexConcaveCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +void _wrap_btConvexConcaveCollisionAlgorithm_clearCache_mbt_e879218550ba2e2b(btConvexConcaveCollisionAlgorithm *_swig_go_0) { + btConvexConcaveCollisionAlgorithm *arg1 = (btConvexConcaveCollisionAlgorithm *) 0 ; + + arg1 = *(btConvexConcaveCollisionAlgorithm **)&_swig_go_0; + + (arg1)->clearCache(); + +} + + +void _wrap_gCompoundChildShapePairCallback_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + btShapePairCallback arg1 = (btShapePairCallback) 0 ; + + arg1 = *(btShapePairCallback *)&_swig_go_0; + + gCompoundChildShapePairCallback = arg1; + +} + + +void* _wrap_gCompoundChildShapePairCallback_get_mbt_e879218550ba2e2b() { + btShapePairCallback result; + void* _swig_go_result; + + + result = (btShapePairCallback)gCompoundChildShapePairCallback; + *(btShapePairCallback *)&_swig_go_result = (btShapePairCallback)result; + return _swig_go_result; +} + + +btCompoundCollisionAlgorithm *_wrap_new_btCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, bool _swig_go_3) { + btCollisionAlgorithmConstructionInfo *arg1 = 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + bool arg4 ; + btCompoundCollisionAlgorithm *result = 0 ; + btCompoundCollisionAlgorithm *_swig_go_result; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = (bool)_swig_go_3; + + result = (btCompoundCollisionAlgorithm *)new btCompoundCollisionAlgorithm((btCollisionAlgorithmConstructionInfo const &)*arg1,(btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,arg4); + *(btCompoundCollisionAlgorithm **)&_swig_go_result = (btCompoundCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(btCompoundCollisionAlgorithm *_swig_go_0) { + btCompoundCollisionAlgorithm *arg1 = (btCompoundCollisionAlgorithm *) 0 ; + + arg1 = *(btCompoundCollisionAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +btCollisionAlgorithm *_wrap_btCompoundCollisionAlgorithm_getChildAlgorithm_mbt_e879218550ba2e2b(btCompoundCollisionAlgorithm *_swig_go_0, intgo _swig_go_1) { + btCompoundCollisionAlgorithm *arg1 = (btCompoundCollisionAlgorithm *) 0 ; + int arg2 ; + btCollisionAlgorithm *result = 0 ; + btCollisionAlgorithm *_swig_go_result; + + arg1 = *(btCompoundCollisionAlgorithm **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btCollisionAlgorithm *)((btCompoundCollisionAlgorithm const *)arg1)->getChildAlgorithm(arg2); + *(btCollisionAlgorithm **)&_swig_go_result = (btCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_btCompoundCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(btCompoundCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btCompoundCollisionAlgorithm *arg1 = (btCompoundCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btCompoundCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btCompoundCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btCompoundCollisionAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btCompoundCollisionAlgorithm *arg1 = (btCompoundCollisionAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCompoundCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCompoundCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btCompoundCollisionAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btCompoundCollisionAlgorithm *arg1 = (btCompoundCollisionAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btCompoundCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +intgo _wrap_BT_SIMPLE_NULL_PAIR_get_mbt_e879218550ba2e2b() { + int result; + intgo _swig_go_result; + + + result = (int)(int)BT_SIMPLE_NULL_PAIR; + _swig_go_result = result; + return _swig_go_result; +} + + +btSimplePair *_wrap_new_btSimplePair_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1) { + int arg1 ; + int arg2 ; + btSimplePair *result = 0 ; + btSimplePair *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btSimplePair *)new btSimplePair(arg1,arg2); + *(btSimplePair **)&_swig_go_result = (btSimplePair *)result; + return _swig_go_result; +} + + +void _wrap_btSimplePair_m_indexA_set_mbt_e879218550ba2e2b(btSimplePair *_swig_go_0, intgo _swig_go_1) { + btSimplePair *arg1 = (btSimplePair *) 0 ; + int arg2 ; + + arg1 = *(btSimplePair **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_indexA = arg2; + +} + + +intgo _wrap_btSimplePair_m_indexA_get_mbt_e879218550ba2e2b(btSimplePair *_swig_go_0) { + btSimplePair *arg1 = (btSimplePair *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSimplePair **)&_swig_go_0; + + result = (int) ((arg1)->m_indexA); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSimplePair_m_indexB_set_mbt_e879218550ba2e2b(btSimplePair *_swig_go_0, intgo _swig_go_1) { + btSimplePair *arg1 = (btSimplePair *) 0 ; + int arg2 ; + + arg1 = *(btSimplePair **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + if (arg1) (arg1)->m_indexB = arg2; + +} + + +intgo _wrap_btSimplePair_m_indexB_get_mbt_e879218550ba2e2b(btSimplePair *_swig_go_0) { + btSimplePair *arg1 = (btSimplePair *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSimplePair **)&_swig_go_0; + + result = (int) ((arg1)->m_indexB); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btSimplePair_mbt_e879218550ba2e2b(btSimplePair *_swig_go_0) { + btSimplePair *arg1 = (btSimplePair *) 0 ; + + arg1 = *(btSimplePair **)&_swig_go_0; + + delete arg1; + +} + + +btHashedSimplePairCache *_wrap_new_btHashedSimplePairCache_mbt_e879218550ba2e2b() { + btHashedSimplePairCache *result = 0 ; + btHashedSimplePairCache *_swig_go_result; + + + result = (btHashedSimplePairCache *)new btHashedSimplePairCache(); + *(btHashedSimplePairCache **)&_swig_go_result = (btHashedSimplePairCache *)result; + return _swig_go_result; +} + + +void _wrap_delete_btHashedSimplePairCache_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btHashedSimplePairCache_removeAllPairs_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + + (arg1)->removeAllPairs(); + +} + + +void *_wrap_btHashedSimplePairCache_removeOverlappingPair_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + int arg2 ; + int arg3 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (void *)(arg1)->removeOverlappingPair(arg2,arg3); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +btSimplePair *_wrap_btHashedSimplePairCache_addOverlappingPair_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + int arg2 ; + int arg3 ; + btSimplePair *result = 0 ; + btSimplePair *_swig_go_result; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btSimplePair *)(arg1)->addOverlappingPair(arg2,arg3); + *(btSimplePair **)&_swig_go_result = (btSimplePair *)result; + return _swig_go_result; +} + + +btSimplePair *_wrap_btHashedSimplePairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + btSimplePair *result = 0 ; + btSimplePair *_swig_go_result; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + + result = (btSimplePair *)(arg1)->getOverlappingPairArrayPtr(); + *(btSimplePair **)&_swig_go_result = (btSimplePair *)result; + return _swig_go_result; +} + + +btSimplePair *_wrap_btHashedSimplePairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + btSimplePair *result = 0 ; + btSimplePair *_swig_go_result; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + + result = (btSimplePair *)((btHashedSimplePairCache const *)arg1)->getOverlappingPairArrayPtr(); + *(btSimplePair **)&_swig_go_result = (btSimplePair *)result; + return _swig_go_result; +} + + +btAlignedObjectArray< btSimplePair > *_wrap_btHashedSimplePairCache_getOverlappingPairArray__SWIG_0_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + btSimplePairArray *result = 0 ; + btAlignedObjectArray< btSimplePair > *_swig_go_result; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + + result = (btSimplePairArray *) &(arg1)->getOverlappingPairArray(); + *(btSimplePairArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +btAlignedObjectArray< btSimplePair > *_wrap_btHashedSimplePairCache_getOverlappingPairArray__SWIG_1_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + btSimplePairArray *result = 0 ; + btAlignedObjectArray< btSimplePair > *_swig_go_result; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + + result = (btSimplePairArray *) &((btHashedSimplePairCache const *)arg1)->getOverlappingPairArray(); + *(btSimplePairArray **)&_swig_go_result = result; + return _swig_go_result; +} + + +btSimplePair *_wrap_btHashedSimplePairCache_findPair_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + int arg2 ; + int arg3 ; + btSimplePair *result = 0 ; + btSimplePair *_swig_go_result; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + result = (btSimplePair *)(arg1)->findPair(arg2,arg3); + *(btSimplePair **)&_swig_go_result = (btSimplePair *)result; + return _swig_go_result; +} + + +intgo _wrap_btHashedSimplePairCache_GetCount_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + + result = (int)((btHashedSimplePairCache const *)arg1)->GetCount(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btHashedSimplePairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(btHashedSimplePairCache *_swig_go_0) { + btHashedSimplePairCache *arg1 = (btHashedSimplePairCache *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btHashedSimplePairCache **)&_swig_go_0; + + result = (int)((btHashedSimplePairCache const *)arg1)->getNumOverlappingPairs(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_gCompoundCompoundChildShapePairCallback_set_mbt_e879218550ba2e2b(void* _swig_go_0) { + btShapePairCallback arg1 = (btShapePairCallback) 0 ; + + arg1 = *(btShapePairCallback *)&_swig_go_0; + + gCompoundCompoundChildShapePairCallback = arg1; + +} + + +void* _wrap_gCompoundCompoundChildShapePairCallback_get_mbt_e879218550ba2e2b() { + btShapePairCallback result; + void* _swig_go_result; + + + result = (btShapePairCallback)gCompoundCompoundChildShapePairCallback; + *(btShapePairCallback *)&_swig_go_result = (btShapePairCallback)result; + return _swig_go_result; +} + + +btCompoundCompoundCollisionAlgorithm *_wrap_new_btCompoundCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, bool _swig_go_3) { + btCollisionAlgorithmConstructionInfo *arg1 = 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + bool arg4 ; + btCompoundCompoundCollisionAlgorithm *result = 0 ; + btCompoundCompoundCollisionAlgorithm *_swig_go_result; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = (bool)_swig_go_3; + + result = (btCompoundCompoundCollisionAlgorithm *)new btCompoundCompoundCollisionAlgorithm((btCollisionAlgorithmConstructionInfo const &)*arg1,(btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,arg4); + *(btCompoundCompoundCollisionAlgorithm **)&_swig_go_result = (btCompoundCompoundCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCompoundCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(btCompoundCompoundCollisionAlgorithm *_swig_go_0) { + btCompoundCompoundCollisionAlgorithm *arg1 = (btCompoundCompoundCollisionAlgorithm *) 0 ; + + arg1 = *(btCompoundCompoundCollisionAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btCompoundCompoundCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(btCompoundCompoundCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btCompoundCompoundCollisionAlgorithm *arg1 = (btCompoundCompoundCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btCompoundCompoundCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btCompoundCompoundCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btCompoundCompoundCollisionAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btCompoundCompoundCollisionAlgorithm *arg1 = (btCompoundCompoundCollisionAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btCompoundCompoundCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btCompoundCompoundCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btCompoundCompoundCollisionAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btCompoundCompoundCollisionAlgorithm *arg1 = (btCompoundCompoundCollisionAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btCompoundCompoundCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +btCollisionAlgorithm *_wrap_btCompoundCompoundCollisionAlgorithm_getChildAlgorithm_mbt_e879218550ba2e2b(btCompoundCompoundCollisionAlgorithm *_swig_go_0, intgo _swig_go_1) { + btCompoundCompoundCollisionAlgorithm *arg1 = (btCompoundCompoundCollisionAlgorithm *) 0 ; + int arg2 ; + btCollisionAlgorithm *result = 0 ; + btCollisionAlgorithm *_swig_go_result; + + arg1 = *(btCompoundCompoundCollisionAlgorithm **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btCompoundCollisionAlgorithm *swig_b0 = (btCompoundCollisionAlgorithm *)arg1; + result = (btCollisionAlgorithm *)((btCompoundCollisionAlgorithm const *)swig_b0)->getChildAlgorithm(arg2); + *(btCollisionAlgorithm **)&_swig_go_result = (btCollisionAlgorithm *)result; + return _swig_go_result; +} + + +btConvexPlaneCollisionAlgorithm *_wrap_new_btConvexPlaneCollisionAlgorithm_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btCollisionAlgorithmConstructionInfo *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionObjectWrapper *_swig_go_3, bool _swig_go_4, intgo _swig_go_5, intgo _swig_go_6) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btCollisionAlgorithmConstructionInfo *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + bool arg5 ; + int arg6 ; + int arg7 ; + btConvexPlaneCollisionAlgorithm *result = 0 ; + btConvexPlaneCollisionAlgorithm *_swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + arg6 = (int)_swig_go_5; + arg7 = (int)_swig_go_6; + + result = (btConvexPlaneCollisionAlgorithm *)new btConvexPlaneCollisionAlgorithm(arg1,(btCollisionAlgorithmConstructionInfo const &)*arg2,(btCollisionObjectWrapper const *)arg3,(btCollisionObjectWrapper const *)arg4,arg5,arg6,arg7); + *(btConvexPlaneCollisionAlgorithm **)&_swig_go_result = (btConvexPlaneCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_delete_btConvexPlaneCollisionAlgorithm_mbt_e879218550ba2e2b(btConvexPlaneCollisionAlgorithm *_swig_go_0) { + btConvexPlaneCollisionAlgorithm *arg1 = (btConvexPlaneCollisionAlgorithm *) 0 ; + + arg1 = *(btConvexPlaneCollisionAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btConvexPlaneCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(btConvexPlaneCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btConvexPlaneCollisionAlgorithm *arg1 = (btConvexPlaneCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btConvexPlaneCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +void _wrap_btConvexPlaneCollisionAlgorithm_collideSingleContact_mbt_e879218550ba2e2b(btConvexPlaneCollisionAlgorithm *_swig_go_0, btQuaternion *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionObjectWrapper *_swig_go_3, btDispatcherInfo *_swig_go_4, btManifoldResult *_swig_go_5) { + btConvexPlaneCollisionAlgorithm *arg1 = (btConvexPlaneCollisionAlgorithm *) 0 ; + btQuaternion *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg5 = 0 ; + btManifoldResult *arg6 = (btManifoldResult *) 0 ; + + arg1 = *(btConvexPlaneCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btQuaternion **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + arg5 = *(btDispatcherInfo **)&_swig_go_4; + arg6 = *(btManifoldResult **)&_swig_go_5; + + (arg1)->collideSingleContact((btQuaternion const &)*arg2,(btCollisionObjectWrapper const *)arg3,(btCollisionObjectWrapper const *)arg4,(btDispatcherInfo const &)*arg5,arg6); + +} + + +float _wrap_btConvexPlaneCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btConvexPlaneCollisionAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btConvexPlaneCollisionAlgorithm *arg1 = (btConvexPlaneCollisionAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btConvexPlaneCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btConvexPlaneCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btConvexPlaneCollisionAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btConvexPlaneCollisionAlgorithm *arg1 = (btConvexPlaneCollisionAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btConvexPlaneCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +btBoxBoxCollisionAlgorithm *_wrap_new_btBoxBoxCollisionAlgorithm__SWIG_0_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0) { + btCollisionAlgorithmConstructionInfo *arg1 = 0 ; + btBoxBoxCollisionAlgorithm *result = 0 ; + btBoxBoxCollisionAlgorithm *_swig_go_result; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + + result = (btBoxBoxCollisionAlgorithm *)new btBoxBoxCollisionAlgorithm((btCollisionAlgorithmConstructionInfo const &)*arg1); + *(btBoxBoxCollisionAlgorithm **)&_swig_go_result = (btBoxBoxCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_btBoxBoxCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(btBoxBoxCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btBoxBoxCollisionAlgorithm *arg1 = (btBoxBoxCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btBoxBoxCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btBoxBoxCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btBoxBoxCollisionAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btBoxBoxCollisionAlgorithm *arg1 = (btBoxBoxCollisionAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btBoxBoxCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +btBoxBoxCollisionAlgorithm *_wrap_new_btBoxBoxCollisionAlgorithm__SWIG_1_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btCollisionAlgorithmConstructionInfo *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionObjectWrapper *_swig_go_3) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btCollisionAlgorithmConstructionInfo *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + btBoxBoxCollisionAlgorithm *result = 0 ; + btBoxBoxCollisionAlgorithm *_swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + + result = (btBoxBoxCollisionAlgorithm *)new btBoxBoxCollisionAlgorithm(arg1,(btCollisionAlgorithmConstructionInfo const &)*arg2,(btCollisionObjectWrapper const *)arg3,(btCollisionObjectWrapper const *)arg4); + *(btBoxBoxCollisionAlgorithm **)&_swig_go_result = (btBoxBoxCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_delete_btBoxBoxCollisionAlgorithm_mbt_e879218550ba2e2b(btBoxBoxCollisionAlgorithm *_swig_go_0) { + btBoxBoxCollisionAlgorithm *arg1 = (btBoxBoxCollisionAlgorithm *) 0 ; + + arg1 = *(btBoxBoxCollisionAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btBoxBoxCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btBoxBoxCollisionAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btBoxBoxCollisionAlgorithm *arg1 = (btBoxBoxCollisionAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btBoxBoxCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +btSphereSphereCollisionAlgorithm *_wrap_new_btSphereSphereCollisionAlgorithm__SWIG_0_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btCollisionAlgorithmConstructionInfo *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionObjectWrapper *_swig_go_3) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btCollisionAlgorithmConstructionInfo *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + btSphereSphereCollisionAlgorithm *result = 0 ; + btSphereSphereCollisionAlgorithm *_swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + + result = (btSphereSphereCollisionAlgorithm *)new btSphereSphereCollisionAlgorithm(arg1,(btCollisionAlgorithmConstructionInfo const &)*arg2,(btCollisionObjectWrapper const *)arg3,(btCollisionObjectWrapper const *)arg4); + *(btSphereSphereCollisionAlgorithm **)&_swig_go_result = (btSphereSphereCollisionAlgorithm *)result; + return _swig_go_result; +} + + +btSphereSphereCollisionAlgorithm *_wrap_new_btSphereSphereCollisionAlgorithm__SWIG_1_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0) { + btCollisionAlgorithmConstructionInfo *arg1 = 0 ; + btSphereSphereCollisionAlgorithm *result = 0 ; + btSphereSphereCollisionAlgorithm *_swig_go_result; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + + result = (btSphereSphereCollisionAlgorithm *)new btSphereSphereCollisionAlgorithm((btCollisionAlgorithmConstructionInfo const &)*arg1); + *(btSphereSphereCollisionAlgorithm **)&_swig_go_result = (btSphereSphereCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_btSphereSphereCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(btSphereSphereCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btSphereSphereCollisionAlgorithm *arg1 = (btSphereSphereCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btSphereSphereCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btSphereSphereCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btSphereSphereCollisionAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btSphereSphereCollisionAlgorithm *arg1 = (btSphereSphereCollisionAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSphereSphereCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSphereSphereCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btSphereSphereCollisionAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btSphereSphereCollisionAlgorithm *arg1 = (btSphereSphereCollisionAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btSphereSphereCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +void _wrap_delete_btSphereSphereCollisionAlgorithm_mbt_e879218550ba2e2b(btSphereSphereCollisionAlgorithm *_swig_go_0) { + btSphereSphereCollisionAlgorithm *arg1 = (btSphereSphereCollisionAlgorithm *) 0 ; + + arg1 = *(btSphereSphereCollisionAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +btSphereBoxCollisionAlgorithm *_wrap_new_btSphereBoxCollisionAlgorithm_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btCollisionAlgorithmConstructionInfo *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionObjectWrapper *_swig_go_3, bool _swig_go_4) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btCollisionAlgorithmConstructionInfo *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + bool arg5 ; + btSphereBoxCollisionAlgorithm *result = 0 ; + btSphereBoxCollisionAlgorithm *_swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + + result = (btSphereBoxCollisionAlgorithm *)new btSphereBoxCollisionAlgorithm(arg1,(btCollisionAlgorithmConstructionInfo const &)*arg2,(btCollisionObjectWrapper const *)arg3,(btCollisionObjectWrapper const *)arg4,arg5); + *(btSphereBoxCollisionAlgorithm **)&_swig_go_result = (btSphereBoxCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_delete_btSphereBoxCollisionAlgorithm_mbt_e879218550ba2e2b(btSphereBoxCollisionAlgorithm *_swig_go_0) { + btSphereBoxCollisionAlgorithm *arg1 = (btSphereBoxCollisionAlgorithm *) 0 ; + + arg1 = *(btSphereBoxCollisionAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btSphereBoxCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(btSphereBoxCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btSphereBoxCollisionAlgorithm *arg1 = (btSphereBoxCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btSphereBoxCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btSphereBoxCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btSphereBoxCollisionAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btSphereBoxCollisionAlgorithm *arg1 = (btSphereBoxCollisionAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSphereBoxCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSphereBoxCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btSphereBoxCollisionAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btSphereBoxCollisionAlgorithm *arg1 = (btSphereBoxCollisionAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btSphereBoxCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +bool _wrap_btSphereBoxCollisionAlgorithm_getSphereDistance_mbt_e879218550ba2e2b(btSphereBoxCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, float _swig_go_6, float _swig_go_7) { + btSphereBoxCollisionAlgorithm *arg1 = (btSphereBoxCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btScalar arg7 ; + btScalar arg8 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSphereBoxCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + + result = (bool)(arg1)->getSphereDistance((btCollisionObjectWrapper const *)arg2,*arg3,*arg4,*arg5,(btVector3 const &)*arg6,arg7,arg8); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btSphereBoxCollisionAlgorithm_getSpherePenetration_mbt_e879218550ba2e2b(btSphereBoxCollisionAlgorithm *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4) { + btSphereBoxCollisionAlgorithm *arg1 = (btSphereBoxCollisionAlgorithm *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSphereBoxCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + result = (btScalar)(arg1)->getSpherePenetration((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,*arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +btSphereTriangleCollisionAlgorithm *_wrap_new_btSphereTriangleCollisionAlgorithm__SWIG_0_mbt_e879218550ba2e2b(btPersistentManifold *_swig_go_0, btCollisionAlgorithmConstructionInfo *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btCollisionObjectWrapper *_swig_go_3, bool _swig_go_4) { + btPersistentManifold *arg1 = (btPersistentManifold *) 0 ; + btCollisionAlgorithmConstructionInfo *arg2 = 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg4 = (btCollisionObjectWrapper *) 0 ; + bool arg5 ; + btSphereTriangleCollisionAlgorithm *result = 0 ; + btSphereTriangleCollisionAlgorithm *_swig_go_result; + + arg1 = *(btPersistentManifold **)&_swig_go_0; + arg2 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btCollisionObjectWrapper **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + + result = (btSphereTriangleCollisionAlgorithm *)new btSphereTriangleCollisionAlgorithm(arg1,(btCollisionAlgorithmConstructionInfo const &)*arg2,(btCollisionObjectWrapper const *)arg3,(btCollisionObjectWrapper const *)arg4,arg5); + *(btSphereTriangleCollisionAlgorithm **)&_swig_go_result = (btSphereTriangleCollisionAlgorithm *)result; + return _swig_go_result; +} + + +btSphereTriangleCollisionAlgorithm *_wrap_new_btSphereTriangleCollisionAlgorithm__SWIG_1_mbt_e879218550ba2e2b(btCollisionAlgorithmConstructionInfo *_swig_go_0) { + btCollisionAlgorithmConstructionInfo *arg1 = 0 ; + btSphereTriangleCollisionAlgorithm *result = 0 ; + btSphereTriangleCollisionAlgorithm *_swig_go_result; + + arg1 = *(btCollisionAlgorithmConstructionInfo **)&_swig_go_0; + + result = (btSphereTriangleCollisionAlgorithm *)new btSphereTriangleCollisionAlgorithm((btCollisionAlgorithmConstructionInfo const &)*arg1); + *(btSphereTriangleCollisionAlgorithm **)&_swig_go_result = (btSphereTriangleCollisionAlgorithm *)result; + return _swig_go_result; +} + + +void _wrap_btSphereTriangleCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(btSphereTriangleCollisionAlgorithm *_swig_go_0, btCollisionObjectWrapper *_swig_go_1, btCollisionObjectWrapper *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btSphereTriangleCollisionAlgorithm *arg1 = (btSphereTriangleCollisionAlgorithm *) 0 ; + btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; + btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + + arg1 = *(btSphereTriangleCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObjectWrapper **)&_swig_go_1; + arg3 = *(btCollisionObjectWrapper **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); + +} + + +float _wrap_btSphereTriangleCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(btSphereTriangleCollisionAlgorithm *_swig_go_0, btCollisionObject *_swig_go_1, btCollisionObject *_swig_go_2, btDispatcherInfo *_swig_go_3, btManifoldResult *_swig_go_4) { + btSphereTriangleCollisionAlgorithm *arg1 = (btSphereTriangleCollisionAlgorithm *) 0 ; + btCollisionObject *arg2 = (btCollisionObject *) 0 ; + btCollisionObject *arg3 = (btCollisionObject *) 0 ; + btDispatcherInfo *arg4 = 0 ; + btManifoldResult *arg5 = (btManifoldResult *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSphereTriangleCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btCollisionObject **)&_swig_go_1; + arg3 = *(btCollisionObject **)&_swig_go_2; + arg4 = *(btDispatcherInfo **)&_swig_go_3; + arg5 = *(btManifoldResult **)&_swig_go_4; + + result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSphereTriangleCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(btSphereTriangleCollisionAlgorithm *_swig_go_0, btAlignedObjectArray< btPersistentManifold * > *_swig_go_1) { + btSphereTriangleCollisionAlgorithm *arg1 = (btSphereTriangleCollisionAlgorithm *) 0 ; + btManifoldArray *arg2 = 0 ; + + arg1 = *(btSphereTriangleCollisionAlgorithm **)&_swig_go_0; + arg2 = *(btManifoldArray **)&_swig_go_1; + + (arg1)->getAllContactManifolds(*arg2); + +} + + +void _wrap_delete_btSphereTriangleCollisionAlgorithm_mbt_e879218550ba2e2b(btSphereTriangleCollisionAlgorithm *_swig_go_0) { + btSphereTriangleCollisionAlgorithm *arg1 = (btSphereTriangleCollisionAlgorithm *) 0 ; + + arg1 = *(btSphereTriangleCollisionAlgorithm **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_delete_btConvexPenetrationDepthSolver_mbt_e879218550ba2e2b(btConvexPenetrationDepthSolver *_swig_go_0) { + btConvexPenetrationDepthSolver *arg1 = (btConvexPenetrationDepthSolver *) 0 ; + + arg1 = *(btConvexPenetrationDepthSolver **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btConvexPenetrationDepthSolver_calcPenDepth_mbt_e879218550ba2e2b(btConvexPenetrationDepthSolver *_swig_go_0, btVoronoiSimplexSolver *_swig_go_1, btConvexShape *_swig_go_2, btConvexShape *_swig_go_3, btTransform *_swig_go_4, btTransform *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7, btVector3 *_swig_go_8, btIDebugDraw *_swig_go_9) { + btConvexPenetrationDepthSolver *arg1 = (btConvexPenetrationDepthSolver *) 0 ; + btVoronoiSimplexSolver *arg2 = 0 ; + btConvexShape *arg3 = (btConvexShape *) 0 ; + btConvexShape *arg4 = (btConvexShape *) 0 ; + btTransform *arg5 = 0 ; + btTransform *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + btVector3 *arg9 = 0 ; + btIDebugDraw *arg10 = (btIDebugDraw *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btConvexPenetrationDepthSolver **)&_swig_go_0; + arg2 = *(btVoronoiSimplexSolver **)&_swig_go_1; + arg3 = *(btConvexShape **)&_swig_go_2; + arg4 = *(btConvexShape **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btTransform **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = *(btVector3 **)&_swig_go_8; + arg10 = *(btIDebugDraw **)&_swig_go_9; + + result = (bool)(arg1)->calcPenDepth(*arg2,(btConvexShape const *)arg3,(btConvexShape const *)arg4,(btTransform const &)*arg5,(btTransform const &)*arg6,*arg7,*arg8,*arg9,arg10); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btMinkowskiPenetrationDepthSolver_calcPenDepth_mbt_e879218550ba2e2b(btMinkowskiPenetrationDepthSolver *_swig_go_0, btVoronoiSimplexSolver *_swig_go_1, btConvexShape *_swig_go_2, btConvexShape *_swig_go_3, btTransform *_swig_go_4, btTransform *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7, btVector3 *_swig_go_8, btIDebugDraw *_swig_go_9) { + btMinkowskiPenetrationDepthSolver *arg1 = (btMinkowskiPenetrationDepthSolver *) 0 ; + btVoronoiSimplexSolver *arg2 = 0 ; + btConvexShape *arg3 = (btConvexShape *) 0 ; + btConvexShape *arg4 = (btConvexShape *) 0 ; + btTransform *arg5 = 0 ; + btTransform *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + btVector3 *arg9 = 0 ; + btIDebugDraw *arg10 = (btIDebugDraw *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btMinkowskiPenetrationDepthSolver **)&_swig_go_0; + arg2 = *(btVoronoiSimplexSolver **)&_swig_go_1; + arg3 = *(btConvexShape **)&_swig_go_2; + arg4 = *(btConvexShape **)&_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btTransform **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = *(btVector3 **)&_swig_go_8; + arg10 = *(btIDebugDraw **)&_swig_go_9; + + result = (bool)(arg1)->calcPenDepth(*arg2,(btConvexShape const *)arg3,(btConvexShape const *)arg4,(btTransform const &)*arg5,(btTransform const &)*arg6,*arg7,*arg8,*arg9,arg10); + _swig_go_result = result; + return _swig_go_result; +} + + +btMinkowskiPenetrationDepthSolver *_wrap_new_btMinkowskiPenetrationDepthSolver_mbt_e879218550ba2e2b() { + btMinkowskiPenetrationDepthSolver *result = 0 ; + btMinkowskiPenetrationDepthSolver *_swig_go_result; + + + result = (btMinkowskiPenetrationDepthSolver *)new btMinkowskiPenetrationDepthSolver(); + *(btMinkowskiPenetrationDepthSolver **)&_swig_go_result = (btMinkowskiPenetrationDepthSolver *)result; + return _swig_go_result; +} + + +void _wrap_delete_btMinkowskiPenetrationDepthSolver_mbt_e879218550ba2e2b(btMinkowskiPenetrationDepthSolver *_swig_go_0) { + btMinkowskiPenetrationDepthSolver *arg1 = (btMinkowskiPenetrationDepthSolver *) 0 ; + + arg1 = *(btMinkowskiPenetrationDepthSolver **)&_swig_go_0; + + delete arg1; + +} + + +btPoolAllocator *_wrap_new_btPoolAllocator_mbt_e879218550ba2e2b(intgo _swig_go_0, intgo _swig_go_1) { + int arg1 ; + int arg2 ; + btPoolAllocator *result = 0 ; + btPoolAllocator *_swig_go_result; + + arg1 = (int)_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btPoolAllocator *)new btPoolAllocator(arg1,arg2); + *(btPoolAllocator **)&_swig_go_result = (btPoolAllocator *)result; + return _swig_go_result; +} + + +void _wrap_delete_btPoolAllocator_mbt_e879218550ba2e2b(btPoolAllocator *_swig_go_0) { + btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; + + arg1 = *(btPoolAllocator **)&_swig_go_0; + + delete arg1; + +} + + +intgo _wrap_btPoolAllocator_getFreeCount_mbt_e879218550ba2e2b(btPoolAllocator *_swig_go_0) { + btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPoolAllocator **)&_swig_go_0; + + result = (int)((btPoolAllocator const *)arg1)->getFreeCount(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btPoolAllocator_getUsedCount_mbt_e879218550ba2e2b(btPoolAllocator *_swig_go_0) { + btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPoolAllocator **)&_swig_go_0; + + result = (int)((btPoolAllocator const *)arg1)->getUsedCount(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btPoolAllocator_getMaxCount_mbt_e879218550ba2e2b(btPoolAllocator *_swig_go_0) { + btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPoolAllocator **)&_swig_go_0; + + result = (int)((btPoolAllocator const *)arg1)->getMaxCount(); + _swig_go_result = result; + return _swig_go_result; +} + + +void *_wrap_btPoolAllocator_allocate_mbt_e879218550ba2e2b(btPoolAllocator *_swig_go_0, intgo _swig_go_1) { + btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; + int arg2 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btPoolAllocator **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (void *)(arg1)->allocate(arg2); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +bool _wrap_btPoolAllocator_validPtr_mbt_e879218550ba2e2b(btPoolAllocator *_swig_go_0, void *_swig_go_1) { + btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; + void *arg2 = (void *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btPoolAllocator **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + result = (bool)(arg1)->validPtr(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btPoolAllocator_freeMemory_mbt_e879218550ba2e2b(btPoolAllocator *_swig_go_0, void *_swig_go_1) { + btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btPoolAllocator **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + (arg1)->freeMemory(arg2); + +} + + +intgo _wrap_btPoolAllocator_getElementSize_mbt_e879218550ba2e2b(btPoolAllocator *_swig_go_0) { + btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btPoolAllocator **)&_swig_go_0; + + result = (int)((btPoolAllocator const *)arg1)->getElementSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +char *_wrap_btPoolAllocator_getPoolAddress__SWIG_0_mbt_e879218550ba2e2b(btPoolAllocator *_swig_go_0) { + btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; + unsigned char *result = 0 ; + char *_swig_go_result; + + arg1 = *(btPoolAllocator **)&_swig_go_0; + + result = (unsigned char *)(arg1)->getPoolAddress(); + *(unsigned char **)&_swig_go_result = (unsigned char *)result; + return _swig_go_result; +} + + +char *_wrap_btPoolAllocator_getPoolAddress__SWIG_1_mbt_e879218550ba2e2b(btPoolAllocator *_swig_go_0) { + btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; + unsigned char *result = 0 ; + char *_swig_go_result; + + arg1 = *(btPoolAllocator **)&_swig_go_0; + + result = (unsigned char *)((btPoolAllocator const *)arg1)->getPoolAddress(); + *(unsigned char **)&_swig_go_result = (unsigned char *)result; + return _swig_go_result; +} + + +void _wrap_btMultiIndex_ijk_set_mbt_e879218550ba2e2b(btMultiIndex *_swig_go_0, intgo *_swig_go_1) { + btMultiIndex *arg1 = (btMultiIndex *) 0 ; + unsigned int *arg2 = (unsigned int *) (unsigned int *)0 ; + + arg1 = *(btMultiIndex **)&_swig_go_0; + arg2 = *(unsigned int **)&_swig_go_1; + + { + size_t ii; + unsigned int *b = (unsigned int *) arg1->ijk; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned int *) arg2 + ii); + } + +} + + +intgo *_wrap_btMultiIndex_ijk_get_mbt_e879218550ba2e2b(btMultiIndex *_swig_go_0) { + btMultiIndex *arg1 = (btMultiIndex *) 0 ; + unsigned int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btMultiIndex **)&_swig_go_0; + + result = (unsigned int *)(unsigned int *) ((arg1)->ijk); + *(unsigned int **)&_swig_go_result = result; + return _swig_go_result; +} + + +btMultiIndex *_wrap_new_btMultiIndex_mbt_e879218550ba2e2b() { + btMultiIndex *result = 0 ; + btMultiIndex *_swig_go_result; + + + result = (btMultiIndex *)new btMultiIndex(); + *(btMultiIndex **)&_swig_go_result = (btMultiIndex *)result; + return _swig_go_result; +} + + +void _wrap_delete_btMultiIndex_mbt_e879218550ba2e2b(btMultiIndex *_swig_go_0) { + btMultiIndex *arg1 = (btMultiIndex *) 0 ; + + arg1 = *(btMultiIndex **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btAlignedBox3d_m_min_set_mbt_e879218550ba2e2b(btAlignedBox3d *_swig_go_0, btVector3 *_swig_go_1) { + btAlignedBox3d *arg1 = (btAlignedBox3d *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btAlignedBox3d **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_min = *arg2; + +} + + +btVector3 *_wrap_btAlignedBox3d_m_min_get_mbt_e879218550ba2e2b(btAlignedBox3d *_swig_go_0) { + btAlignedBox3d *arg1 = (btAlignedBox3d *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btAlignedBox3d **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_min); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btAlignedBox3d_m_max_set_mbt_e879218550ba2e2b(btAlignedBox3d *_swig_go_0, btVector3 *_swig_go_1) { + btAlignedBox3d *arg1 = (btAlignedBox3d *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btAlignedBox3d **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_max = *arg2; + +} + + +btVector3 *_wrap_btAlignedBox3d_m_max_get_mbt_e879218550ba2e2b(btAlignedBox3d *_swig_go_0) { + btAlignedBox3d *arg1 = (btAlignedBox3d *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btAlignedBox3d **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_max); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +btVector3 *_wrap_btAlignedBox3d_min_mbt_e879218550ba2e2b(btAlignedBox3d *_swig_go_0) { + btAlignedBox3d *arg1 = (btAlignedBox3d *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btAlignedBox3d **)&_swig_go_0; + + result = (btVector3 *) &((btAlignedBox3d const *)arg1)->min(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btAlignedBox3d_max_mbt_e879218550ba2e2b(btAlignedBox3d *_swig_go_0) { + btAlignedBox3d *arg1 = (btAlignedBox3d *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btAlignedBox3d **)&_swig_go_0; + + result = (btVector3 *) &((btAlignedBox3d const *)arg1)->max(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btAlignedBox3d_contains_mbt_e879218550ba2e2b(btAlignedBox3d *_swig_go_0, btVector3 *_swig_go_1) { + btAlignedBox3d *arg1 = (btAlignedBox3d *) 0 ; + btVector3 *arg2 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btAlignedBox3d **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (bool)((btAlignedBox3d const *)arg1)->contains((btVector3 const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btAlignedBox3d *_wrap_new_btAlignedBox3d__SWIG_0_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btAlignedBox3d *result = 0 ; + btAlignedBox3d *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = (btAlignedBox3d *)new btAlignedBox3d((btVector3 const &)*arg1,(btVector3 const &)*arg2); + *(btAlignedBox3d **)&_swig_go_result = (btAlignedBox3d *)result; + return _swig_go_result; +} + + +btAlignedBox3d *_wrap_new_btAlignedBox3d__SWIG_1_mbt_e879218550ba2e2b() { + btAlignedBox3d *result = 0 ; + btAlignedBox3d *_swig_go_result; + + + result = (btAlignedBox3d *)new btAlignedBox3d(); + *(btAlignedBox3d **)&_swig_go_result = (btAlignedBox3d *)result; + return _swig_go_result; +} + + +void _wrap_delete_btAlignedBox3d_mbt_e879218550ba2e2b(btAlignedBox3d *_swig_go_0) { + btAlignedBox3d *arg1 = (btAlignedBox3d *) 0 ; + + arg1 = *(btAlignedBox3d **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btShapeMatrix_m_vec_set_mbt_e879218550ba2e2b(btShapeMatrix *_swig_go_0, double *_swig_go_1) { + btShapeMatrix *arg1 = (btShapeMatrix *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btShapeMatrix **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_vec; + for (ii = 0; ii < (size_t)32; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btShapeMatrix_m_vec_get_mbt_e879218550ba2e2b(btShapeMatrix *_swig_go_0) { + btShapeMatrix *arg1 = (btShapeMatrix *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btShapeMatrix **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_vec); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +btShapeMatrix *_wrap_new_btShapeMatrix_mbt_e879218550ba2e2b() { + btShapeMatrix *result = 0 ; + btShapeMatrix *_swig_go_result; + + + result = (btShapeMatrix *)new btShapeMatrix(); + *(btShapeMatrix **)&_swig_go_result = (btShapeMatrix *)result; + return _swig_go_result; +} + + +void _wrap_delete_btShapeMatrix_mbt_e879218550ba2e2b(btShapeMatrix *_swig_go_0) { + btShapeMatrix *arg1 = (btShapeMatrix *) 0 ; + + arg1 = *(btShapeMatrix **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btShapeGradients_m_vec_set_mbt_e879218550ba2e2b(btShapeGradients *_swig_go_0, btVector3 (*_swig_go_1)[32]) { + btShapeGradients *arg1 = (btShapeGradients *) 0 ; + btVector3 *arg2 = (btVector3 *) (btVector3 *)0 ; + + arg1 = *(btShapeGradients **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + { + size_t ii; + btVector3 *b = (btVector3 *) arg1->m_vec; + for (ii = 0; ii < (size_t)32; ii++) b[ii] = *((btVector3 *) arg2 + ii); + } + +} + + +btVector3 (*_wrap_btShapeGradients_m_vec_get_mbt_e879218550ba2e2b(btShapeGradients *_swig_go_0))[32] { + btShapeGradients *arg1 = (btShapeGradients *) 0 ; + btVector3 *result = 0 ; + btVector3 (*_swig_go_result)[32]; + + arg1 = *(btShapeGradients **)&_swig_go_0; + + result = (btVector3 *)(btVector3 *) ((arg1)->m_vec); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btShapeGradients_topRowsDivide_mbt_e879218550ba2e2b(btShapeGradients *_swig_go_0, intgo _swig_go_1, double _swig_go_2) { + btShapeGradients *arg1 = (btShapeGradients *) 0 ; + int arg2 ; + double arg3 ; + + arg1 = *(btShapeGradients **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (double)_swig_go_2; + + (arg1)->topRowsDivide(arg2,arg3); + +} + + +void _wrap_btShapeGradients_bottomRowsMul_mbt_e879218550ba2e2b(btShapeGradients *_swig_go_0, intgo _swig_go_1, double _swig_go_2) { + btShapeGradients *arg1 = (btShapeGradients *) 0 ; + int arg2 ; + double arg3 ; + + arg1 = *(btShapeGradients **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (double)_swig_go_2; + + (arg1)->bottomRowsMul(arg2,arg3); + +} + + +btShapeGradients *_wrap_new_btShapeGradients_mbt_e879218550ba2e2b() { + btShapeGradients *result = 0 ; + btShapeGradients *_swig_go_result; + + + result = (btShapeGradients *)new btShapeGradients(); + *(btShapeGradients **)&_swig_go_result = (btShapeGradients *)result; + return _swig_go_result; +} + + +void _wrap_delete_btShapeGradients_mbt_e879218550ba2e2b(btShapeGradients *_swig_go_0) { + btShapeGradients *arg1 = (btShapeGradients *) 0 ; + + arg1 = *(btShapeGradients **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btCell32_m_cells_set_mbt_e879218550ba2e2b(btCell32 *_swig_go_0, intgo *_swig_go_1) { + btCell32 *arg1 = (btCell32 *) 0 ; + unsigned int *arg2 = (unsigned int *) (unsigned int *)0 ; + + arg1 = *(btCell32 **)&_swig_go_0; + arg2 = *(unsigned int **)&_swig_go_1; + + { + size_t ii; + unsigned int *b = (unsigned int *) arg1->m_cells; + for (ii = 0; ii < (size_t)32; ii++) b[ii] = *((unsigned int *) arg2 + ii); + } + +} + + +intgo *_wrap_btCell32_m_cells_get_mbt_e879218550ba2e2b(btCell32 *_swig_go_0) { + btCell32 *arg1 = (btCell32 *) 0 ; + unsigned int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btCell32 **)&_swig_go_0; + + result = (unsigned int *)(unsigned int *) ((arg1)->m_cells); + *(unsigned int **)&_swig_go_result = result; + return _swig_go_result; +} + + +btCell32 *_wrap_new_btCell32_mbt_e879218550ba2e2b() { + btCell32 *result = 0 ; + btCell32 *_swig_go_result; + + + result = (btCell32 *)new btCell32(); + *(btCell32 **)&_swig_go_result = (btCell32 *)result; + return _swig_go_result; +} + + +void _wrap_delete_btCell32_mbt_e879218550ba2e2b(btCell32 *_swig_go_0) { + btCell32 *arg1 = (btCell32 *) 0 ; + + arg1 = *(btCell32 **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btMiniSDF_m_domain_set_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, btAlignedBox3d *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btAlignedBox3d *arg2 = (btAlignedBox3d *) 0 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(btAlignedBox3d **)&_swig_go_1; + + if (arg1) (arg1)->m_domain = *arg2; + +} + + +btAlignedBox3d *_wrap_btMiniSDF_m_domain_get_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btAlignedBox3d *result = 0 ; + btAlignedBox3d *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = (btAlignedBox3d *)& ((arg1)->m_domain); + *(btAlignedBox3d **)&_swig_go_result = (btAlignedBox3d *)result; + return _swig_go_result; +} + + +void _wrap_btMiniSDF_m_resolution_set_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, intgo *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + unsigned int *arg2 = (unsigned int *) (unsigned int *)0 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(unsigned int **)&_swig_go_1; + + { + size_t ii; + unsigned int *b = (unsigned int *) arg1->m_resolution; + for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned int *) arg2 + ii); + } + +} + + +intgo *_wrap_btMiniSDF_m_resolution_get_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + unsigned int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = (unsigned int *)(unsigned int *) ((arg1)->m_resolution); + *(unsigned int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btMiniSDF_m_cell_size_set_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, btVector3 *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_cell_size = *arg2; + +} + + +btVector3 *_wrap_btMiniSDF_m_cell_size_get_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_cell_size); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btMiniSDF_m_inv_cell_size_set_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, btVector3 *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_inv_cell_size = *arg2; + +} + + +btVector3 *_wrap_btMiniSDF_m_inv_cell_size_get_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_inv_cell_size); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btMiniSDF_m_n_cells_set_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, std::size_t *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + std::size_t arg2 ; + std::size_t *argp2 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + argp2 = (std::size_t *)_swig_go_1; + if (argp2 == NULL) { + _swig_gopanic("Attempt to dereference null std::size_t"); + } + arg2 = (std::size_t)*argp2; + + + if (arg1) (arg1)->m_n_cells = arg2; + +} + + +std::size_t *_wrap_btMiniSDF_m_n_cells_get_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + std::size_t result; + std::size_t *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = ((arg1)->m_n_cells); + *(std::size_t **)&_swig_go_result = new std::size_t(result); + return _swig_go_result; +} + + +void _wrap_btMiniSDF_m_n_fields_set_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, std::size_t *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + std::size_t arg2 ; + std::size_t *argp2 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + argp2 = (std::size_t *)_swig_go_1; + if (argp2 == NULL) { + _swig_gopanic("Attempt to dereference null std::size_t"); + } + arg2 = (std::size_t)*argp2; + + + if (arg1) (arg1)->m_n_fields = arg2; + +} + + +std::size_t *_wrap_btMiniSDF_m_n_fields_get_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + std::size_t result; + std::size_t *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = ((arg1)->m_n_fields); + *(std::size_t **)&_swig_go_result = new std::size_t(result); + return _swig_go_result; +} + + +void _wrap_btMiniSDF_m_isValid_set_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, bool _swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + bool arg2 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + if (arg1) (arg1)->m_isValid = arg2; + +} + + +bool _wrap_btMiniSDF_m_isValid_get_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = (bool) ((arg1)->m_isValid); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btMiniSDF_m_nodes_set_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, btAlignedObjectArray< btAlignedObjectArray< double > > *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btAlignedObjectArray< btAlignedObjectArray< double > > *arg2 = (btAlignedObjectArray< btAlignedObjectArray< double > > *) 0 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btAlignedObjectArray< double > > **)&_swig_go_1; + + if (arg1) (arg1)->m_nodes = *arg2; + +} + + +btAlignedObjectArray< btAlignedObjectArray< double > > *_wrap_btMiniSDF_m_nodes_get_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btAlignedObjectArray< btAlignedObjectArray< double > > *result = 0 ; + btAlignedObjectArray< btAlignedObjectArray< double > > *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = (btAlignedObjectArray< btAlignedObjectArray< double > > *)& ((arg1)->m_nodes); + *(btAlignedObjectArray< btAlignedObjectArray< double > > **)&_swig_go_result = (btAlignedObjectArray< btAlignedObjectArray< double > > *)result; + return _swig_go_result; +} + + +void _wrap_btMiniSDF_m_cells_set_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, btAlignedObjectArray< btAlignedObjectArray< btCell32 > > *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btAlignedObjectArray< btAlignedObjectArray< btCell32 > > *arg2 = (btAlignedObjectArray< btAlignedObjectArray< btCell32 > > *) 0 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btAlignedObjectArray< btCell32 > > **)&_swig_go_1; + + if (arg1) (arg1)->m_cells = *arg2; + +} + + +btAlignedObjectArray< btAlignedObjectArray< btCell32 > > *_wrap_btMiniSDF_m_cells_get_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btAlignedObjectArray< btAlignedObjectArray< btCell32 > > *result = 0 ; + btAlignedObjectArray< btAlignedObjectArray< btCell32 > > *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = (btAlignedObjectArray< btAlignedObjectArray< btCell32 > > *)& ((arg1)->m_cells); + *(btAlignedObjectArray< btAlignedObjectArray< btCell32 > > **)&_swig_go_result = (btAlignedObjectArray< btAlignedObjectArray< btCell32 > > *)result; + return _swig_go_result; +} + + +void _wrap_btMiniSDF_m_cell_map_set_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, btAlignedObjectArray< btAlignedObjectArray< unsigned int > > *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btAlignedObjectArray< btAlignedObjectArray< unsigned int > > *arg2 = (btAlignedObjectArray< btAlignedObjectArray< unsigned int > > *) 0 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(btAlignedObjectArray< btAlignedObjectArray< unsigned int > > **)&_swig_go_1; + + if (arg1) (arg1)->m_cell_map = *arg2; + +} + + +btAlignedObjectArray< btAlignedObjectArray< unsigned int > > *_wrap_btMiniSDF_m_cell_map_get_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btAlignedObjectArray< btAlignedObjectArray< unsigned int > > *result = 0 ; + btAlignedObjectArray< btAlignedObjectArray< unsigned int > > *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = (btAlignedObjectArray< btAlignedObjectArray< unsigned int > > *)& ((arg1)->m_cell_map); + *(btAlignedObjectArray< btAlignedObjectArray< unsigned int > > **)&_swig_go_result = (btAlignedObjectArray< btAlignedObjectArray< unsigned int > > *)result; + return _swig_go_result; +} + + +btMiniSDF *_wrap_new_btMiniSDF_mbt_e879218550ba2e2b() { + btMiniSDF *result = 0 ; + btMiniSDF *_swig_go_result; + + + result = (btMiniSDF *)new btMiniSDF(); + *(btMiniSDF **)&_swig_go_result = (btMiniSDF *)result; + return _swig_go_result; +} + + +bool _wrap_btMiniSDF_load_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, _gostring_ _swig_go_1, intgo _swig_go_2) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + bool result; + bool _swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + arg3 = (int)_swig_go_2; + + result = (bool)(arg1)->load((char const *)arg2,arg3); + _swig_go_result = result; + free(arg2); + return _swig_go_result; +} + + +bool _wrap_btMiniSDF_isValid_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + result = (bool)((btMiniSDF const *)arg1)->isValid(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btMiniSDF_multiToSingleIndex_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, btMultiIndex *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btMultiIndex *arg2 = 0 ; + unsigned int result; + intgo _swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(btMultiIndex **)&_swig_go_1; + + result = (unsigned int)((btMiniSDF const *)arg1)->multiToSingleIndex((btMultiIndex const &)*arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +btAlignedBox3d *_wrap_btMiniSDF_subdomain__SWIG_0_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, btMultiIndex *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btMultiIndex *arg2 = 0 ; + btAlignedBox3d result; + btAlignedBox3d *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(btMultiIndex **)&_swig_go_1; + + result = ((btMiniSDF const *)arg1)->subdomain((btMultiIndex const &)*arg2); + *(btAlignedBox3d **)&_swig_go_result = new btAlignedBox3d(result); + return _swig_go_result; +} + + +btMultiIndex *_wrap_btMiniSDF_singleToMultiIndex_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, intgo _swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + unsigned int arg2 ; + btMultiIndex result; + btMultiIndex *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + + result = ((btMiniSDF const *)arg1)->singleToMultiIndex(arg2); + *(btMultiIndex **)&_swig_go_result = new btMultiIndex(result); + return _swig_go_result; +} + + +btAlignedBox3d *_wrap_btMiniSDF_subdomain__SWIG_1_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, intgo _swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + unsigned int arg2 ; + btAlignedBox3d result; + btAlignedBox3d *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + + result = ((btMiniSDF const *)arg1)->subdomain(arg2); + *(btAlignedBox3d **)&_swig_go_result = new btAlignedBox3d(result); + return _swig_go_result; +} + + +btShapeMatrix *_wrap_btMiniSDF_shape_function___SWIG_0_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, btVector3 *_swig_go_1, btShapeGradients *_swig_go_2) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btVector3 *arg2 = 0 ; + btShapeGradients *arg3 = (btShapeGradients *) 0 ; + btShapeMatrix result; + btShapeMatrix *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btShapeGradients **)&_swig_go_2; + + result = ((btMiniSDF const *)arg1)->shape_function_((btVector3 const &)*arg2,arg3); + *(btShapeMatrix **)&_swig_go_result = new btShapeMatrix(result); + return _swig_go_result; +} + + +btShapeMatrix *_wrap_btMiniSDF_shape_function___SWIG_1_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, btVector3 *_swig_go_1) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + btVector3 *arg2 = 0 ; + btShapeMatrix result; + btShapeMatrix *_swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + result = ((btMiniSDF const *)arg1)->shape_function_((btVector3 const &)*arg2); + *(btShapeMatrix **)&_swig_go_result = new btShapeMatrix(result); + return _swig_go_result; +} + + +bool _wrap_btMiniSDF_interpolate_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0, intgo _swig_go_1, double *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + unsigned int arg2 ; + double *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = (btVector3 *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btMiniSDF **)&_swig_go_0; + arg2 = (unsigned int)_swig_go_1; + arg3 = *(double **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + result = (bool)((btMiniSDF const *)arg1)->interpolate(arg2,*arg3,(btVector3 const &)*arg4,arg5); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_delete_btMiniSDF_mbt_e879218550ba2e2b(btMiniSDF *_swig_go_0) { + btMiniSDF *arg1 = (btMiniSDF *) 0 ; + + arg1 = *(btMiniSDF **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btBoxBoxDetector_m_box1_set_mbt_e879218550ba2e2b(btBoxBoxDetector *_swig_go_0, btBoxShape *_swig_go_1) { + btBoxBoxDetector *arg1 = (btBoxBoxDetector *) 0 ; + btBoxShape *arg2 = (btBoxShape *) 0 ; + + arg1 = *(btBoxBoxDetector **)&_swig_go_0; + arg2 = *(btBoxShape **)&_swig_go_1; + + if (arg1) (arg1)->m_box1 = (btBoxShape const *)arg2; + +} + + +btBoxShape *_wrap_btBoxBoxDetector_m_box1_get_mbt_e879218550ba2e2b(btBoxBoxDetector *_swig_go_0) { + btBoxBoxDetector *arg1 = (btBoxBoxDetector *) 0 ; + btBoxShape *result = 0 ; + btBoxShape *_swig_go_result; + + arg1 = *(btBoxBoxDetector **)&_swig_go_0; + + result = (btBoxShape *) ((arg1)->m_box1); + *(btBoxShape **)&_swig_go_result = (btBoxShape *)result; + return _swig_go_result; +} + + +void _wrap_btBoxBoxDetector_m_box2_set_mbt_e879218550ba2e2b(btBoxBoxDetector *_swig_go_0, btBoxShape *_swig_go_1) { + btBoxBoxDetector *arg1 = (btBoxBoxDetector *) 0 ; + btBoxShape *arg2 = (btBoxShape *) 0 ; + + arg1 = *(btBoxBoxDetector **)&_swig_go_0; + arg2 = *(btBoxShape **)&_swig_go_1; + + if (arg1) (arg1)->m_box2 = (btBoxShape const *)arg2; + +} + + +btBoxShape *_wrap_btBoxBoxDetector_m_box2_get_mbt_e879218550ba2e2b(btBoxBoxDetector *_swig_go_0) { + btBoxBoxDetector *arg1 = (btBoxBoxDetector *) 0 ; + btBoxShape *result = 0 ; + btBoxShape *_swig_go_result; + + arg1 = *(btBoxBoxDetector **)&_swig_go_0; + + result = (btBoxShape *) ((arg1)->m_box2); + *(btBoxShape **)&_swig_go_result = (btBoxShape *)result; + return _swig_go_result; +} + + +btBoxBoxDetector *_wrap_new_btBoxBoxDetector_mbt_e879218550ba2e2b(btBoxShape *_swig_go_0, btBoxShape *_swig_go_1) { + btBoxShape *arg1 = (btBoxShape *) 0 ; + btBoxShape *arg2 = (btBoxShape *) 0 ; + btBoxBoxDetector *result = 0 ; + btBoxBoxDetector *_swig_go_result; + + arg1 = *(btBoxShape **)&_swig_go_0; + arg2 = *(btBoxShape **)&_swig_go_1; + + result = (btBoxBoxDetector *)new btBoxBoxDetector((btBoxShape const *)arg1,(btBoxShape const *)arg2); + *(btBoxBoxDetector **)&_swig_go_result = (btBoxBoxDetector *)result; + return _swig_go_result; +} + + +void _wrap_delete_btBoxBoxDetector_mbt_e879218550ba2e2b(btBoxBoxDetector *_swig_go_0) { + btBoxBoxDetector *arg1 = (btBoxBoxDetector *) 0 ; + + arg1 = *(btBoxBoxDetector **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btBoxBoxDetector_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(btBoxBoxDetector *_swig_go_0, btDiscreteCollisionDetectorInterface::ClosestPointInput *_swig_go_1, btDiscreteCollisionDetectorInterface::Result *_swig_go_2, btIDebugDraw *_swig_go_3, bool _swig_go_4) { + btBoxBoxDetector *arg1 = (btBoxBoxDetector *) 0 ; + btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; + btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; + bool arg5 ; + + arg1 = *(btBoxBoxDetector **)&_swig_go_0; + arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&_swig_go_1; + arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_2; + arg4 = *(btIDebugDraw **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + + (arg1)->getClosestPoints((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4,arg5); + +} + + +void _wrap_btBoxBoxDetector_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(btBoxBoxDetector *_swig_go_0, btDiscreteCollisionDetectorInterface::ClosestPointInput *_swig_go_1, btDiscreteCollisionDetectorInterface::Result *_swig_go_2, btIDebugDraw *_swig_go_3) { + btBoxBoxDetector *arg1 = (btBoxBoxDetector *) 0 ; + btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; + btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; + + arg1 = *(btBoxBoxDetector **)&_swig_go_0; + arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&_swig_go_1; + arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_2; + arg4 = *(btIDebugDraw **)&_swig_go_3; + + (arg1)->getClosestPoints((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4); + +} + + +float _wrap_dDOT_mbt_e879218550ba2e2b(float *_swig_go_0, float *_swig_go_1) { + btScalar *arg1 = (btScalar *) 0 ; + btScalar *arg2 = (btScalar *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btScalar **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + result = (btScalar)dDOT((float const *)arg1,(float const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_dDOT44_mbt_e879218550ba2e2b(float *_swig_go_0, float *_swig_go_1) { + btScalar *arg1 = (btScalar *) 0 ; + btScalar *arg2 = (btScalar *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btScalar **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + result = (btScalar)dDOT44((float const *)arg1,(float const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_dDOT41_mbt_e879218550ba2e2b(float *_swig_go_0, float *_swig_go_1) { + btScalar *arg1 = (btScalar *) 0 ; + btScalar *arg2 = (btScalar *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btScalar **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + result = (btScalar)dDOT41((float const *)arg1,(float const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_dDOT14_mbt_e879218550ba2e2b(float *_swig_go_0, float *_swig_go_1) { + btScalar *arg1 = (btScalar *) 0 ; + btScalar *arg2 = (btScalar *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btScalar **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + + result = (btScalar)dDOT14((float const *)arg1,(float const *)arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_dLineClosestApproach_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float *_swig_go_4, float *_swig_go_5) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar *arg5 = (btScalar *) 0 ; + btScalar *arg6 = (btScalar *) 0 ; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btScalar **)&_swig_go_5; + + dLineClosestApproach((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6); + +} + + +intgo _wrap_intersectRectQuad2_mbt_e879218550ba2e2b(float *_swig_go_0, float *_swig_go_1, float *_swig_go_2) { + btScalar *arg1 = (btScalar *) (btScalar *)0 ; + btScalar *arg2 = (btScalar *) (btScalar *)0 ; + btScalar *arg3 = (btScalar *) (btScalar *)0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btScalar **)&_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + result = (int)intersectRectQuad2(arg1,arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_cullPoints2_mbt_e879218550ba2e2b(intgo _swig_go_0, float *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3, intgo *_swig_go_4) { + int arg1 ; + btScalar *arg2 = (btScalar *) (btScalar *)0 ; + int arg3 ; + int arg4 ; + int *arg5 = (int *) (int *)0 ; + + arg1 = (int)_swig_go_0; + arg2 = *(btScalar **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(int **)&_swig_go_4; + + cullPoints2(arg1,arg2,arg3,arg4,arg5); + +} + + +intgo _wrap_dBoxBox2_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6, float *_swig_go_7, intgo *_swig_go_8, intgo _swig_go_9, dContactGeom *_swig_go_10, intgo _swig_go_11, btDiscreteCollisionDetectorInterface::Result *_swig_go_12) { + btVector3 *arg1 = 0 ; + btScalar *arg2 = (btScalar *) (btScalar *)0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar *arg5 = (btScalar *) (btScalar *)0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btScalar *arg8 = (btScalar *) 0 ; + int *arg9 = (int *) 0 ; + int arg10 ; + dContactGeom *arg11 = (dContactGeom *) 0 ; + int arg12 ; + btDiscreteCollisionDetectorInterface::Result *arg13 = 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(float **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btScalar **)&_swig_go_7; + arg9 = *(int **)&_swig_go_8; + arg10 = (int)_swig_go_9; + arg11 = *(dContactGeom **)&_swig_go_10; + arg12 = (int)_swig_go_11; + arg13 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_12; + + result = (int)dBoxBox2((btVector3 const &)*arg1,(float const (*))arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(float const (*))arg5,(btVector3 const &)*arg6,*arg7,arg8,arg9,arg10,arg11,arg12,*arg13); + _swig_go_result = result; + return _swig_go_result; +} + + +btSdfCollisionShape *_wrap_new_btSdfCollisionShape_mbt_e879218550ba2e2b() { + btSdfCollisionShape *result = 0 ; + btSdfCollisionShape *_swig_go_result; + + + result = (btSdfCollisionShape *)new btSdfCollisionShape(); + *(btSdfCollisionShape **)&_swig_go_result = (btSdfCollisionShape *)result; + return _swig_go_result; +} + + +void _wrap_delete_btSdfCollisionShape_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_btSdfCollisionShape_initializeSDF_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, _gostring_ _swig_go_1, intgo _swig_go_2) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + arg3 = (int)_swig_go_2; + + result = (bool)(arg1)->initializeSDF((char const *)arg2,arg3); + _swig_go_result = result; + free(arg2); + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShape_getAabb_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btSdfCollisionShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btSdfCollisionShape_setLocalScaling_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, btVector3 *_swig_go_1) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btSdfCollisionShape_getLocalScaling_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + result = (btVector3 *) &((btSdfCollisionShape const *)arg1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShape_calculateLocalInertia_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btSdfCollisionShape const *)arg1)->calculateLocalInertia(arg2,*arg3); + +} + + +_gostring_ _wrap_btSdfCollisionShape_getName_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + result = (char *)((btSdfCollisionShape const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShape_setMargin_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, float _swig_go_1) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + (arg1)->setMargin(arg2); + +} + + +float _wrap_btSdfCollisionShape_getMargin_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + result = (btScalar)((btSdfCollisionShape const *)arg1)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShape_processAllTriangles_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, btTriangleCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btTriangleCallback *arg2 = (btTriangleCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = *(btTriangleCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btSdfCollisionShape const *)arg1)->processAllTriangles(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +bool _wrap_btSdfCollisionShape_queryPoint_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2, btVector3 *_swig_go_3) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + btVector3 *arg4 = 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = (bool)(arg1)->queryPoint((btVector3 const &)*arg2,*arg3,*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShape_getBoundingSphere_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btSdfCollisionShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (btScalar)((btCollisionShape const *)swig_b1)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btSdfCollisionShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, float _swig_go_1) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (btScalar)((btCollisionShape const *)swig_b1)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btSdfCollisionShape_isPolyhedral_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSdfCollisionShape_isConvex2d_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSdfCollisionShape_isConvex_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSdfCollisionShape_isNonMoving_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSdfCollisionShape_isConcave_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSdfCollisionShape_isCompound_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSdfCollisionShape_isSoftBody_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btSdfCollisionShape_isInfinite_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSdfCollisionShape_getShapeType_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btSdfCollisionShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = ((btCollisionShape const *)swig_b1)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShape_setUserPointer_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, void *_swig_go_1) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserPointer(arg2); + +} + + +void *_wrap_btSdfCollisionShape_getUserPointer_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (void *)((btCollisionShape const *)swig_b1)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShape_setUserIndex_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, intgo _swig_go_1) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + int arg2 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserIndex(arg2); + +} + + +intgo _wrap_btSdfCollisionShape_getUserIndex_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShape_setUserIndex2_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, intgo _swig_go_1) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + int arg2 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserIndex2(arg2); + +} + + +intgo _wrap_btSdfCollisionShape_getUserIndex2_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btSdfCollisionShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btSdfCollisionShape_serialize_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (char *)((btCollisionShape const *)swig_b1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShape_serializeSingleShape_mbt_e879218550ba2e2b(btSdfCollisionShape *_swig_go_0, btSerializer *_swig_go_1) { + btSdfCollisionShape *arg1 = (btSdfCollisionShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btSdfCollisionShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->serializeSingleShape(arg2); + +} + + +void _wrap_btSdfCollisionShapeInternalData_m_localScaling_set_mbt_e879218550ba2e2b(btSdfCollisionShapeInternalData *_swig_go_0, btVector3 *_swig_go_1) { + btSdfCollisionShapeInternalData *arg1 = (btSdfCollisionShapeInternalData *) 0 ; + btVector3 *arg2 = (btVector3 *) 0 ; + + arg1 = *(btSdfCollisionShapeInternalData **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + if (arg1) (arg1)->m_localScaling = *arg2; + +} + + +btVector3 *_wrap_btSdfCollisionShapeInternalData_m_localScaling_get_mbt_e879218550ba2e2b(btSdfCollisionShapeInternalData *_swig_go_0) { + btSdfCollisionShapeInternalData *arg1 = (btSdfCollisionShapeInternalData *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btSdfCollisionShapeInternalData **)&_swig_go_0; + + result = (btVector3 *)& ((arg1)->m_localScaling); + *(btVector3 **)&_swig_go_result = (btVector3 *)result; + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShapeInternalData_m_margin_set_mbt_e879218550ba2e2b(btSdfCollisionShapeInternalData *_swig_go_0, float _swig_go_1) { + btSdfCollisionShapeInternalData *arg1 = (btSdfCollisionShapeInternalData *) 0 ; + btScalar arg2 ; + + arg1 = *(btSdfCollisionShapeInternalData **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + if (arg1) (arg1)->m_margin = arg2; + +} + + +float _wrap_btSdfCollisionShapeInternalData_m_margin_get_mbt_e879218550ba2e2b(btSdfCollisionShapeInternalData *_swig_go_0) { + btSdfCollisionShapeInternalData *arg1 = (btSdfCollisionShapeInternalData *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btSdfCollisionShapeInternalData **)&_swig_go_0; + + result = (btScalar) ((arg1)->m_margin); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btSdfCollisionShapeInternalData_m_sdf_set_mbt_e879218550ba2e2b(btSdfCollisionShapeInternalData *_swig_go_0, btMiniSDF *_swig_go_1) { + btSdfCollisionShapeInternalData *arg1 = (btSdfCollisionShapeInternalData *) 0 ; + btMiniSDF *arg2 = (btMiniSDF *) 0 ; + + arg1 = *(btSdfCollisionShapeInternalData **)&_swig_go_0; + arg2 = *(btMiniSDF **)&_swig_go_1; + + if (arg1) (arg1)->m_sdf = *arg2; + +} + + +btMiniSDF *_wrap_btSdfCollisionShapeInternalData_m_sdf_get_mbt_e879218550ba2e2b(btSdfCollisionShapeInternalData *_swig_go_0) { + btSdfCollisionShapeInternalData *arg1 = (btSdfCollisionShapeInternalData *) 0 ; + btMiniSDF *result = 0 ; + btMiniSDF *_swig_go_result; + + arg1 = *(btSdfCollisionShapeInternalData **)&_swig_go_0; + + result = (btMiniSDF *)& ((arg1)->m_sdf); + *(btMiniSDF **)&_swig_go_result = (btMiniSDF *)result; + return _swig_go_result; +} + + +btSdfCollisionShapeInternalData *_wrap_new_btSdfCollisionShapeInternalData_mbt_e879218550ba2e2b() { + btSdfCollisionShapeInternalData *result = 0 ; + btSdfCollisionShapeInternalData *_swig_go_result; + + + result = (btSdfCollisionShapeInternalData *)new btSdfCollisionShapeInternalData(); + *(btSdfCollisionShapeInternalData **)&_swig_go_result = (btSdfCollisionShapeInternalData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btSdfCollisionShapeInternalData_mbt_e879218550ba2e2b(btSdfCollisionShapeInternalData *_swig_go_0) { + btSdfCollisionShapeInternalData *arg1 = (btSdfCollisionShapeInternalData *) 0 ; + + arg1 = *(btSdfCollisionShapeInternalData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_SphereTriangleDetector_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(SphereTriangleDetector *_swig_go_0, btDiscreteCollisionDetectorInterface::ClosestPointInput *_swig_go_1, btDiscreteCollisionDetectorInterface::Result *_swig_go_2, btIDebugDraw *_swig_go_3, bool _swig_go_4) { + SphereTriangleDetector *arg1 = (SphereTriangleDetector *) 0 ; + btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; + btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; + bool arg5 ; + + arg1 = *(SphereTriangleDetector **)&_swig_go_0; + arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&_swig_go_1; + arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_2; + arg4 = *(btIDebugDraw **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + + (arg1)->getClosestPoints((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4,arg5); + +} + + +void _wrap_SphereTriangleDetector_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(SphereTriangleDetector *_swig_go_0, btDiscreteCollisionDetectorInterface::ClosestPointInput *_swig_go_1, btDiscreteCollisionDetectorInterface::Result *_swig_go_2, btIDebugDraw *_swig_go_3) { + SphereTriangleDetector *arg1 = (SphereTriangleDetector *) 0 ; + btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; + btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; + btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; + + arg1 = *(SphereTriangleDetector **)&_swig_go_0; + arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&_swig_go_1; + arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&_swig_go_2; + arg4 = *(btIDebugDraw **)&_swig_go_3; + + (arg1)->getClosestPoints((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4); + +} + + +SphereTriangleDetector *_wrap_new_SphereTriangleDetector_mbt_e879218550ba2e2b(btSphereShape *_swig_go_0, btTriangleShape *_swig_go_1, float _swig_go_2) { + btSphereShape *arg1 = (btSphereShape *) 0 ; + btTriangleShape *arg2 = (btTriangleShape *) 0 ; + btScalar arg3 ; + SphereTriangleDetector *result = 0 ; + SphereTriangleDetector *_swig_go_result; + + arg1 = *(btSphereShape **)&_swig_go_0; + arg2 = *(btTriangleShape **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + result = (SphereTriangleDetector *)new SphereTriangleDetector(arg1,arg2,arg3); + *(SphereTriangleDetector **)&_swig_go_result = (SphereTriangleDetector *)result; + return _swig_go_result; +} + + +void _wrap_delete_SphereTriangleDetector_mbt_e879218550ba2e2b(SphereTriangleDetector *_swig_go_0) { + SphereTriangleDetector *arg1 = (SphereTriangleDetector *) 0 ; + + arg1 = *(SphereTriangleDetector **)&_swig_go_0; + + delete arg1; + +} + + +bool _wrap_SphereTriangleDetector_collide_mbt_e879218550ba2e2b(SphereTriangleDetector *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float *_swig_go_4, float *_swig_go_5, float _swig_go_6) { + SphereTriangleDetector *arg1 = (SphereTriangleDetector *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar *arg5 = 0 ; + btScalar *arg6 = 0 ; + btScalar arg7 ; + bool result; + bool _swig_go_result; + + arg1 = *(SphereTriangleDetector **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btScalar **)&_swig_go_4; + arg6 = *(btScalar **)&_swig_go_5; + arg7 = (btScalar)_swig_go_6; + + result = (bool)(arg1)->collide((btVector3 const &)*arg2,*arg3,*arg4,*arg5,*arg6,arg7); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_SegmentSqrDistance_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btVector3 *arg1 = 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + result = (btScalar)SegmentSqrDistance((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); + _swig_go_result = result; + return _swig_go_result; +} + + +btStaticPlaneShape *_wrap_new_btStaticPlaneShape_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, float _swig_go_1) { + btVector3 *arg1 = 0 ; + btScalar arg2 ; + btStaticPlaneShape *result = 0 ; + btStaticPlaneShape *_swig_go_result; + + arg1 = *(btVector3 **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + result = (btStaticPlaneShape *)new btStaticPlaneShape((btVector3 const &)*arg1,arg2); + *(btStaticPlaneShape **)&_swig_go_result = (btStaticPlaneShape *)result; + return _swig_go_result; +} + + +void _wrap_delete_btStaticPlaneShape_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btStaticPlaneShape_getAabb_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btStaticPlaneShape const *)arg1)->getAabb((btTransform const &)*arg2,*arg3,*arg4); + +} + + +void _wrap_btStaticPlaneShape_processAllTriangles_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, btTriangleCallback *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btTriangleCallback *arg2 = (btTriangleCallback *) 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = *(btTriangleCallback **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + ((btStaticPlaneShape const *)arg1)->processAllTriangles(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btStaticPlaneShape_calculateLocalInertia_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, float _swig_go_1, btVector3 *_swig_go_2) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btScalar arg2 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + ((btStaticPlaneShape const *)arg1)->calculateLocalInertia(arg2,*arg3); + +} + + +void _wrap_btStaticPlaneShape_setLocalScaling_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, btVector3 *_swig_go_1) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + (arg1)->setLocalScaling((btVector3 const &)*arg2); + +} + + +btVector3 *_wrap_btStaticPlaneShape_getLocalScaling_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + result = (btVector3 *) &((btStaticPlaneShape const *)arg1)->getLocalScaling(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btStaticPlaneShape_getPlaneNormal_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btVector3 *result = 0 ; + btVector3 *_swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + result = (btVector3 *) &((btStaticPlaneShape const *)arg1)->getPlaneNormal(); + *(btVector3 **)&_swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btStaticPlaneShape_getPlaneConstant_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btScalar *result = 0 ; + float _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + result = (btScalar *) &((btStaticPlaneShape const *)arg1)->getPlaneConstant(); + _swig_go_result = (btScalar)*result; + return _swig_go_result; +} + + +_gostring_ _wrap_btStaticPlaneShape_getName_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + result = (char *)((btStaticPlaneShape const *)arg1)->getName(); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +intgo _wrap_btStaticPlaneShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + result = (int)((btStaticPlaneShape const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btStaticPlaneShape_serialize_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btStaticPlaneShape const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +float _wrap_btStaticPlaneShape_getMargin_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + result = (btScalar)((btConcaveShape const *)swig_b0)->getMargin(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btStaticPlaneShape_setMargin_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, float _swig_go_1) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btScalar arg2 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + (swig_b0)->setMargin(arg2); + +} + + +void _wrap_btStaticPlaneShape_getBoundingSphere_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, btVector3 *_swig_go_1, float *_swig_go_2) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btVector3 *arg2 = 0 ; + btScalar *arg3 = 0 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btScalar **)&_swig_go_2; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->getBoundingSphere(*arg2,*arg3); + +} + + +float _wrap_btStaticPlaneShape_getAngularMotionDisc_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (btScalar)((btCollisionShape const *)swig_b1)->getAngularMotionDisc(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btStaticPlaneShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, float _swig_go_1) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btScalar arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (btScalar)((btCollisionShape const *)swig_b1)->getContactBreakingThreshold(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btStaticPlaneShape_calculateTemporalAabb_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, btTransform *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btTransform *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->calculateTemporalAabb((btTransform const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,*arg6,*arg7); + +} + + +bool _wrap_btStaticPlaneShape_isPolyhedral_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isPolyhedral(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btStaticPlaneShape_isConvex2d_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConvex2d(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btStaticPlaneShape_isConvex_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConvex(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btStaticPlaneShape_isNonMoving_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isNonMoving(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btStaticPlaneShape_isConcave_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isConcave(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btStaticPlaneShape_isCompound_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isCompound(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btStaticPlaneShape_isSoftBody_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isSoftBody(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btStaticPlaneShape_isInfinite_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (bool)((btCollisionShape const *)swig_b1)->isInfinite(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btStaticPlaneShape_getShapeType_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getShapeType(); + _swig_go_result = result; + return _swig_go_result; +} + + +btVector3 *_wrap_btStaticPlaneShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = ((btCollisionShape const *)swig_b1)->getAnisotropicRollingFrictionDirection(); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +void _wrap_btStaticPlaneShape_setUserPointer_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, void *_swig_go_1) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserPointer(arg2); + +} + + +void *_wrap_btStaticPlaneShape_getUserPointer_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (void *)((btCollisionShape const *)swig_b1)->getUserPointer(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btStaticPlaneShape_setUserIndex_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, intgo _swig_go_1) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + int arg2 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserIndex(arg2); + +} + + +intgo _wrap_btStaticPlaneShape_getUserIndex_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getUserIndex(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btStaticPlaneShape_setUserIndex2_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, intgo _swig_go_1) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + int arg2 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + (swig_b1)->setUserIndex2(arg2); + +} + + +intgo _wrap_btStaticPlaneShape_getUserIndex2_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + result = (int)((btCollisionShape const *)swig_b1)->getUserIndex2(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btStaticPlaneShape_serializeSingleShape_mbt_e879218550ba2e2b(btStaticPlaneShape *_swig_go_0, btSerializer *_swig_go_1) { + btStaticPlaneShape *arg1 = (btStaticPlaneShape *) 0 ; + btSerializer *arg2 = (btSerializer *) 0 ; + + arg1 = *(btStaticPlaneShape **)&_swig_go_0; + arg2 = *(btSerializer **)&_swig_go_1; + + btConcaveShape *swig_b0 = (btConcaveShape *)arg1; + btCollisionShape *swig_b1 = (btCollisionShape *)swig_b0; + ((btCollisionShape const *)swig_b1)->serializeSingleShape(arg2); + +} + + +void _wrap_btStaticPlaneShapeData_m_collisionShapeData_set_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0, btCollisionShapeData *_swig_go_1) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + btCollisionShapeData *arg2 = (btCollisionShapeData *) 0 ; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + arg2 = *(btCollisionShapeData **)&_swig_go_1; + + if (arg1) (arg1)->m_collisionShapeData = *arg2; + +} + + +btCollisionShapeData *_wrap_btStaticPlaneShapeData_m_collisionShapeData_get_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + btCollisionShapeData *result = 0 ; + btCollisionShapeData *_swig_go_result; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + + result = (btCollisionShapeData *)& ((arg1)->m_collisionShapeData); + *(btCollisionShapeData **)&_swig_go_result = (btCollisionShapeData *)result; + return _swig_go_result; +} + + +void _wrap_btStaticPlaneShapeData_m_localScaling_set_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_localScaling = *arg2; + +} + + +btVector3FloatData *_wrap_btStaticPlaneShapeData_m_localScaling_get_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_localScaling); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btStaticPlaneShapeData_m_planeNormal_set_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0, btVector3FloatData *_swig_go_1) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + arg2 = *(btVector3FloatData **)&_swig_go_1; + + if (arg1) (arg1)->m_planeNormal = *arg2; + +} + + +btVector3FloatData *_wrap_btStaticPlaneShapeData_m_planeNormal_get_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + btVector3FloatData *result = 0 ; + btVector3FloatData *_swig_go_result; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + + result = (btVector3FloatData *)& ((arg1)->m_planeNormal); + *(btVector3FloatData **)&_swig_go_result = (btVector3FloatData *)result; + return _swig_go_result; +} + + +void _wrap_btStaticPlaneShapeData_m_planeConstant_set_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0, float _swig_go_1) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + float arg2 ; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + arg2 = (float)_swig_go_1; + + if (arg1) (arg1)->m_planeConstant = arg2; + +} + + +float _wrap_btStaticPlaneShapeData_m_planeConstant_get_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + float result; + float _swig_go_result; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + + result = (float) ((arg1)->m_planeConstant); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btStaticPlaneShapeData_m_pad_set_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0, _gostring_ _swig_go_1) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + char *arg2 = (char *) (char *)0 ; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + { + if(arg2) { + strncpy((char*)arg1->m_pad, (const char *)arg2, 4-1); + arg1->m_pad[4-1] = 0; + } else { + arg1->m_pad[0] = 0; + } + } + + free(arg2); +} + + +_gostring_ _wrap_btStaticPlaneShapeData_m_pad_get_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + + result = (char *)(char *) ((arg1)->m_pad); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +btStaticPlaneShapeData *_wrap_new_btStaticPlaneShapeData_mbt_e879218550ba2e2b() { + btStaticPlaneShapeData *result = 0 ; + btStaticPlaneShapeData *_swig_go_result; + + + result = (btStaticPlaneShapeData *)new btStaticPlaneShapeData(); + *(btStaticPlaneShapeData **)&_swig_go_result = (btStaticPlaneShapeData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btStaticPlaneShapeData_mbt_e879218550ba2e2b(btStaticPlaneShapeData *_swig_go_0) { + btStaticPlaneShapeData *arg1 = (btStaticPlaneShapeData *) 0 ; + + arg1 = *(btStaticPlaneShapeData **)&_swig_go_0; + + delete arg1; + +} + + +btGeneric6DofSpringConstraint *_wrap_new_btGeneric6DofSpringConstraint__SWIG_0_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btRigidBody *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, bool _swig_go_4) { + btRigidBody *arg1 = 0 ; + btRigidBody *arg2 = 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + bool arg5 ; + btGeneric6DofSpringConstraint *result = 0 ; + btGeneric6DofSpringConstraint *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btRigidBody **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = (bool)_swig_go_4; + + result = (btGeneric6DofSpringConstraint *)new btGeneric6DofSpringConstraint(*arg1,*arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,arg5); + *(btGeneric6DofSpringConstraint **)&_swig_go_result = (btGeneric6DofSpringConstraint *)result; + return _swig_go_result; +} + + +btGeneric6DofSpringConstraint *_wrap_new_btGeneric6DofSpringConstraint__SWIG_1_mbt_e879218550ba2e2b(btRigidBody *_swig_go_0, btTransform *_swig_go_1, bool _swig_go_2) { + btRigidBody *arg1 = 0 ; + btTransform *arg2 = 0 ; + bool arg3 ; + btGeneric6DofSpringConstraint *result = 0 ; + btGeneric6DofSpringConstraint *_swig_go_result; + + arg1 = *(btRigidBody **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = (bool)_swig_go_2; + + result = (btGeneric6DofSpringConstraint *)new btGeneric6DofSpringConstraint(*arg1,(btTransform const &)*arg2,arg3); + *(btGeneric6DofSpringConstraint **)&_swig_go_result = (btGeneric6DofSpringConstraint *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_enableSpring_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1, bool _swig_go_2) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + bool arg3 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (bool)_swig_go_2; + + (arg1)->enableSpring(arg2,arg3); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setStiffness_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setStiffness(arg2,arg3); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setDamping_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setDamping(arg2,arg3); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setEquilibriumPoint__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + (arg1)->setEquilibriumPoint(); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setEquilibriumPoint__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setEquilibriumPoint(arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setEquilibriumPoint__SWIG_2_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->setEquilibriumPoint(arg2,arg3); + +} + + +bool _wrap_btGeneric6DofSpringConstraint_isSpringEnabled_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (bool)((btGeneric6DofSpringConstraint const *)arg1)->isSpringEnabled(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGeneric6DofSpringConstraint_getStiffness_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btScalar)((btGeneric6DofSpringConstraint const *)arg1)->getStiffness(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGeneric6DofSpringConstraint_getDamping_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btScalar)((btGeneric6DofSpringConstraint const *)arg1)->getDamping(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGeneric6DofSpringConstraint_getEquilibriumPoint_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + result = (btScalar)((btGeneric6DofSpringConstraint const *)arg1)->getEquilibriumPoint(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setAxis_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + + (arg1)->setAxis((btVector3 const &)*arg2,(btVector3 const &)*arg3); + +} + + +void _wrap_btGeneric6DofSpringConstraint_getInfo2_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo2 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTypedConstraint::btConstraintInfo2 *arg2 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_1; + + (arg1)->getInfo2(arg2); + +} + + +intgo _wrap_btGeneric6DofSpringConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + result = (int)((btGeneric6DofSpringConstraint const *)arg1)->calculateSerializeBufferSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +_gostring_ _wrap_btGeneric6DofSpringConstraint_serialize_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, void *_swig_go_1, btSerializer *_swig_go_2) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + void *arg2 = (void *) 0 ; + btSerializer *arg3 = (btSerializer *) 0 ; + char *result = 0 ; + _gostring_ _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + arg3 = *(btSerializer **)&_swig_go_2; + + result = (char *)((btGeneric6DofSpringConstraint const *)arg1)->serialize(arg2,arg3); + _swig_go_result = Swig_AllocateString((char*)result, result ? strlen((char*)result) : 0); + return _swig_go_result; +} + + +void _wrap_delete_btGeneric6DofSpringConstraint_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_SetbtGeneric6DofSpringConstraint_M_useSolveConstraintObsolete_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, bool _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + if (swig_b0) (swig_b0)->m_useSolveConstraintObsolete = arg2; + +} + + +bool _wrap_GetbtGeneric6DofSpringConstraint_M_useSolveConstraintObsolete_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (bool) ((swig_b0)->m_useSolveConstraintObsolete); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_calculateTransforms__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->calculateTransforms((btTransform const &)*arg2,(btTransform const &)*arg3); + +} + + +void _wrap_btGeneric6DofSpringConstraint_calculateTransforms__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->calculateTransforms(); + +} + + +btTransform *_wrap_btGeneric6DofSpringConstraint_getCalculatedTransformA_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btTransform *) &((btGeneric6DofConstraint const *)swig_b0)->getCalculatedTransformA(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btGeneric6DofSpringConstraint_getCalculatedTransformB_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btTransform *) &((btGeneric6DofConstraint const *)swig_b0)->getCalculatedTransformB(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btGeneric6DofSpringConstraint_getFrameOffsetA__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btTransform *) &((btGeneric6DofConstraint const *)swig_b0)->getFrameOffsetA(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btGeneric6DofSpringConstraint_getFrameOffsetA__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btTransform *) &(swig_b0)->getFrameOffsetA(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btGeneric6DofSpringConstraint_getFrameOffsetB__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btTransform *) &((btGeneric6DofConstraint const *)swig_b0)->getFrameOffsetB(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +btTransform *_wrap_btGeneric6DofSpringConstraint_getFrameOffsetB__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTransform *result = 0 ; + btTransform *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btTransform *) &(swig_b0)->getFrameOffsetB(); + *(btTransform **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_buildJacobian_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->buildJacobian(); + +} + + +void _wrap_btGeneric6DofSpringConstraint_getInfo1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo1 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTypedConstraint::btConstraintInfo1 *arg2 = (btTypedConstraint::btConstraintInfo1 *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo1 **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->getInfo1(arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_getInfo1NonVirtual_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo1 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTypedConstraint::btConstraintInfo1 *arg2 = (btTypedConstraint::btConstraintInfo1 *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo1 **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->getInfo1NonVirtual(arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_getInfo2NonVirtual_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btTypedConstraint::btConstraintInfo2 *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTypedConstraint::btConstraintInfo2 *arg2 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->getInfo2NonVirtual(arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8); + +} + + +void _wrap_btGeneric6DofSpringConstraint_updateRHS_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, float _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->updateRHS(arg2); + +} + + +btVector3 *_wrap_btGeneric6DofSpringConstraint_getAxis_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btVector3 result; + btVector3 *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = ((btGeneric6DofConstraint const *)swig_b0)->getAxis(arg2); + *(btVector3 **)&_swig_go_result = new btVector3(result); + return _swig_go_result; +} + + +float _wrap_btGeneric6DofSpringConstraint_getAngle_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btScalar)((btGeneric6DofConstraint const *)swig_b0)->getAngle(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGeneric6DofSpringConstraint_getRelativePivotPosition_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btScalar)((btGeneric6DofConstraint const *)swig_b0)->getRelativePivotPosition(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setFrames_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btTransform *_swig_go_1, btTransform *_swig_go_2) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTransform *arg2 = 0 ; + btTransform *arg3 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->setFrames((btTransform const &)*arg2,(btTransform const &)*arg3); + +} + + +bool _wrap_btGeneric6DofSpringConstraint_testAngularLimitMotor_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (bool)(swig_b0)->testAngularLimitMotor(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setLinearLowerLimit_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->setLinearLowerLimit((btVector3 const &)*arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_getLinearLowerLimit_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + ((btGeneric6DofConstraint const *)swig_b0)->getLinearLowerLimit(*arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setLinearUpperLimit_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->setLinearUpperLimit((btVector3 const &)*arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_getLinearUpperLimit_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + ((btGeneric6DofConstraint const *)swig_b0)->getLinearUpperLimit(*arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setAngularLowerLimit_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->setAngularLowerLimit((btVector3 const &)*arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_getAngularLowerLimit_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + ((btGeneric6DofConstraint const *)swig_b0)->getAngularLowerLimit(*arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setAngularUpperLimit_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->setAngularUpperLimit((btVector3 const &)*arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_getAngularUpperLimit_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btVector3 *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btVector3 *arg2 = 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + ((btGeneric6DofConstraint const *)swig_b0)->getAngularUpperLimit(*arg2); + +} + + +btRotationalLimitMotor *_wrap_btGeneric6DofSpringConstraint_getRotationalLimitMotor_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btRotationalLimitMotor *result = 0 ; + btRotationalLimitMotor *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btRotationalLimitMotor *)(swig_b0)->getRotationalLimitMotor(arg2); + *(btRotationalLimitMotor **)&_swig_go_result = (btRotationalLimitMotor *)result; + return _swig_go_result; +} + + +btTranslationalLimitMotor *_wrap_btGeneric6DofSpringConstraint_getTranslationalLimitMotor_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTranslationalLimitMotor *result = 0 ; + btTranslationalLimitMotor *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btTranslationalLimitMotor *)(swig_b0)->getTranslationalLimitMotor(); + *(btTranslationalLimitMotor **)&_swig_go_result = (btTranslationalLimitMotor *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setLimit_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2, float _swig_go_3) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + btScalar arg4 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->setLimit(arg2,arg3,arg4); + +} + + +bool _wrap_btGeneric6DofSpringConstraint_isLimited_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (bool)((btGeneric6DofConstraint const *)swig_b0)->isLimited(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_calcAnchorPos_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->calcAnchorPos(); + +} + + +intgo _wrap_btGeneric6DofSpringConstraint_get_limit_motor_info2__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btRotationalLimitMotor *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7, btTypedConstraint::btConstraintInfo2 *_swig_go_8, intgo _swig_go_9, btVector3 *_swig_go_10, intgo _swig_go_11, intgo _swig_go_12) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btRotationalLimitMotor *arg2 = (btRotationalLimitMotor *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + btTypedConstraint::btConstraintInfo2 *arg9 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + int arg10 ; + btVector3 *arg11 = 0 ; + int arg12 ; + int arg13 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btRotationalLimitMotor **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_8; + arg10 = (int)_swig_go_9; + arg11 = *(btVector3 **)&_swig_go_10; + arg12 = (int)_swig_go_11; + arg13 = (int)_swig_go_12; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (int)(swig_b0)->get_limit_motor_info2(arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8,arg9,arg10,*arg11,arg12,arg13); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofSpringConstraint_get_limit_motor_info2__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btRotationalLimitMotor *_swig_go_1, btTransform *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7, btTypedConstraint::btConstraintInfo2 *_swig_go_8, intgo _swig_go_9, btVector3 *_swig_go_10, intgo _swig_go_11) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btRotationalLimitMotor *arg2 = (btRotationalLimitMotor *) 0 ; + btTransform *arg3 = 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + btTypedConstraint::btConstraintInfo2 *arg9 = (btTypedConstraint::btConstraintInfo2 *) 0 ; + int arg10 ; + btVector3 *arg11 = 0 ; + int arg12 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btRotationalLimitMotor **)&_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = *(btTypedConstraint::btConstraintInfo2 **)&_swig_go_8; + arg10 = (int)_swig_go_9; + arg11 = *(btVector3 **)&_swig_go_10; + arg12 = (int)_swig_go_11; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (int)(swig_b0)->get_limit_motor_info2(arg2,(btTransform const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8,arg9,arg10,*arg11,arg12); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btGeneric6DofSpringConstraint_getUseFrameOffset_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (bool)((btGeneric6DofConstraint const *)swig_b0)->getUseFrameOffset(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setUseFrameOffset_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, bool _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->setUseFrameOffset(arg2); + +} + + +bool _wrap_btGeneric6DofSpringConstraint_getUseLinearReferenceFrameA_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (bool)((btGeneric6DofConstraint const *)swig_b0)->getUseLinearReferenceFrameA(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setUseLinearReferenceFrameA_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, bool _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->setUseLinearReferenceFrameA(arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2, intgo _swig_go_3) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + int arg4 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->setParam(arg2,arg3,arg4); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1, float _swig_go_2) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar arg3 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + (swig_b0)->setParam(arg2,arg3); + +} + + +float _wrap_btGeneric6DofSpringConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + int arg3 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + arg3 = (int)_swig_go_2; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btScalar)((btGeneric6DofConstraint const *)swig_b0)->getParam(arg2,arg3); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGeneric6DofSpringConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (btScalar)((btGeneric6DofConstraint const *)swig_b0)->getParam(arg2); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofSpringConstraint_getFlags_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + result = (int)((btGeneric6DofConstraint const *)swig_b0)->getFlags(); + _swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btGeneric6DofSpringConstraint_getFixedBody_mbt_e879218550ba2e2b() { + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + + result = (btRigidBody *) &btTypedConstraint::getFixedBody(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofSpringConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (int)((btTypedConstraint const *)swig_b1)->getOverrideNumSolverIterations(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->setOverrideNumSolverIterations(arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btAlignedObjectArray< btSolverConstraint > *_swig_go_1, intgo _swig_go_2, intgo _swig_go_3, float _swig_go_4) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btConstraintArray *arg2 = 0 ; + int arg3 ; + int arg4 ; + btScalar arg5 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btConstraintArray **)&_swig_go_1; + arg3 = (int)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = (btScalar)_swig_go_4; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->setupSolverConstraint(*arg2,arg3,arg4,arg5); + +} + + +void _wrap_btGeneric6DofSpringConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, float _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->internalSetAppliedImpulse(arg2); + +} + + +float _wrap_btGeneric6DofSpringConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btScalar)(swig_b1)->internalGetAppliedImpulse(); + _swig_go_result = result; + return _swig_go_result; +} + + +float _wrap_btGeneric6DofSpringConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btScalar)((btTypedConstraint const *)swig_b1)->getBreakingImpulseThreshold(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, float _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->setBreakingImpulseThreshold(arg2); + +} + + +bool _wrap_btGeneric6DofSpringConstraint_isEnabled_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (bool)((btTypedConstraint const *)swig_b1)->isEnabled(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setEnabled_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, bool _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->setEnabled(arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btSolverBody *_swig_go_1, btSolverBody *_swig_go_2, float _swig_go_3) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btSolverBody *arg2 = 0 ; + btSolverBody *arg3 = 0 ; + btScalar arg4 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btSolverBody **)&_swig_go_1; + arg3 = *(btSolverBody **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->solveConstraintObsolete(*arg2,*arg3,arg4); + +} + + +btRigidBody *_wrap_btGeneric6DofSpringConstraint_getRigidBodyA__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btRigidBody *) &((btTypedConstraint const *)swig_b1)->getRigidBodyA(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btGeneric6DofSpringConstraint_getRigidBodyA__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btRigidBody *) &(swig_b1)->getRigidBodyA(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btGeneric6DofSpringConstraint_getRigidBodyB__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btRigidBody *) &((btTypedConstraint const *)swig_b1)->getRigidBodyB(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +btRigidBody *_wrap_btGeneric6DofSpringConstraint_getRigidBodyB__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btRigidBody *result = 0 ; + btRigidBody *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btRigidBody *) &(swig_b1)->getRigidBodyB(); + *(btRigidBody **)&_swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofSpringConstraint_getUserConstraintType_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (int)((btTypedConstraint const *)swig_b1)->getUserConstraintType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setUserConstraintType_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->setUserConstraintType(arg2); + +} + + +void _wrap_btGeneric6DofSpringConstraint_setUserConstraintId_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->setUserConstraintId(arg2); + +} + + +intgo _wrap_btGeneric6DofSpringConstraint_getUserConstraintId_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (int)((btTypedConstraint const *)swig_b1)->getUserConstraintId(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, void *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(void **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->setUserConstraintPtr(arg2); + +} + + +void *_wrap_btGeneric6DofSpringConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + void *result = 0 ; + void *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (void *)(swig_b1)->getUserConstraintPtr(); + *(void **)&_swig_go_result = (void *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setJointFeedback_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, btJointFeedback *_swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btJointFeedback *arg2 = (btJointFeedback *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = *(btJointFeedback **)&_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->setJointFeedback(arg2); + +} + + +btJointFeedback *_wrap_btGeneric6DofSpringConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btJointFeedback *result = 0 ; + btJointFeedback *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btJointFeedback *)((btTypedConstraint const *)swig_b1)->getJointFeedback(); + *(btJointFeedback **)&_swig_go_result = (btJointFeedback *)result; + return _swig_go_result; +} + + +btJointFeedback *_wrap_btGeneric6DofSpringConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btJointFeedback *result = 0 ; + btJointFeedback *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btJointFeedback *)(swig_b1)->getJointFeedback(); + *(btJointFeedback **)&_swig_go_result = (btJointFeedback *)result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofSpringConstraint_getUid_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (int)((btTypedConstraint const *)swig_b1)->getUid(); + _swig_go_result = result; + return _swig_go_result; +} + + +bool _wrap_btGeneric6DofSpringConstraint_needsFeedback_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + bool result; + bool _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (bool)((btTypedConstraint const *)swig_b1)->needsFeedback(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_enableFeedback_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, bool _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + bool arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (bool)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->enableFeedback(arg2); + +} + + +float _wrap_btGeneric6DofSpringConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btScalar)((btTypedConstraint const *)swig_b1)->getAppliedImpulse(); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofSpringConstraint_getConstraintType_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btTypedConstraintType result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btTypedConstraintType)((btTypedConstraint const *)swig_b1)->getConstraintType(); + _swig_go_result = (intgo)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, float _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btScalar arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + (swig_b1)->setDbgDrawSize(arg2); + +} + + +float _wrap_btGeneric6DofSpringConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + btScalar result; + float _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + result = (btScalar)(swig_b1)->getDbgDrawSize(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_SetbtGeneric6DofSpringConstraint_M_objectType_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0, intgo _swig_go_1) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int arg2 ; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + btTypedObject *swig_b2 = (btTypedObject *)swig_b1; + if (swig_b2) (swig_b2)->m_objectType = arg2; + +} + + +intgo _wrap_GetbtGeneric6DofSpringConstraint_M_objectType_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + btTypedObject *swig_b2 = (btTypedObject *)swig_b1; + result = (int) ((swig_b2)->m_objectType); + _swig_go_result = result; + return _swig_go_result; +} + + +intgo _wrap_btGeneric6DofSpringConstraint_getObjectType_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraint *_swig_go_0) { + btGeneric6DofSpringConstraint *arg1 = (btGeneric6DofSpringConstraint *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraint **)&_swig_go_0; + + btGeneric6DofConstraint *swig_b0 = (btGeneric6DofConstraint *)arg1; + btTypedConstraint *swig_b1 = (btTypedConstraint *)swig_b0; + btTypedObject *swig_b2 = (btTypedObject *)swig_b1; + result = (int)((btTypedObject const *)swig_b2)->getObjectType(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraintData_m_6dofData_set_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0, btGeneric6DofConstraintData *_swig_go_1) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + btGeneric6DofConstraintData *arg2 = (btGeneric6DofConstraintData *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + arg2 = *(btGeneric6DofConstraintData **)&_swig_go_1; + + if (arg1) (arg1)->m_6dofData = *arg2; + +} + + +btGeneric6DofConstraintData *_wrap_btGeneric6DofSpringConstraintData_m_6dofData_get_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + btGeneric6DofConstraintData *result = 0 ; + btGeneric6DofConstraintData *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + + result = (btGeneric6DofConstraintData *)& ((arg1)->m_6dofData); + *(btGeneric6DofConstraintData **)&_swig_go_result = (btGeneric6DofConstraintData *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraintData_m_springEnabled_set_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0, intgo *_swig_go_1) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_springEnabled; + for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btGeneric6DofSpringConstraintData_m_springEnabled_get_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_springEnabled); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraintData_m_equilibriumPoint_set_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0, float *_swig_go_1) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_equilibriumPoint; + for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btGeneric6DofSpringConstraintData_m_equilibriumPoint_get_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_equilibriumPoint); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraintData_m_springStiffness_set_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0, float *_swig_go_1) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_springStiffness; + for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btGeneric6DofSpringConstraintData_m_springStiffness_get_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_springStiffness); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraintData_m_springDamping_set_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0, float *_swig_go_1) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + float *arg2 = (float *) (float *)0 ; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + arg2 = *(float **)&_swig_go_1; + + { + size_t ii; + float *b = (float *) arg1->m_springDamping; + for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((float *) arg2 + ii); + } + +} + + +float *_wrap_btGeneric6DofSpringConstraintData_m_springDamping_get_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + float *result = 0 ; + float *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + + result = (float *)(float *) ((arg1)->m_springDamping); + *(float **)&_swig_go_result = result; + return _swig_go_result; +} + + +btGeneric6DofSpringConstraintData *_wrap_new_btGeneric6DofSpringConstraintData_mbt_e879218550ba2e2b() { + btGeneric6DofSpringConstraintData *result = 0 ; + btGeneric6DofSpringConstraintData *_swig_go_result; + + + result = (btGeneric6DofSpringConstraintData *)new btGeneric6DofSpringConstraintData(); + *(btGeneric6DofSpringConstraintData **)&_swig_go_result = (btGeneric6DofSpringConstraintData *)result; + return _swig_go_result; +} + + +void _wrap_delete_btGeneric6DofSpringConstraintData_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintData *_swig_go_0) { + btGeneric6DofSpringConstraintData *arg1 = (btGeneric6DofSpringConstraintData *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraintData **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btGeneric6DofSpringConstraintDoubleData2_m_6dofData_set_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0, btGeneric6DofConstraintDoubleData2 *_swig_go_1) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + btGeneric6DofConstraintDoubleData2 *arg2 = (btGeneric6DofConstraintDoubleData2 *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_1; + + if (arg1) (arg1)->m_6dofData = *arg2; + +} + + +btGeneric6DofConstraintDoubleData2 *_wrap_btGeneric6DofSpringConstraintDoubleData2_m_6dofData_get_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + btGeneric6DofConstraintDoubleData2 *result = 0 ; + btGeneric6DofConstraintDoubleData2 *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + + result = (btGeneric6DofConstraintDoubleData2 *)& ((arg1)->m_6dofData); + *(btGeneric6DofConstraintDoubleData2 **)&_swig_go_result = (btGeneric6DofConstraintDoubleData2 *)result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraintDoubleData2_m_springEnabled_set_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0, intgo *_swig_go_1) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + int *arg2 = (int *) (int *)0 ; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(int **)&_swig_go_1; + + { + size_t ii; + int *b = (int *) arg1->m_springEnabled; + for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((int *) arg2 + ii); + } + +} + + +intgo *_wrap_btGeneric6DofSpringConstraintDoubleData2_m_springEnabled_get_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + int *result = 0 ; + intgo *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + + result = (int *)(int *) ((arg1)->m_springEnabled); + *(int **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraintDoubleData2_m_equilibriumPoint_set_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0, double *_swig_go_1) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_equilibriumPoint; + for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btGeneric6DofSpringConstraintDoubleData2_m_equilibriumPoint_get_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_equilibriumPoint); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraintDoubleData2_m_springStiffness_set_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0, double *_swig_go_1) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_springStiffness; + for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btGeneric6DofSpringConstraintDoubleData2_m_springStiffness_get_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_springStiffness); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btGeneric6DofSpringConstraintDoubleData2_m_springDamping_set_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0, double *_swig_go_1) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + double *arg2 = (double *) (double *)0 ; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + arg2 = *(double **)&_swig_go_1; + + { + size_t ii; + double *b = (double *) arg1->m_springDamping; + for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((double *) arg2 + ii); + } + +} + + +double *_wrap_btGeneric6DofSpringConstraintDoubleData2_m_springDamping_get_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + double *result = 0 ; + double *_swig_go_result; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + + result = (double *)(double *) ((arg1)->m_springDamping); + *(double **)&_swig_go_result = result; + return _swig_go_result; +} + + +btGeneric6DofSpringConstraintDoubleData2 *_wrap_new_btGeneric6DofSpringConstraintDoubleData2_mbt_e879218550ba2e2b() { + btGeneric6DofSpringConstraintDoubleData2 *result = 0 ; + btGeneric6DofSpringConstraintDoubleData2 *_swig_go_result; + + + result = (btGeneric6DofSpringConstraintDoubleData2 *)new btGeneric6DofSpringConstraintDoubleData2(); + *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_result = (btGeneric6DofSpringConstraintDoubleData2 *)result; + return _swig_go_result; +} + + +void _wrap_delete_btGeneric6DofSpringConstraintDoubleData2_mbt_e879218550ba2e2b(btGeneric6DofSpringConstraintDoubleData2 *_swig_go_0) { + btGeneric6DofSpringConstraintDoubleData2 *arg1 = (btGeneric6DofSpringConstraintDoubleData2 *) 0 ; + + arg1 = *(btGeneric6DofSpringConstraintDoubleData2 **)&_swig_go_0; + + delete arg1; + +} + + +btMDefaultColors *_wrap_new_btMDefaultColors_mbt_e879218550ba2e2b(btVector3 *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6) { + btVector3 arg1 ; + btVector3 arg2 ; + btVector3 arg3 ; + btVector3 arg4 ; + btVector3 arg5 ; + btVector3 arg6 ; + btVector3 arg7 ; + btVector3 *argp1 ; + btVector3 *argp2 ; + btVector3 *argp3 ; + btVector3 *argp4 ; + btVector3 *argp5 ; + btVector3 *argp6 ; + btVector3 *argp7 ; + btMDefaultColors *result = 0 ; + btMDefaultColors *_swig_go_result; + + + argp1 = (btVector3 *)_swig_go_0; + if (argp1 == NULL) { + _swig_gopanic("Attempt to dereference null btVector3"); + } + arg1 = (btVector3)*argp1; + + + argp2 = (btVector3 *)_swig_go_1; + if (argp2 == NULL) { + _swig_gopanic("Attempt to dereference null btVector3"); + } + arg2 = (btVector3)*argp2; + + + argp3 = (btVector3 *)_swig_go_2; + if (argp3 == NULL) { + _swig_gopanic("Attempt to dereference null btVector3"); + } + arg3 = (btVector3)*argp3; + + + argp4 = (btVector3 *)_swig_go_3; + if (argp4 == NULL) { + _swig_gopanic("Attempt to dereference null btVector3"); + } + arg4 = (btVector3)*argp4; + + + argp5 = (btVector3 *)_swig_go_4; + if (argp5 == NULL) { + _swig_gopanic("Attempt to dereference null btVector3"); + } + arg5 = (btVector3)*argp5; + + + argp6 = (btVector3 *)_swig_go_5; + if (argp6 == NULL) { + _swig_gopanic("Attempt to dereference null btVector3"); + } + arg6 = (btVector3)*argp6; + + + argp7 = (btVector3 *)_swig_go_6; + if (argp7 == NULL) { + _swig_gopanic("Attempt to dereference null btVector3"); + } + arg7 = (btVector3)*argp7; + + + result = (btMDefaultColors *)new btMDefaultColors(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + *(btMDefaultColors **)&_swig_go_result = (btMDefaultColors *)result; + return _swig_go_result; +} + + +void _wrap_delete_btMDefaultColors_mbt_e879218550ba2e2b(btMDefaultColors *_swig_go_0) { + btMDefaultColors *arg1 = (btMDefaultColors *) 0 ; + + arg1 = *(btMDefaultColors **)&_swig_go_0; + + delete arg1; + +} + + +btMDebugDrawLiner *_wrap__swig_NewDirectorBtMDebugDrawLinerBtMDebugDrawLiner_mbt_e879218550ba2e2b(intgo _swig_go_0) { + int arg1 ; + btMDebugDrawLiner *result = 0 ; + btMDebugDrawLiner *_swig_go_result; + + arg1 = (int)_swig_go_0; + + result = new SwigDirector_btMDebugDrawLiner(arg1); + *(btMDebugDrawLiner **)&_swig_go_result = (btMDebugDrawLiner *)result; + return _swig_go_result; +} + + +void _wrap_DeleteDirectorBtMDebugDrawLiner_mbt_e879218550ba2e2b(btMDebugDrawLiner *_swig_go_0) { + btMDebugDrawLiner *arg1 = (btMDebugDrawLiner *) 0 ; + + arg1 = *(btMDebugDrawLiner **)&_swig_go_0; + + delete arg1; + +} + + +btMDebugDrawLiner *_wrap_new_btMDebugDrawLiner_mbt_e879218550ba2e2b() { + btMDebugDrawLiner *result = 0 ; + btMDebugDrawLiner *_swig_go_result; + + + _swig_gopanic("accessing abstract class or protected constructor"); + *(btMDebugDrawLiner **)&_swig_go_result = (btMDebugDrawLiner *)result; + return _swig_go_result; +} + + +void _wrap_delete_btMDebugDrawLiner_mbt_e879218550ba2e2b(btMDebugDrawLiner *_swig_go_0) { + btMDebugDrawLiner *arg1 = (btMDebugDrawLiner *) 0 ; + + arg1 = *(btMDebugDrawLiner **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btMDebugDrawLiner_drawLine_mbt_e879218550ba2e2b(btMDebugDrawLiner *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btMDebugDrawLiner *arg1 = (btMDebugDrawLiner *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btMDebugDrawLiner **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +btMDebugDraw *_wrap_new_btMDebugDraw_mbt_e879218550ba2e2b() { + btMDebugDraw *result = 0 ; + btMDebugDraw *_swig_go_result; + + + result = (btMDebugDraw *)new btMDebugDraw(); + *(btMDebugDraw **)&_swig_go_result = (btMDebugDraw *)result; + return _swig_go_result; +} + + +void _wrap_delete_btMDebugDraw_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + + delete arg1; + +} + + +void _wrap_btMDebugDraw_drawLine__SWIG_0_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + (arg1)->drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5); + +} + + +void _wrap_btMDebugDraw_drawSphere__SWIG_0_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, float _swig_go_1, btTransform *_swig_go_2, btVector3 *_swig_go_3) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btScalar arg2 ; + btTransform *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = *(btTransform **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawSphere(arg2,(btTransform const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btMDebugDraw_drawSphere__SWIG_1_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2, btVector3 *_swig_go_3) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawSphere((btVector3 const &)*arg2,arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btMDebugDraw_drawTriangle__SWIG_0_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, btVector3 *_swig_go_5, btVector3 *_swig_go_6, btVector3 *_swig_go_7, float _swig_go_8) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btVector3 *arg6 = 0 ; + btVector3 *arg7 = 0 ; + btVector3 *arg8 = 0 ; + btScalar arg9 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + arg7 = *(btVector3 **)&_swig_go_6; + arg8 = *(btVector3 **)&_swig_go_7; + arg9 = (btScalar)_swig_go_8; + + (arg1)->drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8,arg9); + +} + + +void _wrap_btMDebugDraw_drawTriangle__SWIG_1_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, btVector3 *_swig_go_4, float _swig_go_5) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btVector3 *arg5 = 0 ; + btScalar arg6 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + arg6 = (btScalar)_swig_go_5; + + (arg1)->drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,arg6); + +} + + +void _wrap_btMDebugDraw_drawAabb_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawAabb((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btMDebugDraw_drawTransform_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btTransform *_swig_go_1, float _swig_go_2) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btTransform *arg2 = 0 ; + btScalar arg3 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btTransform **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + + (arg1)->drawTransform((btTransform const &)*arg2,arg3); + +} + + +void _wrap_btMDebugDraw_drawArc__SWIG_0_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, btVector3 *_swig_go_8, bool _swig_go_9, float _swig_go_10) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + btScalar arg8 ; + btVector3 *arg9 = 0 ; + bool arg10 ; + btScalar arg11 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + arg9 = *(btVector3 **)&_swig_go_8; + arg10 = (bool)_swig_go_9; + arg11 = (btScalar)_swig_go_10; + + (arg1)->drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10,arg11); + +} + + +void _wrap_btMDebugDraw_drawArc__SWIG_1_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, btVector3 *_swig_go_8, bool _swig_go_9) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + btScalar arg8 ; + btVector3 *arg9 = 0 ; + bool arg10 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + arg9 = *(btVector3 **)&_swig_go_8; + arg10 = (bool)_swig_go_9; + + (arg1)->drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10); + +} + + +void _wrap_btMDebugDraw_drawSpherePatch__SWIG_0_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, float _swig_go_8, btVector3 *_swig_go_9, float _swig_go_10, bool _swig_go_11) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + btScalar arg8 ; + btScalar arg9 ; + btVector3 *arg10 = 0 ; + btScalar arg11 ; + bool arg12 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + arg9 = (btScalar)_swig_go_8; + arg10 = *(btVector3 **)&_swig_go_9; + arg11 = (btScalar)_swig_go_10; + arg12 = (bool)_swig_go_11; + + (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11,arg12); + +} + + +void _wrap_btMDebugDraw_drawSpherePatch__SWIG_1_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, float _swig_go_8, btVector3 *_swig_go_9, float _swig_go_10) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + btScalar arg8 ; + btScalar arg9 ; + btVector3 *arg10 = 0 ; + btScalar arg11 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + arg9 = (btScalar)_swig_go_8; + arg10 = *(btVector3 **)&_swig_go_9; + arg11 = (btScalar)_swig_go_10; + + (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11); + +} + + +void _wrap_btMDebugDraw_drawSpherePatch__SWIG_2_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3, float _swig_go_4, float _swig_go_5, float _swig_go_6, float _swig_go_7, float _swig_go_8, btVector3 *_swig_go_9) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + btScalar arg5 ; + btScalar arg6 ; + btScalar arg7 ; + btScalar arg8 ; + btScalar arg9 ; + btVector3 *arg10 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + arg5 = (btScalar)_swig_go_4; + arg6 = (btScalar)_swig_go_5; + arg7 = (btScalar)_swig_go_6; + arg8 = (btScalar)_swig_go_7; + arg9 = (btScalar)_swig_go_8; + arg10 = *(btVector3 **)&_swig_go_9; + + (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10); + +} + + +void _wrap_btMDebugDraw_drawBox__SWIG_0_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btMDebugDraw_drawBox__SWIG_1_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + (arg1)->drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); + +} + + +void _wrap_btMDebugDraw_drawCapsule_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, float _swig_go_1, float _swig_go_2, intgo _swig_go_3, btTransform *_swig_go_4, btVector3 *_swig_go_5) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + int arg4 ; + btTransform *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->drawCapsule(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btMDebugDraw_drawCylinder_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, float _swig_go_1, float _swig_go_2, intgo _swig_go_3, btTransform *_swig_go_4, btVector3 *_swig_go_5) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + int arg4 ; + btTransform *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->drawCylinder(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btMDebugDraw_drawCone_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, float _swig_go_1, float _swig_go_2, intgo _swig_go_3, btTransform *_swig_go_4, btVector3 *_swig_go_5) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btScalar arg2 ; + btScalar arg3 ; + int arg4 ; + btTransform *arg5 = 0 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = (btScalar)_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = (int)_swig_go_3; + arg5 = *(btTransform **)&_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->drawCone(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btMDebugDraw_drawPlane_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, float _swig_go_2, btTransform *_swig_go_3, btVector3 *_swig_go_4) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btScalar arg3 ; + btTransform *arg4 = 0 ; + btVector3 *arg5 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = (btScalar)_swig_go_2; + arg4 = *(btTransform **)&_swig_go_3; + arg5 = *(btVector3 **)&_swig_go_4; + + (arg1)->drawPlane((btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); + +} + + +void _wrap_btMDebugDraw_clearLines_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + + (arg1)->clearLines(); + +} + + +void _wrap_btMDebugDraw_flushLines_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + + (arg1)->flushLines(); + +} + + +btIDebugDraw::DefaultColors *_wrap_btMDebugDraw_getDefaultColors_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btIDebugDraw::DefaultColors result; + btIDebugDraw::DefaultColors *_swig_go_result; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + + result = ((btMDebugDraw const *)arg1)->getDefaultColors(); + *(btIDebugDraw::DefaultColors **)&_swig_go_result = new btIDebugDraw::DefaultColors(result); + return _swig_go_result; +} + + +void _wrap_btMDebugDraw_setMDefaultColors_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btMDefaultColors *_swig_go_1) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btMDefaultColors *arg2 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btMDefaultColors **)&_swig_go_1; + + (arg1)->setMDefaultColors((btMDefaultColors const &)*arg2); + +} + + +void _wrap_btMDebugDraw_setLiner_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btMDebugDrawLiner *_swig_go_1) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btMDebugDrawLiner *arg2 = (btMDebugDrawLiner *) 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btMDebugDrawLiner **)&_swig_go_1; + + (arg1)->setLiner(arg2); + +} + + +btMDebugDrawLiner *_wrap_btMDebugDraw_getLiner_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btMDebugDrawLiner *result = 0 ; + btMDebugDrawLiner *_swig_go_result; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + + result = (btMDebugDrawLiner *)(arg1)->getLiner(); + *(btMDebugDrawLiner **)&_swig_go_result = (btMDebugDrawLiner *)result; + return _swig_go_result; +} + + +void _wrap_btMDebugDraw_setDebugMode_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, intgo _swig_go_1) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + int arg2 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = (int)_swig_go_1; + + (arg1)->setDebugMode(arg2); + +} + + +intgo _wrap_btMDebugDraw_getDebugMode_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + int result; + intgo _swig_go_result; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + + result = (int)((btMDebugDraw const *)arg1)->getDebugMode(); + _swig_go_result = result; + return _swig_go_result; +} + + +void _wrap_btMDebugDraw_drawLine__SWIG_1_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, btVector3 *_swig_go_3) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btVector3 *arg4 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = *(btVector3 **)&_swig_go_3; + + (arg1)->drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); + +} + + +void _wrap_btMDebugDraw_drawContactPoint_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, btVector3 *_swig_go_2, float _swig_go_3, intgo _swig_go_4, btVector3 *_swig_go_5) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + btVector3 *arg3 = 0 ; + btScalar arg4 ; + int arg5 ; + btVector3 *arg6 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + arg3 = *(btVector3 **)&_swig_go_2; + arg4 = (btScalar)_swig_go_3; + arg5 = (int)_swig_go_4; + arg6 = *(btVector3 **)&_swig_go_5; + + (arg1)->drawContactPoint((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5,(btVector3 const &)*arg6); + +} + + +void _wrap_btMDebugDraw_reportErrorWarning_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, _gostring_ _swig_go_1) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + + arg2 = (char *)malloc(_swig_go_1.n + 1); + memcpy(arg2, _swig_go_1.p, _swig_go_1.n); + arg2[_swig_go_1.n] = '\0'; + + + (arg1)->reportErrorWarning((char const *)arg2); + + free(arg2); +} + + +void _wrap_btMDebugDraw_draw3dText_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btVector3 *_swig_go_1, _gostring_ _swig_go_2) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btVector3 *arg2 = 0 ; + char *arg3 = (char *) 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btVector3 **)&_swig_go_1; + + arg3 = (char *)malloc(_swig_go_2.n + 1); + memcpy(arg3, _swig_go_2.p, _swig_go_2.n); + arg3[_swig_go_2.n] = '\0'; + + + (arg1)->draw3dText((btVector3 const &)*arg2,(char const *)arg3); + + free(arg3); +} + + +void _wrap_btMDebugDraw_setDefaultColors_mbt_e879218550ba2e2b(btMDebugDraw *_swig_go_0, btIDebugDraw::DefaultColors *_swig_go_1) { + btMDebugDraw *arg1 = (btMDebugDraw *) 0 ; + btIDebugDraw::DefaultColors *arg2 = 0 ; + + arg1 = *(btMDebugDraw **)&_swig_go_0; + arg2 = *(btIDebugDraw::DefaultColors **)&_swig_go_1; + + btIDebugDraw *swig_b0 = (btIDebugDraw *)arg1; + (swig_b0)->setDefaultColors((btIDebugDraw::DefaultColors const &)*arg2); + +} + + +#ifdef __cplusplus +} +#endif + diff --git a/pkg/mphysics/mbt/mbt.go b/pkg/mphysics/mbt/mbt.go new file mode 100644 index 00000000..bc6a9864 --- /dev/null +++ b/pkg/mphysics/mbt/mbt.go @@ -0,0 +1,54340 @@ +//go:build windows +// +build windows + +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.2.0 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +// source: C:\MMD\mlib_go\pkg\mbt\bullet.i + +package mbt + +/* +#define intgo swig_intgo +typedef void *swig_voidp; + +#include +#include + + +typedef ptrdiff_t intgo; +typedef size_t uintgo; + + + +typedef struct { char *p; intgo n; } _gostring_; +typedef struct { void* array; intgo len; intgo cap; } _goslice_; + + +typedef long long swig_type_1; +typedef void* swig_type_2; +typedef void* swig_type_3; +typedef void* swig_type_4; +typedef void* swig_type_5; +typedef long long swig_type_6; +typedef void* swig_type_7; +typedef void* swig_type_8; +typedef void* swig_type_9; +typedef void* swig_type_10; +typedef long long swig_type_11; +typedef void* swig_type_12; +typedef void* swig_type_13; +typedef void* swig_type_14; +typedef void* swig_type_15; +typedef long long swig_type_16; +typedef long long swig_type_17; +typedef long long swig_type_18; +typedef long long swig_type_19; +typedef long long swig_type_20; +typedef long long swig_type_21; +typedef long long swig_type_22; +typedef long long swig_type_23; +typedef _gostring_ swig_type_24; +typedef _gostring_ swig_type_25; +typedef _gostring_ swig_type_26; +typedef _gostring_ swig_type_27; +typedef _gostring_ swig_type_28; +typedef _gostring_ swig_type_29; +typedef _gostring_ swig_type_30; +typedef _gostring_ swig_type_31; +typedef _gostring_ swig_type_32; +typedef _gostring_ swig_type_33; +typedef _gostring_ swig_type_34; +typedef _gostring_ swig_type_35; +typedef _gostring_ swig_type_36; +typedef _gostring_ swig_type_37; +typedef _gostring_ swig_type_38; +typedef _gostring_ swig_type_39; +typedef _gostring_ swig_type_40; +typedef _gostring_ swig_type_41; +typedef long long swig_type_42; +typedef long long swig_type_43; +typedef _gostring_ swig_type_44; +typedef _gostring_ swig_type_45; +typedef _gostring_ swig_type_46; +typedef _gostring_ swig_type_47; +typedef _gostring_ swig_type_48; +typedef _gostring_ swig_type_49; +typedef _gostring_ swig_type_50; +typedef _gostring_ swig_type_51; +typedef _gostring_ swig_type_52; +typedef _gostring_ swig_type_53; +typedef _gostring_ swig_type_54; +typedef _gostring_ swig_type_55; +typedef _gostring_ swig_type_56; +typedef _gostring_ swig_type_57; +typedef _gostring_ swig_type_58; +typedef _gostring_ swig_type_59; +typedef _gostring_ swig_type_60; +typedef _gostring_ swig_type_61; +typedef _gostring_ swig_type_62; +typedef _gostring_ swig_type_63; +typedef _gostring_ swig_type_64; +typedef _gostring_ swig_type_65; +typedef _gostring_ swig_type_66; +typedef _gostring_ swig_type_67; +typedef _gostring_ swig_type_68; +typedef _gostring_ swig_type_69; +typedef _gostring_ swig_type_70; +typedef _gostring_ swig_type_71; +typedef _gostring_ swig_type_72; +typedef _gostring_ swig_type_73; +typedef _gostring_ swig_type_74; +typedef _gostring_ swig_type_75; +typedef _gostring_ swig_type_76; +typedef long long swig_type_77; +typedef _gostring_ swig_type_78; +typedef _gostring_ swig_type_79; +typedef _gostring_ swig_type_80; +typedef _gostring_ swig_type_81; +typedef _gostring_ swig_type_82; +typedef _gostring_ swig_type_83; +typedef long long swig_type_84; +typedef long long swig_type_85; +typedef _gostring_ swig_type_86; +typedef _gostring_ swig_type_87; +typedef _gostring_ swig_type_88; +typedef _gostring_ swig_type_89; +typedef _gostring_ swig_type_90; +typedef _gostring_ swig_type_91; +typedef void* swig_type_92; +typedef void* swig_type_93; +typedef void* swig_type_94; +typedef void* swig_type_95; +typedef void* swig_type_96; +typedef void* swig_type_97; +typedef void* swig_type_98; +typedef void* swig_type_99; +typedef void* swig_type_100; +typedef void* swig_type_101; +typedef void* swig_type_102; +typedef void* swig_type_103; +typedef void* swig_type_104; +typedef void* swig_type_105; +typedef void* swig_type_106; +typedef void* swig_type_107; +typedef _gostring_ swig_type_108; +typedef _gostring_ swig_type_109; +typedef _gostring_ swig_type_110; +typedef _gostring_ swig_type_111; +typedef _gostring_ swig_type_112; +typedef _gostring_ swig_type_113; +typedef _gostring_ swig_type_114; +typedef _gostring_ swig_type_115; +typedef _gostring_ swig_type_116; +typedef _gostring_ swig_type_117; +typedef _gostring_ swig_type_118; +typedef _gostring_ swig_type_119; +typedef _gostring_ swig_type_120; +typedef _gostring_ swig_type_121; +typedef _gostring_ swig_type_122; +typedef _gostring_ swig_type_123; +typedef _gostring_ swig_type_124; +typedef _gostring_ swig_type_125; +typedef _gostring_ swig_type_126; +typedef _gostring_ swig_type_127; +typedef _gostring_ swig_type_128; +typedef _gostring_ swig_type_129; +typedef _gostring_ swig_type_130; +typedef _gostring_ swig_type_131; +typedef _gostring_ swig_type_132; +typedef _gostring_ swig_type_133; +typedef _gostring_ swig_type_134; +typedef _gostring_ swig_type_135; +typedef _gostring_ swig_type_136; +typedef _gostring_ swig_type_137; +typedef _gostring_ swig_type_138; +typedef _gostring_ swig_type_139; +typedef void* swig_type_140; +typedef void* swig_type_141; +typedef void* swig_type_142; +typedef void* swig_type_143; +typedef void* swig_type_144; +typedef void* swig_type_145; +typedef long long swig_type_146; +typedef long long swig_type_147; +typedef long long swig_type_148; +typedef void* swig_type_149; +typedef void* swig_type_150; +typedef void* swig_type_151; +typedef void* swig_type_152; +typedef void* swig_type_153; +typedef void* swig_type_154; +typedef _gostring_ swig_type_155; +typedef _gostring_ swig_type_156; +typedef _gostring_ swig_type_157; +typedef _gostring_ swig_type_158; +typedef void* swig_type_159; +typedef void* swig_type_160; +typedef void* swig_type_161; +typedef void* swig_type_162; +typedef void* swig_type_163; +typedef void* swig_type_164; +typedef _gostring_ swig_type_165; +typedef _gostring_ swig_type_166; +typedef _gostring_ swig_type_167; +typedef _gostring_ swig_type_168; +typedef _gostring_ swig_type_169; +typedef _gostring_ swig_type_170; +typedef _gostring_ swig_type_171; +typedef _gostring_ swig_type_172; +typedef _gostring_ swig_type_173; +typedef _gostring_ swig_type_174; +typedef _gostring_ swig_type_175; +extern void _wrap_Swig_free_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_Swig_malloc_mbt_e879218550ba2e2b(swig_intgo arg1); +extern swig_intgo _wrap_btGetVersion_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btIsDoublePrecision_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btInfMaskConverter__SWIG_0_mbt_e879218550ba2e2b(swig_intgo arg1); +extern uintptr_t _wrap_new_btInfMaskConverter__SWIG_1_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btInfMaskConverter_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btInfinityMask_set_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btInfinityMask_get_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btGetInfinityMask_mbt_e879218550ba2e2b(void); +extern float _wrap_btSqrt_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btFabs_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btCos_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btSin_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btTan_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btAcos_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btAsin_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btAtan_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btAtan2_mbt_e879218550ba2e2b(float arg1, float arg2); +extern float _wrap_btExp_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btLog_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btPow_mbt_e879218550ba2e2b(float arg1, float arg2); +extern float _wrap_btFmod_mbt_e879218550ba2e2b(float arg1, float arg2); +extern float _wrap_btAtan2Fast_mbt_e879218550ba2e2b(float arg1, float arg2); +extern _Bool _wrap_btFuzzyZero_mbt_e879218550ba2e2b(float arg1); +extern _Bool _wrap_btEqual_mbt_e879218550ba2e2b(float arg1, float arg2); +extern _Bool _wrap_btGreaterEqual_mbt_e879218550ba2e2b(float arg1, float arg2); +extern swig_intgo _wrap_btIsNegative_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btRadians_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btDegrees_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btFsel_mbt_e879218550ba2e2b(float arg1, float arg2, float arg3); +extern _Bool _wrap_btMachineIsLittleEndian_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btSelect__SWIG_0_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2, swig_intgo arg3); +extern swig_intgo _wrap_btSelect__SWIG_1_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2, swig_intgo arg3); +extern float _wrap_btSelect__SWIG_2_mbt_e879218550ba2e2b(swig_intgo arg1, float arg2, float arg3); +extern swig_intgo _wrap_btSwapEndian__SWIG_0_mbt_e879218550ba2e2b(swig_intgo arg1); +extern short _wrap_btSwapEndian__SWIG_1_mbt_e879218550ba2e2b(short arg1); +extern swig_intgo _wrap_btSwapEndian__SWIG_2_mbt_e879218550ba2e2b(swig_intgo arg1); +extern short _wrap_btSwapEndian__SWIG_3_mbt_e879218550ba2e2b(short arg1); +extern swig_intgo _wrap_btSwapEndianFloat_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_btUnswapEndianFloat_mbt_e879218550ba2e2b(swig_intgo arg1); +extern void _wrap_btSwapEndianDouble_mbt_e879218550ba2e2b(double arg1, swig_voidp arg2); +extern double _wrap_btUnswapEndianDouble_mbt_e879218550ba2e2b(swig_voidp arg1); +extern float _wrap_btLargeDot_mbt_e879218550ba2e2b(swig_voidp arg1, swig_voidp arg2, swig_intgo arg3); +extern float _wrap_btNormalizeAngle_mbt_e879218550ba2e2b(float arg1); +extern uintptr_t _wrap_new_btTypedObject_mbt_e879218550ba2e2b(swig_intgo arg1); +extern void _wrap_btTypedObject_m_objectType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedObject_m_objectType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btTypedObject_getObjectType_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btTypedObject_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btAlignedAllocInternal_mbt_e879218550ba2e2b(swig_type_1 arg1, swig_intgo arg2); +extern void _wrap_btAlignedFreeInternal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btAlignedAllocSetCustom_mbt_e879218550ba2e2b(swig_type_2 arg1, swig_type_3 arg2); +extern void _wrap_btAlignedAllocSetCustomAligned_mbt_e879218550ba2e2b(swig_type_4 arg1, swig_type_5 arg2); +extern uintptr_t _wrap_btAllocDefault_mbt_e879218550ba2e2b(swig_type_6 arg1); +extern void _wrap_btFreeDefault_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_sAllocFunc_set_mbt_e879218550ba2e2b(swig_type_7 arg1); +extern swig_type_8 _wrap_sAllocFunc_get_mbt_e879218550ba2e2b(void); +extern void _wrap_sFreeFunc_set_mbt_e879218550ba2e2b(swig_type_9 arg1); +extern swig_type_10 _wrap_sFreeFunc_get_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_btAlignedAllocDefault_mbt_e879218550ba2e2b(swig_type_11 arg1, swig_intgo arg2); +extern void _wrap_btAlignedFreeDefault_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_sAlignedAllocFunc_set_mbt_e879218550ba2e2b(swig_type_12 arg1); +extern swig_type_13 _wrap_sAlignedAllocFunc_get_mbt_e879218550ba2e2b(void); +extern void _wrap_sAlignedFreeFunc_set_mbt_e879218550ba2e2b(swig_type_14 arg1); +extern swig_type_15 _wrap_sAlignedFreeFunc_get_mbt_e879218550ba2e2b(void); +extern void _wrap_btVector3_m_floats_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btVector3_m_floats_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btVector3__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btVector3__SWIG_1_mbt_e879218550ba2e2b(float arg1, float arg2, float arg3); +extern float _wrap_btVector3_dot_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btVector3_length2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btVector3_length_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btVector3_norm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btVector3_safeNorm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btVector3_distance2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btVector3_distance_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btVector3_safeNormalize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btVector3_normalize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btVector3_normalized_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btVector3_rotate_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern float _wrap_btVector3_angle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btVector3_absolute_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btVector3_cross_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btVector3_triple_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btVector3_minAxis_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btVector3_maxAxis_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btVector3_furthestAxis_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btVector3_closestAxis_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVector3_setInterpolate3_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern uintptr_t _wrap_btVector3_lerp_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern float _wrap_btVector3_getX_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btVector3_getY_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btVector3_getZ_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVector3_setX_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btVector3_setY_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btVector3_setZ_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btVector3_setW_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btVector3_x_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btVector3_y_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btVector3_z_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btVector3_w_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVector3_setMax_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btVector3_setMin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btVector3_setValue_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4); +extern void _wrap_btVector3_getSkewSymmetricMatrix_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btVector3_setZero_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btVector3_isZero_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btVector3_fuzzyZero_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVector3_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btVector3_deSerialize__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btVector3_deSerialize__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btVector3_serializeFloat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btVector3_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btVector3_serializeDouble_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btVector3_deSerializeDouble_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_type_16 _wrap_btVector3_maxDot_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_type_17 arg3, swig_voidp arg4); +extern swig_type_18 _wrap_btVector3_minDot_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_type_19 arg3, swig_voidp arg4); +extern uintptr_t _wrap_btVector3_dot3_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_delete_btVector3_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btDot_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btDistance2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btDistance_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btAngle__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCross_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btTriple_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_lerp_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern uintptr_t _wrap_new_btVector4__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btVector4__SWIG_1_mbt_e879218550ba2e2b(float arg1, float arg2, float arg3, float arg4); +extern uintptr_t _wrap_btVector4_absolute4_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btVector4_getW_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btVector4_maxAxis4_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btVector4_minAxis4_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btVector4_closestAxis4_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVector4_setValue_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4, float arg5); +extern void _wrap_delete_btVector4_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SetbtVector4_M_floats_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_voidp arg1); +extern swig_voidp _wrap_GetbtVector4_M_floats_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btVector4_dot_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btVector4_length2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btVector4_length_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btVector4_norm_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btVector4_safeNorm_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btVector4_distance2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btVector4_distance_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btVector4_safeNormalize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btVector4_normalize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btVector4_normalized_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btVector4_rotate_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern float _wrap_btVector4_angle_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btVector4_absolute_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btVector4_cross_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btVector4_triple_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btVector4_minAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btVector4_maxAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btVector4_furthestAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btVector4_closestAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btVector4_setInterpolate3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, float arg3); +extern uintptr_t _wrap_btVector4_lerp_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern float _wrap_btVector4_getX_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btVector4_getY_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btVector4_getZ_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btVector4_setX_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btVector4_setY_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btVector4_setZ_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btVector4_setW_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btVector4_x_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btVector4_y_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btVector4_z_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btVector4_w_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btVector4_setMax_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btVector4_setMin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btVector4_getSkewSymmetricMatrix_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btVector4_setZero_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btVector4_isZero_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btVector4_fuzzyZero_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btVector4_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btVector4_deSerialize__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btVector4_deSerialize__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btVector4_serializeFloat_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btVector4_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btVector4_serializeDouble_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btVector4_deSerializeDouble_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern swig_type_20 _wrap_btVector4_maxDot_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_type_21 arg2, swig_voidp arg3); +extern swig_type_22 _wrap_btVector4_minDot_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_type_23 arg2, swig_voidp arg3); +extern uintptr_t _wrap_btVector4_dot3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSwapScalarEndian_mbt_e879218550ba2e2b(float arg1, swig_voidp arg2); +extern void _wrap_btSwapVector3Endian_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btUnSwapVector3Endian_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVector3FloatData_m_floats_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btVector3FloatData_m_floats_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btVector3FloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btVector3FloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVector3DoubleData_m_floats_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btVector3DoubleData_m_floats_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btVector3DoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btVector3DoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btQuadWord_getX_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btQuadWord_getY_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btQuadWord_getZ_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuadWord_setX_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btQuadWord_setY_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btQuadWord_setZ_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btQuadWord_setW_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btQuadWord_x_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btQuadWord_y_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btQuadWord_z_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btQuadWord_w_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuadWord_setValue__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4); +extern void _wrap_btQuadWord_setValue__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4, float arg5); +extern uintptr_t _wrap_new_btQuadWord__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btQuadWord__SWIG_1_mbt_e879218550ba2e2b(float arg1, float arg2, float arg3); +extern uintptr_t _wrap_new_btQuadWord__SWIG_2_mbt_e879218550ba2e2b(float arg1, float arg2, float arg3, float arg4); +extern void _wrap_btQuadWord_setMax_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btQuadWord_setMin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btQuadWord_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btQuaternion__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btQuaternion__SWIG_1_mbt_e879218550ba2e2b(float arg1, float arg2, float arg3, float arg4); +extern uintptr_t _wrap_new_btQuaternion__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern uintptr_t _wrap_new_btQuaternion__SWIG_3_mbt_e879218550ba2e2b(float arg1, float arg2, float arg3); +extern void _wrap_btQuaternion_setRotation_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern void _wrap_btQuaternion_setEuler_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4); +extern void _wrap_btQuaternion_setEulerZYX_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4); +extern void _wrap_btQuaternion_getEulerZYX_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, swig_voidp arg3, swig_voidp arg4); +extern float _wrap_btQuaternion_dot_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btQuaternion_length2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btQuaternion_length_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btQuaternion_safeNormalize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btQuaternion_normalize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btQuaternion_normalized_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btQuaternion_angle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btQuaternion_angleShortestPath_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btQuaternion_getAngle_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btQuaternion_getAngleShortestPath_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btQuaternion_getAxis_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btQuaternion_inverse_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btQuaternion_farthest_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuaternion_nearest_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuaternion_slerp_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern uintptr_t _wrap_btQuaternion_getIdentity_mbt_e879218550ba2e2b(void); +extern float _wrap_btQuaternion_getW_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuaternion_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btQuaternion_deSerialize__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btQuaternion_deSerialize__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btQuaternion_serializeFloat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btQuaternion_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btQuaternion_serializeDouble_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btQuaternion_deSerializeDouble_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btQuaternion_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btQuaternion_getX_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btQuaternion_getY_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btQuaternion_getZ_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btQuaternion_setX_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btQuaternion_setY_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btQuaternion_setZ_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btQuaternion_setW_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btQuaternion_x_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btQuaternion_y_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btQuaternion_z_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btQuaternion_w_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btQuaternion_setValue__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2, float arg3); +extern void _wrap_btQuaternion_setValue__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2, float arg3, float arg4); +extern void _wrap_btQuaternion_setMax_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btQuaternion_setMin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_dot_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_length_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btAngle__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_inverse_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_slerp_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern uintptr_t _wrap_quatRotate_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_shortestArcQuat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_shortestArcQuatNormalize2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btQuaternionFloatData_m_floats_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btQuaternionFloatData_m_floats_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btQuaternionFloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btQuaternionFloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuaternionDoubleData_m_floats_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btQuaternionDoubleData_m_floats_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btQuaternionDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btQuaternionDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btMatrix3x3__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btMatrix3x3__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btMatrix3x3__SWIG_2_mbt_e879218550ba2e2b(float arg1, float arg2, float arg3, float arg4, float arg5, float arg6, float arg7, float arg8, float arg9); +extern uintptr_t _wrap_new_btMatrix3x3__SWIG_3_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btMatrix3x3__SWIG_4_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btMatrix3x3_getColumn_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btMatrix3x3_getRow_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btMatrix3x3_setFromOpenGLSubMatrix_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern void _wrap_btMatrix3x3_setValue_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4, float arg5, float arg6, float arg7, float arg8, float arg9, float arg10); +extern void _wrap_btMatrix3x3_setRotation_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btMatrix3x3_setEulerYPR_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4); +extern void _wrap_btMatrix3x3_setEulerZYX_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4); +extern void _wrap_btMatrix3x3_setIdentity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMatrix3x3_setZero_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btMatrix3x3_getIdentity_mbt_e879218550ba2e2b(void); +extern void _wrap_btMatrix3x3_getOpenGLSubMatrix_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern void _wrap_btMatrix3x3_getRotation_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btMatrix3x3_getEulerYPR_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, swig_voidp arg3, swig_voidp arg4); +extern void _wrap_btMatrix3x3_getEulerZYX__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, swig_voidp arg3, swig_voidp arg4, swig_intgo arg5); +extern void _wrap_btMatrix3x3_getEulerZYX__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, swig_voidp arg3, swig_voidp arg4); +extern uintptr_t _wrap_btMatrix3x3_scaled_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btMatrix3x3_determinant_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btMatrix3x3_adjoint_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btMatrix3x3_absolute_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btMatrix3x3_transpose_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btMatrix3x3_inverse_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btMatrix3x3_solve33_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMatrix3x3_transposeTimes_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMatrix3x3_timesTranspose_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btMatrix3x3_tdotx_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btMatrix3x3_tdoty_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btMatrix3x3_tdotz_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btMatrix3x3_extractRotation__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, swig_intgo arg4); +extern void _wrap_btMatrix3x3_extractRotation__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern void _wrap_btMatrix3x3_extractRotation__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btMatrix3x3_diagonalize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, swig_intgo arg4); +extern float _wrap_btMatrix3x3_cofac_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, swig_intgo arg4, swig_intgo arg5); +extern void _wrap_btMatrix3x3_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btMatrix3x3_serializeFloat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btMatrix3x3_deSerialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btMatrix3x3_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btMatrix3x3_deSerializeDouble_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btMatrix3x3_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMatrix3x3FloatData_m_el_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMatrix3x3FloatData_m_el_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btMatrix3x3FloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btMatrix3x3FloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMatrix3x3DoubleData_m_el_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMatrix3x3DoubleData_m_el_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btMatrix3x3DoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btMatrix3x3DoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTransform__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btTransform__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btTransform__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTransform__SWIG_3_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btTransform__SWIG_4_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTransform__SWIG_5_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTransform_mult_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btTransform_getBasis__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTransform_getBasis__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTransform_getOrigin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTransform_getOrigin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTransform_getRotation_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTransform_setFromOpenGLMatrix_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern void _wrap_btTransform_getOpenGLMatrix_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern void _wrap_btTransform_setOrigin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTransform_invXform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTransform_setBasis_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTransform_setRotation_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTransform_setIdentity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTransform_inverse_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTransform_inverseTimes_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTransform_getIdentity_mbt_e879218550ba2e2b(void); +extern void _wrap_btTransform_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTransform_serializeFloat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTransform_deSerialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTransform_deSerializeDouble_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTransform_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btTransform_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTransformFloatData_m_basis_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTransformFloatData_m_basis_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTransformFloatData_m_origin_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTransformFloatData_m_origin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTransformFloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btTransformFloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTransformDoubleData_m_basis_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTransformDoubleData_m_basis_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTransformDoubleData_m_origin_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTransformDoubleData_m_origin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTransformDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btTransformDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btMotionState_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMotionState_getWorldTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btMotionState_setWorldTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDefaultMotionState_m_graphicsWorldTrans_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDefaultMotionState_m_graphicsWorldTrans_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultMotionState_m_centerOfMassOffset_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDefaultMotionState_m_centerOfMassOffset_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultMotionState_m_startWorldTrans_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDefaultMotionState_m_startWorldTrans_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultMotionState_m_userPointer_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDefaultMotionState_m_userPointer_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDefaultMotionState__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btDefaultMotionState__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDefaultMotionState__SWIG_2_mbt_e879218550ba2e2b(void); +extern void _wrap_btDefaultMotionState_getWorldTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDefaultMotionState_setWorldTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btDefaultMotionState_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_BOX_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_TRIANGLE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_TETRAHEDRAL_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CONVEX_HULL_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CUSTOM_POLYHEDRAL_SHAPE_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_IMPLICIT_CONVEX_SHAPES_START_HERE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SPHERE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_MULTI_SPHERE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CAPSULE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CONE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CONVEX_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CYLINDER_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_UNIFORM_SCALING_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_MINKOWSKI_SUM_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BOX_2D_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CONVEX_2D_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CUSTOM_CONVEX_SHAPE_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CONCAVE_SHAPES_START_HERE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_TRIANGLE_MESH_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_FAST_CONCAVE_MESH_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_TERRAIN_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_GIMPACT_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_EMPTY_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_STATIC_PLANE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CUSTOM_CONCAVE_SHAPE_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SDF_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CONCAVE_SHAPES_END_HERE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_COMPOUND_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOFTBODY_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_HFFLUID_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_INVALID_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_MAX_BROADPHASE_COLLISION_TYPES_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DefaultFilter_btBroadphaseProxy_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_StaticFilter_btBroadphaseProxy_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_KinematicFilter_btBroadphaseProxy_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DebrisFilter_btBroadphaseProxy_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SensorTrigger_btBroadphaseProxy_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CharacterFilter_btBroadphaseProxy_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_AllFilter_btBroadphaseProxy_mbt_e879218550ba2e2b(void); +extern void _wrap_btBroadphaseProxy_m_clientObject_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBroadphaseProxy_m_clientObject_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBroadphaseProxy_m_collisionFilterGroup_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btBroadphaseProxy_m_collisionFilterGroup_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBroadphaseProxy_m_collisionFilterMask_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btBroadphaseProxy_m_collisionFilterMask_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBroadphaseProxy_m_uniqueId_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btBroadphaseProxy_m_uniqueId_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBroadphaseProxy_m_aabbMin_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBroadphaseProxy_m_aabbMin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBroadphaseProxy_m_aabbMax_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBroadphaseProxy_m_aabbMax_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btBroadphaseProxy_getUid_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btBroadphaseProxy__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btBroadphaseProxy__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4, swig_intgo arg5); +extern _Bool _wrap_btBroadphaseProxy_isPolyhedral_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btBroadphaseProxy_isConvex_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btBroadphaseProxy_isNonMoving_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btBroadphaseProxy_isConcave_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btBroadphaseProxy_isCompound_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btBroadphaseProxy_isSoftBody_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btBroadphaseProxy_isInfinite_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btBroadphaseProxy_isConvex2d_mbt_e879218550ba2e2b(swig_intgo arg1); +extern void _wrap_delete_btBroadphaseProxy_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btBroadphasePair__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btBroadphasePair__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btBroadphasePair_m_pProxy0_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBroadphasePair_m_pProxy0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBroadphasePair_m_pProxy1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBroadphasePair_m_pProxy1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBroadphasePair_m_algorithm_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBroadphasePair_m_algorithm_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btBroadphasePair_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btBroadphasePairSortPredicate_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btBroadphasePairSortPredicate_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btCollisionShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btCollisionShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_voidp arg3); +extern float _wrap_btCollisionShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btCollisionShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btCollisionShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, uintptr_t arg6, uintptr_t arg7); +extern _Bool _wrap_btCollisionShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionShape_isConvex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionShape_isConcave_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionShape_isCompound_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern swig_type_24 _wrap_btCollisionShape_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btCollisionShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionShape_setMargin_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionShape_getMargin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btCollisionShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_25 _wrap_btCollisionShape_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btCollisionShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionShapeData_m_name_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_26 arg2); +extern swig_type_27 _wrap_btCollisionShapeData_m_name_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionShapeData_m_shapeType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionShapeData_m_shapeType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionShapeData_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_28 arg2); +extern swig_type_29 _wrap_btCollisionShapeData_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btCollisionShapeData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btCollisionShapeData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletCollisionProbe_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btConvexShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btConvexShape_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btConvexShape_getMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexShape_getAabbNonVirtual_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btConvexShape_project_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_voidp arg4, swig_voidp arg5, uintptr_t arg6, uintptr_t arg7); +extern void _wrap_btConvexShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4); +extern void _wrap_btConvexShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btConvexShape_getAabbSlow_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btConvexShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexShape_setMargin_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConvexShape_getMargin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btConvexShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3); +extern void _wrap_btConvexShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btConvexShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btConvexShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btConvexShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btConvexShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, uintptr_t arg2); +extern swig_type_30 _wrap_btConvexShape_getName_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btConvexShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btConvexShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConvexShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btConvexShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btConvexShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btConvexShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_31 _wrap_btConvexShape_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConvexShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_convexHullSupport_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, uintptr_t arg4); +extern void _wrap_AabbExpand_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern _Bool _wrap_TestPointAgainstAabb2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_TestAabbAgainstAabb2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern _Bool _wrap_TestTriangleAgainstAabb2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btOutcode_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btRayAabb2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, uintptr_t arg4, swig_voidp arg5, float arg6, float arg7); +extern _Bool _wrap_btRayAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, swig_voidp arg5, uintptr_t arg6); +extern void _wrap_btTransformAabb__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btTransformAabb__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern swig_intgo _wrap_testQuantizedAabbAgainstQuantizedAabb_mbt_e879218550ba2e2b(swig_voidp arg1, swig_voidp arg2, swig_voidp arg3, swig_voidp arg4); +extern void _wrap_delete_btConvexInternalShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btConvexInternalShape_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexInternalShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexInternalShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConvexInternalShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3); +extern void _wrap_btConvexInternalShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btConvexInternalShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern void _wrap_btConvexInternalShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConvexInternalShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btConvexInternalShape_getAabbSlow_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btConvexInternalShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexInternalShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btConvexInternalShape_getLocalScalingNV_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexInternalShape_setMargin_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConvexInternalShape_getMargin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConvexInternalShape_getMarginNV_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btConvexInternalShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexInternalShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3); +extern swig_intgo _wrap_btConvexInternalShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_32 _wrap_btConvexInternalShape_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btConvexInternalShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConvexInternalShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConvexInternalShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btConvexInternalShape_getMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalShape_getAabbNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btConvexInternalShape_project_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_voidp arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btConvexInternalShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btConvexInternalShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btConvexInternalShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btConvexInternalShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btConvexInternalShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btConvexInternalShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, uintptr_t arg2); +extern swig_type_33 _wrap_btConvexInternalShape_getName_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btConvexInternalShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btConvexInternalShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConvexInternalShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btConvexInternalShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btConvexInternalShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btConvexInternalShapeData_m_collisionShapeData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexInternalShapeData_m_collisionShapeData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexInternalShapeData_m_localScaling_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexInternalShapeData_m_localScaling_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexInternalShapeData_m_implicitShapeDimensions_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexInternalShapeData_m_implicitShapeDimensions_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexInternalShapeData_m_collisionMargin_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConvexInternalShapeData_m_collisionMargin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexInternalShapeData_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btConvexInternalShapeData_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btConvexInternalShapeData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btConvexInternalShapeData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexInternalAabbCachingShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConvexInternalAabbCachingShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btConvexInternalAabbCachingShape_recalcLocalAabb_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btConvexInternalAabbCachingShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btConvexInternalAabbCachingShape_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConvexInternalAabbCachingShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalAabbCachingShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2); +extern void _wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern void _wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btConvexInternalAabbCachingShape_getAabbSlow_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btConvexInternalAabbCachingShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btConvexInternalAabbCachingShape_getLocalScalingNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalAabbCachingShape_setMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btConvexInternalAabbCachingShape_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btConvexInternalAabbCachingShape_getMarginNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btConvexInternalAabbCachingShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalAabbCachingShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, uintptr_t arg2); +extern swig_intgo _wrap_btConvexInternalAabbCachingShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_34 _wrap_btConvexInternalAabbCachingShape_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexInternalAabbCachingShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConvexInternalAabbCachingShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConvexInternalAabbCachingShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btConvexInternalAabbCachingShape_getMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalAabbCachingShape_getAabbNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btConvexInternalAabbCachingShape_project_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_voidp arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btConvexInternalAabbCachingShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btConvexInternalAabbCachingShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btConvexInternalAabbCachingShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btConvexInternalAabbCachingShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btConvexInternalAabbCachingShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btConvexInternalAabbCachingShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalAabbCachingShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalAabbCachingShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalAabbCachingShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalAabbCachingShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalAabbCachingShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalAabbCachingShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConvexInternalAabbCachingShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalAabbCachingShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, uintptr_t arg2); +extern swig_type_35 _wrap_btConvexInternalAabbCachingShape_getName_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btConvexInternalAabbCachingShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btConvexInternalAabbCachingShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalAabbCachingShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConvexInternalAabbCachingShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalAabbCachingShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btConvexInternalAabbCachingShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalAabbCachingShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btConvexInternalAabbCachingShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConvexInternalAabbCachingShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_new_btSphereShape_mbt_e879218550ba2e2b(float arg1); +extern uintptr_t _wrap_btSphereShape_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSphereShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btSphereShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4); +extern void _wrap_btSphereShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern void _wrap_btSphereShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern float _wrap_btSphereShape_getRadius_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSphereShape_setUnscaledRadius_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern swig_type_36 _wrap_btSphereShape_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSphereShape_setMargin_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSphereShape_getMargin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btSphereShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSphereShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSphereShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btSphereShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2); +extern void _wrap_btSphereShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btSphereShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern void _wrap_btSphereShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btSphereShape_getAabbSlow_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSphereShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btSphereShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btSphereShape_getLocalScalingNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btSphereShape_getMarginNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btSphereShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSphereShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, uintptr_t arg2); +extern swig_intgo _wrap_btSphereShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_37 _wrap_btSphereShape_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSphereShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btSphereShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btSphereShape_getMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSphereShape_getAabbNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSphereShape_project_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_voidp arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btSphereShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btSphereShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btSphereShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btSphereShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btSphereShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSphereShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSphereShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSphereShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSphereShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSphereShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSphereShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSphereShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btSphereShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btSphereShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSphereShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btSphereShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSphereShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btSphereShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSphereShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btSphereShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSphereShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_delete_btPolyhedralConvexShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btPolyhedralConvexShape_initializePolyhedralFeatures__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern _Bool _wrap_btPolyhedralConvexShape_initializePolyhedralFeatures__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPolyhedralConvexShape_setPolyhedralFeatures_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPolyhedralConvexShape_getConvexPolyhedron_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btPolyhedralConvexShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btPolyhedralConvexShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4); +extern void _wrap_btPolyhedralConvexShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern swig_intgo _wrap_btPolyhedralConvexShape_getNumVertices_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btPolyhedralConvexShape_getNumEdges_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPolyhedralConvexShape_getEdge_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btPolyhedralConvexShape_getVertex_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3); +extern swig_intgo _wrap_btPolyhedralConvexShape_getNumPlanes_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPolyhedralConvexShape_getPlane_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4); +extern _Bool _wrap_btPolyhedralConvexShape_isInside_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern uintptr_t _wrap_btPolyhedralConvexShape_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btPolyhedralConvexShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2); +extern void _wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern void _wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btPolyhedralConvexShape_getAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btPolyhedralConvexShape_getAabbSlow_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btPolyhedralConvexShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btPolyhedralConvexShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btPolyhedralConvexShape_getLocalScalingNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexShape_setMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btPolyhedralConvexShape_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btPolyhedralConvexShape_getMarginNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btPolyhedralConvexShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, uintptr_t arg2); +extern swig_intgo _wrap_btPolyhedralConvexShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_38 _wrap_btPolyhedralConvexShape_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPolyhedralConvexShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btPolyhedralConvexShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btPolyhedralConvexShape_getMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexShape_getAabbNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btPolyhedralConvexShape_project_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_voidp arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btPolyhedralConvexShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btPolyhedralConvexShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btPolyhedralConvexShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btPolyhedralConvexShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btPolyhedralConvexShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_39 _wrap_btPolyhedralConvexShape_getName_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btPolyhedralConvexShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btPolyhedralConvexShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btPolyhedralConvexShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btPolyhedralConvexShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btPolyhedralConvexShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btPolyhedralConvexAabbCachingShape_getNonvirtualAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btPolyhedralConvexAabbCachingShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btPolyhedralConvexAabbCachingShape_recalcLocalAabb_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btPolyhedralConvexAabbCachingShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_initializePolyhedralFeatures__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_initializePolyhedralFeatures__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setPolyhedralFeatures_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btPolyhedralConvexAabbCachingShape_getConvexPolyhedron_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btPolyhedralConvexAabbCachingShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btPolyhedralConvexAabbCachingShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btPolyhedralConvexAabbCachingShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, uintptr_t arg2); +extern swig_intgo _wrap_btPolyhedralConvexAabbCachingShape_getNumVertices_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btPolyhedralConvexAabbCachingShape_getNumEdges_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_getEdge_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btPolyhedralConvexAabbCachingShape_getVertex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, uintptr_t arg2); +extern swig_intgo _wrap_btPolyhedralConvexAabbCachingShape_getNumPlanes_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_getPlane_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_isInside_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern uintptr_t _wrap_btPolyhedralConvexAabbCachingShape_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btPolyhedralConvexAabbCachingShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btPolyhedralConvexAabbCachingShape_getAabbSlow_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btPolyhedralConvexAabbCachingShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btPolyhedralConvexAabbCachingShape_getLocalScalingNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btPolyhedralConvexAabbCachingShape_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btPolyhedralConvexAabbCachingShape_getMarginNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btPolyhedralConvexAabbCachingShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, uintptr_t arg2); +extern swig_intgo _wrap_btPolyhedralConvexAabbCachingShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_40 _wrap_btPolyhedralConvexAabbCachingShape_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPolyhedralConvexAabbCachingShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btPolyhedralConvexAabbCachingShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btPolyhedralConvexAabbCachingShape_getMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_getAabbNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btPolyhedralConvexAabbCachingShape_project_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_voidp arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btPolyhedralConvexAabbCachingShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btPolyhedralConvexAabbCachingShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btPolyhedralConvexAabbCachingShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btPolyhedralConvexAabbCachingShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btPolyhedralConvexAabbCachingShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_41 _wrap_btPolyhedralConvexAabbCachingShape_getName_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btPolyhedralConvexAabbCachingShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btPolyhedralConvexAabbCachingShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btPolyhedralConvexAabbCachingShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btPolyhedralConvexAabbCachingShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btPolyhedralConvexAabbCachingShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPolyhedralConvexAabbCachingShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btFace_m_indices_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btFace_m_indices_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btFace_m_plane_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btFace_m_plane_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btFace_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btFace_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btConvexPolyhedron_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btConvexPolyhedron_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_m_vertices_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexPolyhedron_m_vertices_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_m_faces_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexPolyhedron_m_faces_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_m_uniqueEdges_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexPolyhedron_m_uniqueEdges_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_m_localCenter_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexPolyhedron_m_localCenter_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_m_extents_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexPolyhedron_m_extents_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_m_radius_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConvexPolyhedron_m_radius_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_mC_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexPolyhedron_mC_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_mE_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexPolyhedron_mE_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_initialize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_initialize2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btConvexPolyhedron_testContainment_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPolyhedron_project_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_voidp arg4, swig_voidp arg5, uintptr_t arg6, uintptr_t arg7); +extern _Bool _wrap_IsAlmostZero1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btInternalVertexPair_mbt_e879218550ba2e2b(short arg1, short arg2); +extern void _wrap_btInternalVertexPair_m_v0_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btInternalVertexPair_m_v0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btInternalVertexPair_m_v1_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btInternalVertexPair_m_v1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btInternalVertexPair_getHash_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btInternalVertexPair_equals_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btInternalVertexPair_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btInternalEdge_mbt_e879218550ba2e2b(void); +extern void _wrap_btInternalEdge_m_face0_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btInternalEdge_m_face0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btInternalEdge_m_face1_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btInternalEdge_m_face1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btInternalEdge_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexHullComputer_vertices_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexHullComputer_vertices_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexHullComputer_original_vertex_index_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexHullComputer_original_vertex_index_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexHullComputer_edges_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexHullComputer_edges_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexHullComputer_faces_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexHullComputer_faces_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConvexHullComputer_compute__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, swig_intgo arg3, swig_intgo arg4, float arg5, float arg6); +extern float _wrap_btConvexHullComputer_compute__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, swig_intgo arg3, swig_intgo arg4, float arg5, float arg6); +extern uintptr_t _wrap_new_btConvexHullComputer_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btConvexHullComputer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexHullInternal_vertexList_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexHullInternal_vertexList_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexHullInternal_compute_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, _Bool arg3, swig_intgo arg4, swig_intgo arg5); +extern uintptr_t _wrap_btConvexHullInternal_getCoordinates_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btConvexHullInternal_shrink_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3); +extern uintptr_t _wrap_new_btConvexHullInternal_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btConvexHullInternal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_pointCmp_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_pointCmp_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_getVertexCopy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeometryUtil_getPlaneEquationsFromVertices_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeometryUtil_getVerticesFromPlaneEquations_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btGeometryUtil_isPointInsidePlanes_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern _Bool _wrap_btGeometryUtil_areVerticesBehindPlane_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern uintptr_t _wrap_new_btGeometryUtil_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btGeometryUtil_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletMathProbe_mbt_e879218550ba2e2b(void); +extern _Bool _wrap_notExist_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_GrahamVector3_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_GrahamVector3_m_angle_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_GrahamVector3_m_angle_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GrahamVector3_m_orgIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_GrahamVector3_m_orgIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_GrahamVector3_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SetGrahamVector3_M_floats_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_voidp arg1); +extern swig_voidp _wrap_GetGrahamVector3_M_floats_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_GrahamVector3_dot_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_GrahamVector3_length2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_GrahamVector3_length_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_GrahamVector3_norm_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_GrahamVector3_safeNorm_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_GrahamVector3_distance2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_GrahamVector3_distance_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_GrahamVector3_safeNormalize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_GrahamVector3_normalize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_GrahamVector3_normalized_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_GrahamVector3_rotate_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern float _wrap_GrahamVector3_angle_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_GrahamVector3_absolute_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_GrahamVector3_cross_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_GrahamVector3_triple_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_GrahamVector3_minAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_GrahamVector3_maxAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_GrahamVector3_furthestAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_GrahamVector3_closestAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_GrahamVector3_setInterpolate3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, float arg3); +extern uintptr_t _wrap_GrahamVector3_lerp_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern float _wrap_GrahamVector3_getX_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_GrahamVector3_getY_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_GrahamVector3_getZ_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_GrahamVector3_setX_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_GrahamVector3_setY_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_GrahamVector3_setZ_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_GrahamVector3_setW_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GrahamVector3_x_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_GrahamVector3_y_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_GrahamVector3_z_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_GrahamVector3_w_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_GrahamVector3_setMax_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_GrahamVector3_setMin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_GrahamVector3_setValue_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2, float arg3); +extern void _wrap_GrahamVector3_getSkewSymmetricMatrix_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_GrahamVector3_setZero_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_GrahamVector3_isZero_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_GrahamVector3_fuzzyZero_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_GrahamVector3_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_GrahamVector3_deSerialize__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_GrahamVector3_deSerialize__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_GrahamVector3_serializeFloat_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_GrahamVector3_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_GrahamVector3_serializeDouble_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_GrahamVector3_deSerializeDouble_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern swig_type_42 _wrap_GrahamVector3_maxDot_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_type_21 arg2, swig_voidp arg3); +extern swig_type_43 _wrap_GrahamVector3_minDot_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_type_23 arg2, swig_voidp arg3); +extern uintptr_t _wrap_GrahamVector3_dot3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btAngleCompareFunc_m_anchor_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btAngleCompareFunc_m_anchor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btAngleCompareFunc_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btAngleCompareFunc_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GrahamScanConvexHull2D_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btBoxShape_getHalfExtentsWithMargin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btBoxShape_getHalfExtentsWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btBoxShape_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBoxShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btBoxShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4); +extern uintptr_t _wrap_new_btBoxShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBoxShape_setMargin_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btBoxShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btBoxShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btBoxShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern void _wrap_btBoxShape_getPlane_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4); +extern swig_intgo _wrap_btBoxShape_getNumPlanes_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btBoxShape_getNumVertices_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btBoxShape_getNumEdges_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBoxShape_getVertex_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3); +extern void _wrap_btBoxShape_getPlaneEquation_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btBoxShape_getEdge_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3, uintptr_t arg4); +extern _Bool _wrap_btBoxShape_isInside_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern swig_type_44 _wrap_btBoxShape_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btBoxShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBoxShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3); +extern void _wrap_delete_btBoxShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btBoxShape_initializePolyhedralFeatures__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern _Bool _wrap_btBoxShape_initializePolyhedralFeatures__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBoxShape_setPolyhedralFeatures_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btBoxShape_getConvexPolyhedron_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBoxShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBoxShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btBoxShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2); +extern void _wrap_btBoxShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btBoxShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern void _wrap_btBoxShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btBoxShape_getAabbSlow_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btBoxShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBoxShape_getLocalScalingNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btBoxShape_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btBoxShape_getMarginNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btBoxShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_45 _wrap_btBoxShape_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBoxShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btBoxShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btBoxShape_getMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBoxShape_getAabbNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btBoxShape_project_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_voidp arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btBoxShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btBoxShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btBoxShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btBoxShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btBoxShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBoxShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBoxShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBoxShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBoxShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBoxShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBoxShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBoxShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btBoxShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBoxShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBoxShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btBoxShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBoxShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btBoxShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBoxShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btBoxShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBoxShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_new_btCapsuleShape__SWIG_1_mbt_e879218550ba2e2b(float arg1, float arg2); +extern void _wrap_btCapsuleShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern uintptr_t _wrap_btCapsuleShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCapsuleShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4); +extern void _wrap_btCapsuleShape_setMargin_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btCapsuleShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern swig_type_46 _wrap_btCapsuleShape_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btCapsuleShape_getUpAxis_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btCapsuleShape_getRadius_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btCapsuleShape_getHalfHeight_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCapsuleShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCapsuleShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btCapsuleShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_47 _wrap_btCapsuleShape_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btCapsuleShape_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btCapsuleShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShape_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btCapsuleShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2); +extern void _wrap_btCapsuleShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btCapsuleShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern void _wrap_btCapsuleShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btCapsuleShape_getAabbSlow_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btCapsuleShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btCapsuleShape_getLocalScalingNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShape_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShape_getMarginNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btCapsuleShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCapsuleShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btCapsuleShape_getMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShape_getAabbNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btCapsuleShape_project_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_voidp arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btCapsuleShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btCapsuleShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btCapsuleShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btCapsuleShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btCapsuleShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btCapsuleShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btCapsuleShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_new_btCapsuleShapeX_mbt_e879218550ba2e2b(float arg1, float arg2); +extern swig_type_48 _wrap_btCapsuleShapeX_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btCapsuleShapeX_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCapsuleShapeX_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCapsuleShapeX_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btCapsuleShapeX_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btCapsuleShapeX_setMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btCapsuleShapeX_getAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btCapsuleShapeX_getUpAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShapeX_getRadius_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShapeX_getHalfHeight_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeX_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShapeX_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btCapsuleShapeX_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_49 _wrap_btCapsuleShapeX_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCapsuleShapeX_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShapeX_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShapeX_getImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeX_setImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btCapsuleShapeX_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2); +extern void _wrap_btCapsuleShapeX_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btCapsuleShapeX_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern void _wrap_btCapsuleShapeX_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btCapsuleShapeX_getAabbSlow_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btCapsuleShapeX_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btCapsuleShapeX_getLocalScalingNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShapeX_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShapeX_getMarginNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btCapsuleShapeX_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeX_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCapsuleShapeX_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShapeX_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btCapsuleShapeX_getMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeX_getAabbNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btCapsuleShapeX_project_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_voidp arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btCapsuleShapeX_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btCapsuleShapeX_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShapeX_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btCapsuleShapeX_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btCapsuleShapeX_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeX_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeX_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeX_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeX_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeX_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeX_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeX_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btCapsuleShapeX_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeX_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShapeX_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeX_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btCapsuleShapeX_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeX_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btCapsuleShapeX_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeX_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_new_btCapsuleShapeZ_mbt_e879218550ba2e2b(float arg1, float arg2); +extern swig_type_50 _wrap_btCapsuleShapeZ_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btCapsuleShapeZ_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCapsuleShapeZ_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCapsuleShapeZ_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btCapsuleShapeZ_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btCapsuleShapeZ_setMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btCapsuleShapeZ_getAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btCapsuleShapeZ_getUpAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShapeZ_getRadius_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShapeZ_getHalfHeight_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeZ_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShapeZ_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btCapsuleShapeZ_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_51 _wrap_btCapsuleShapeZ_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCapsuleShapeZ_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShapeZ_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShapeZ_getImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeZ_setImplicitShapeDimensions_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btCapsuleShapeZ_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2); +extern void _wrap_btCapsuleShapeZ_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btCapsuleShapeZ_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, float arg2); +extern void _wrap_btCapsuleShapeZ_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btCapsuleShapeZ_getAabbSlow_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btCapsuleShapeZ_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btCapsuleShapeZ_getLocalScalingNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShapeZ_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShapeZ_getMarginNV_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btCapsuleShapeZ_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeZ_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCapsuleShapeZ_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShapeZ_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern float _wrap_btCapsuleShapeZ_getMarginNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeZ_getAabbNonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btCapsuleShapeZ_project_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_voidp arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btCapsuleShapeZ_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btCapsuleShapeZ_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btCapsuleShapeZ_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btCapsuleShapeZ_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btCapsuleShapeZ_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeZ_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeZ_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeZ_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeZ_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeZ_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeZ_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btCapsuleShapeZ_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btCapsuleShapeZ_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeZ_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btCapsuleShapeZ_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeZ_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btCapsuleShapeZ_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeZ_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btCapsuleShapeZ_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btCapsuleShapeZ_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btCapsuleShapeData_m_convexInternalShapeData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCapsuleShapeData_m_convexInternalShapeData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCapsuleShapeData_m_upAxis_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCapsuleShapeData_m_upAxis_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCapsuleShapeData_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_52 arg2); +extern swig_type_53 _wrap_btCapsuleShapeData_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btCapsuleShapeData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btCapsuleShapeData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_CF_DYNAMIC_OBJECT_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_STATIC_OBJECT_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_KINEMATIC_OBJECT_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_NO_CONTACT_RESPONSE_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_CUSTOM_MATERIAL_CALLBACK_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_CHARACTER_OBJECT_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_DISABLE_VISUALIZE_OBJECT_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_DISABLE_SPU_COLLISION_PROCESSING_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_HAS_CONTACT_STIFFNESS_DAMPING_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_HAS_FRICTION_ANCHOR_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_HAS_COLLISION_SOUND_TRIGGER_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CO_COLLISION_OBJECT_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CO_RIGID_BODY_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CO_GHOST_OBJECT_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CO_SOFT_BODY_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CO_HF_FLUID_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CO_USER_TYPE_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CO_FEATHERSTONE_LINK_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_ANISOTROPIC_FRICTION_DISABLED_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_ANISOTROPIC_FRICTION_btCollisionObject_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CF_ANISOTROPIC_ROLLING_FRICTION_btCollisionObject_mbt_e879218550ba2e2b(void); +extern _Bool _wrap_btCollisionObject_mergesSimulationIslands_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionObject_getAnisotropicFriction_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btCollisionObject_setAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btCollisionObject_hasAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern _Bool _wrap_btCollisionObject_hasAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setContactProcessingThreshold_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObject_getContactProcessingThreshold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionObject_isStaticObject_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionObject_isKinematicObject_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionObject_isStaticOrKinematicObject_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionObject_hasContactResponse_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btCollisionObject_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btCollisionObject_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setCollisionShape_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObject_getCollisionShape__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionObject_getCollisionShape__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setIgnoreCollisionCheck_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, _Bool arg3); +extern swig_intgo _wrap_btCollisionObject_getNumObjectsWithoutCollision_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionObject_getObjectWithoutCollision_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern _Bool _wrap_btCollisionObject_checkCollideWithOverride_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObject_internalGetExtensionPointer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_internalSetExtensionPointer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btCollisionObject_getActivationState_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setActivationState_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btCollisionObject_setDeactivationTime_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObject_getDeactivationTime_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_forceActivationState_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btCollisionObject_activate__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern void _wrap_btCollisionObject_activate__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionObject_isActive_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setRestitution_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObject_getRestitution_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setFriction_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObject_getFriction_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setRollingFriction_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObject_getRollingFriction_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setSpinningFriction_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObject_getSpinningFriction_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setContactStiffnessAndDamping_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3); +extern float _wrap_btCollisionObject_getContactStiffness_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btCollisionObject_getContactDamping_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btCollisionObject_getInternalType_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionObject_getWorldTransform__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionObject_getWorldTransform__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setWorldTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObject_getBroadphaseHandle__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionObject_getBroadphaseHandle__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setBroadphaseHandle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObject_getInterpolationWorldTransform__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionObject_getInterpolationWorldTransform__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setInterpolationWorldTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionObject_setInterpolationLinearVelocity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionObject_setInterpolationAngularVelocity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObject_getInterpolationLinearVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionObject_getInterpolationAngularVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btCollisionObject_getIslandTag_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setIslandTag_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObject_getCompanionId_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setCompanionId_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObject_getWorldArrayIndex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setWorldArrayIndex_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern float _wrap_btCollisionObject_getHitFraction_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setHitFraction_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern swig_intgo _wrap_btCollisionObject_getCollisionFlags_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setCollisionFlags_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern float _wrap_btCollisionObject_getCcdSweptSphereRadius_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setCcdSweptSphereRadius_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObject_getCcdMotionThreshold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btCollisionObject_getCcdSquareMotionThreshold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setCcdMotionThreshold_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern uintptr_t _wrap_btCollisionObject_getUserPointer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btCollisionObject_getUserIndex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btCollisionObject_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btCollisionObject_getUserIndex3_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setUserPointer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionObject_setUserIndex_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btCollisionObject_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btCollisionObject_setUserIndex3_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObject_getUpdateRevisionInternal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObject_setCustomDebugColor_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionObject_removeCustomDebugColor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionObject_getCustomDebugColor_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btCollisionObject_checkCollideWith_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btCollisionObject_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_54 _wrap_btCollisionObject_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btCollisionObject_serializeSingleObject_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionObjectDoubleData_m_broadphaseHandle_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectDoubleData_m_broadphaseHandle_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_collisionShape_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectDoubleData_m_collisionShape_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_rootCollisionShape_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectDoubleData_m_rootCollisionShape_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_name_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_55 arg2); +extern swig_type_56 _wrap_btCollisionObjectDoubleData_m_name_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_worldTransform_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectDoubleData_m_worldTransform_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_interpolationWorldTransform_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectDoubleData_m_interpolationWorldTransform_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_interpolationLinearVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectDoubleData_m_interpolationLinearVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_interpolationAngularVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectDoubleData_m_interpolationAngularVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_anisotropicFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectDoubleData_m_anisotropicFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btCollisionObjectDoubleData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_deactivationTime_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btCollisionObjectDoubleData_m_deactivationTime_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_friction_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btCollisionObjectDoubleData_m_friction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_rollingFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btCollisionObjectDoubleData_m_rollingFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_contactDamping_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btCollisionObjectDoubleData_m_contactDamping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_contactStiffness_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btCollisionObjectDoubleData_m_contactStiffness_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_restitution_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btCollisionObjectDoubleData_m_restitution_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_hitFraction_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btCollisionObjectDoubleData_m_hitFraction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_ccdSweptSphereRadius_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btCollisionObjectDoubleData_m_ccdSweptSphereRadius_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_ccdMotionThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btCollisionObjectDoubleData_m_ccdMotionThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_hasAnisotropicFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectDoubleData_m_hasAnisotropicFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_collisionFlags_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectDoubleData_m_collisionFlags_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_islandTag1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectDoubleData_m_islandTag1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_companionId_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectDoubleData_m_companionId_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_activationState1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectDoubleData_m_activationState1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_internalType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectDoubleData_m_internalType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_checkCollideWith_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectDoubleData_m_checkCollideWith_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_collisionFilterGroup_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectDoubleData_m_collisionFilterGroup_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_collisionFilterMask_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectDoubleData_m_collisionFilterMask_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectDoubleData_m_uniqueId_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectDoubleData_m_uniqueId_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btCollisionObjectDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btCollisionObjectDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_broadphaseHandle_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectFloatData_m_broadphaseHandle_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_collisionShape_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectFloatData_m_collisionShape_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_rootCollisionShape_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectFloatData_m_rootCollisionShape_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_name_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_57 arg2); +extern swig_type_58 _wrap_btCollisionObjectFloatData_m_name_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_worldTransform_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectFloatData_m_worldTransform_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_interpolationWorldTransform_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectFloatData_m_interpolationWorldTransform_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_interpolationLinearVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectFloatData_m_interpolationLinearVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_interpolationAngularVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectFloatData_m_interpolationAngularVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_anisotropicFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionObjectFloatData_m_anisotropicFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObjectFloatData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_deactivationTime_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObjectFloatData_m_deactivationTime_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_friction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObjectFloatData_m_friction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_rollingFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObjectFloatData_m_rollingFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_contactDamping_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObjectFloatData_m_contactDamping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_contactStiffness_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObjectFloatData_m_contactStiffness_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_restitution_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObjectFloatData_m_restitution_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_hitFraction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObjectFloatData_m_hitFraction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_ccdSweptSphereRadius_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObjectFloatData_m_ccdSweptSphereRadius_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_ccdMotionThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btCollisionObjectFloatData_m_ccdMotionThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_hasAnisotropicFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectFloatData_m_hasAnisotropicFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_collisionFlags_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectFloatData_m_collisionFlags_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_islandTag1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectFloatData_m_islandTag1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_companionId_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectFloatData_m_companionId_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_activationState1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectFloatData_m_activationState1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_internalType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectFloatData_m_internalType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_checkCollideWith_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectFloatData_m_checkCollideWith_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_collisionFilterGroup_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectFloatData_m_collisionFilterGroup_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_collisionFilterMask_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectFloatData_m_collisionFilterMask_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionObjectFloatData_m_uniqueId_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btCollisionObjectFloatData_m_uniqueId_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btCollisionObjectFloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btCollisionObjectFloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_gDeactivationTime_set_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_gDeactivationTime_get_mbt_e879218550ba2e2b(void); +extern void _wrap_gDisableDeactivation_set_mbt_e879218550ba2e2b(_Bool arg1); +extern _Bool _wrap_gDisableDeactivation_get_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_DISABLE_WORLD_GRAVITY_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_ENABLE_GYROPSCOPIC_FORCE_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btRigidBody__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btRigidBody__SWIG_1_mbt_e879218550ba2e2b(float arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_new_btRigidBody__SWIG_2_mbt_e879218550ba2e2b(float arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_delete_btRigidBody_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_proceedToTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBody_upcast__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_upcast__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_predictIntegratedTransform_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern void _wrap_btRigidBody_saveKinematicState_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btRigidBody_applyGravity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_clearGravity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setGravity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBody_getGravity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setDamping_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3); +extern float _wrap_btRigidBody_getLinearDamping_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btRigidBody_getAngularDamping_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btRigidBody_getLinearSleepingThreshold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btRigidBody_getAngularSleepingThreshold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_applyDamping_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern uintptr_t _wrap_btRigidBody_getCollisionShape__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getCollisionShape__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setMassProps_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern uintptr_t _wrap_btRigidBody_getLinearFactor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setLinearFactor_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btRigidBody_getInvMass_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btRigidBody_getMass_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getInvInertiaTensorWorld_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_integrateVelocities_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btRigidBody_setCenterOfMassTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_applyCentralForce_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBody_getTotalForce_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getTotalTorque_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getInvInertiaDiagLocal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setInvInertiaDiagLocal_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_setSleepingThresholds_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3); +extern void _wrap_btRigidBody_applyTorque_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_applyForce_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btRigidBody_applyCentralImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_applyTorqueImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_applyImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btRigidBody_applyPushImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btRigidBody_getPushVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getTurnVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setPushVelocity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_setTurnVelocity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_applyCentralPushImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_applyTorqueTurnImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_clearForces_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_updateInertiaTensor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getCenterOfMassPosition_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getOrientation_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getCenterOfMassTransform_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getLinearVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getAngularVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setLinearVelocity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_setAngularVelocity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBody_getVelocityInLocalPoint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBody_getPushVelocityInLocalPoint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_translate_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern float _wrap_btRigidBody_computeImpulseDenominator_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern float _wrap_btRigidBody_computeAngularImpulseDenominator_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_updateDeactivation_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern _Bool _wrap_btRigidBody_wantsSleeping_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getConstBroadphaseProxy_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getBroadphaseProxy_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setNewBroadphaseProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBody_getMotionState__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getMotionState__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setMotionState_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_m_contactSolverType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btRigidBody_m_contactSolverType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_m_frictionSolverType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btRigidBody_m_frictionSolverType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setAngularFactor__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_setAngularFactor__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern uintptr_t _wrap_btRigidBody_getAngularFactor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btRigidBody_isInWorld_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_addConstraintRef_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btRigidBody_removeConstraintRef_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBody_getConstraintRef_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btRigidBody_getNumConstraintRefs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBody_setFlags_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btRigidBody_getFlags_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_computeGyroscopicImpulseImplicit_World_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern uintptr_t _wrap_btRigidBody_computeGyroscopicImpulseImplicit_Body_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern uintptr_t _wrap_btRigidBody_computeGyroscopicForceExplicit_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern uintptr_t _wrap_btRigidBody_getLocalInertia_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btRigidBody_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_59 _wrap_btRigidBody_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btRigidBody_serializeSingleObject_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btRigidBody_mergesSimulationIslands_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btRigidBody_getAnisotropicFriction_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btRigidBody_setAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern _Bool _wrap_btRigidBody_hasAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern _Bool _wrap_btRigidBody_hasAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setContactProcessingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btRigidBody_getContactProcessingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btRigidBody_isStaticObject_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btRigidBody_isKinematicObject_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btRigidBody_isStaticOrKinematicObject_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btRigidBody_hasContactResponse_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setCollisionShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btRigidBody_setIgnoreCollisionCheck_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, _Bool arg2); +extern swig_intgo _wrap_btRigidBody_getNumObjectsWithoutCollision_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btRigidBody_getObjectWithoutCollision_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern _Bool _wrap_btRigidBody_checkCollideWithOverride_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_internalGetExtensionPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_internalSetExtensionPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern swig_intgo _wrap_btRigidBody_getActivationState_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setActivationState_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btRigidBody_setDeactivationTime_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btRigidBody_getDeactivationTime_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_forceActivationState_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btRigidBody_activate__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern void _wrap_btRigidBody_activate__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btRigidBody_isActive_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setRestitution_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btRigidBody_getRestitution_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setFriction_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btRigidBody_getFriction_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setRollingFriction_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btRigidBody_getRollingFriction_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setSpinningFriction_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btRigidBody_getSpinningFriction_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setContactStiffnessAndDamping_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, float arg2); +extern float _wrap_btRigidBody_getContactStiffness_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btRigidBody_getContactDamping_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btRigidBody_getInternalType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btRigidBody_getWorldTransform__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btRigidBody_getWorldTransform__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setWorldTransform_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getBroadphaseHandle__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btRigidBody_getBroadphaseHandle__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setBroadphaseHandle_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getInterpolationWorldTransform__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btRigidBody_getInterpolationWorldTransform__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setInterpolationWorldTransform_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btRigidBody_setInterpolationLinearVelocity_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btRigidBody_setInterpolationAngularVelocity_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btRigidBody_getInterpolationLinearVelocity_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btRigidBody_getInterpolationAngularVelocity_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btRigidBody_getIslandTag_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setIslandTag_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btRigidBody_getCompanionId_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setCompanionId_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btRigidBody_getWorldArrayIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setWorldArrayIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern float _wrap_btRigidBody_getHitFraction_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setHitFraction_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern swig_intgo _wrap_btRigidBody_getCollisionFlags_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setCollisionFlags_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern float _wrap_btRigidBody_getCcdSweptSphereRadius_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setCcdSweptSphereRadius_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btRigidBody_getCcdMotionThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btRigidBody_getCcdSquareMotionThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setCcdMotionThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern uintptr_t _wrap_btRigidBody_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btRigidBody_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btRigidBody_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btRigidBody_getUserIndex3_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btRigidBody_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btRigidBody_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btRigidBody_setUserIndex3_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btRigidBody_getUpdateRevisionInternal_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btRigidBody_setCustomDebugColor_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btRigidBody_removeCustomDebugColor_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btRigidBody_getCustomDebugColor_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern _Bool _wrap_btRigidBody_checkCollideWith_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_collisionObjectData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_collisionObjectData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_invInertiaTensorWorld_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_invInertiaTensorWorld_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_linearVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_linearVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_angularVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_angularVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_angularFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_angularFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_linearFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_linearFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_gravity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_gravity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_gravity_acceleration_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_gravity_acceleration_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_invInertiaLocal_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_invInertiaLocal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_totalForce_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_totalForce_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_totalTorque_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyFloatData_m_totalTorque_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_inverseMass_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRigidBodyFloatData_m_inverseMass_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_linearDamping_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRigidBodyFloatData_m_linearDamping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_angularDamping_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRigidBodyFloatData_m_angularDamping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_additionalDampingFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRigidBodyFloatData_m_additionalDampingFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_additionalAngularDampingFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRigidBodyFloatData_m_additionalAngularDampingFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_linearSleepingThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRigidBodyFloatData_m_linearSleepingThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_angularSleepingThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRigidBodyFloatData_m_angularSleepingThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyFloatData_m_additionalDamping_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btRigidBodyFloatData_m_additionalDamping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btRigidBodyFloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btRigidBodyFloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_collisionObjectData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_collisionObjectData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_invInertiaTensorWorld_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_invInertiaTensorWorld_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_linearVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_linearVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_angularVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_angularVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_angularFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_angularFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_linearFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_linearFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_gravity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_gravity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_gravity_acceleration_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_gravity_acceleration_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_invInertiaLocal_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_invInertiaLocal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_totalForce_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_totalForce_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_totalTorque_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btRigidBodyDoubleData_m_totalTorque_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_inverseMass_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btRigidBodyDoubleData_m_inverseMass_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_linearDamping_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btRigidBodyDoubleData_m_linearDamping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_angularDamping_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btRigidBodyDoubleData_m_angularDamping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_additionalDampingFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btRigidBodyDoubleData_m_additionalDampingFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_additionalAngularDampingFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btRigidBodyDoubleData_m_additionalAngularDampingFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_linearSleepingThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btRigidBodyDoubleData_m_linearSleepingThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_angularSleepingThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btRigidBodyDoubleData_m_angularSleepingThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_additionalDamping_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btRigidBodyDoubleData_m_additionalDamping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRigidBodyDoubleData_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_60 arg2); +extern swig_type_61 _wrap_btRigidBodyDoubleData_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btRigidBodyDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btRigidBodyDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btAabbSupport_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTransformUtil_integrateTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5); +extern void _wrap_btTransformUtil_calculateVelocityQuaternion_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, uintptr_t arg6, uintptr_t arg7); +extern void _wrap_btTransformUtil_calculateDiffAxisAngleQuaternion_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_voidp arg4); +extern void _wrap_btTransformUtil_calculateVelocity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btTransformUtil_calculateDiffAxisAngle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_voidp arg4); +extern uintptr_t _wrap_new_btTransformUtil_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btTransformUtil_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btConvexSeparatingDistanceUtil_mbt_e879218550ba2e2b(float arg1, float arg2); +extern float _wrap_btConvexSeparatingDistanceUtil_getConservativeSeparatingDistance_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexSeparatingDistanceUtil_updateSeparatingDistance_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btConvexSeparatingDistanceUtil_initSeparatingDistance_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_delete_btConvexSeparatingDistanceUtil_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btJacobianEntry__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btJacobianEntry__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, float arg7, uintptr_t arg8, float arg9); +extern uintptr_t _wrap_new_btJacobianEntry__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern uintptr_t _wrap_new_btJacobianEntry__SWIG_3_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_new_btJacobianEntry__SWIG_4_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, float arg6); +extern float _wrap_btJacobianEntry_getDiagonal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btJacobianEntry_getNonDiagonal__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern float _wrap_btJacobianEntry_getNonDiagonal__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, float arg4); +extern float _wrap_btJacobianEntry_getRelativeVelocity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btJacobianEntry_m_linearJointAxis_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btJacobianEntry_m_linearJointAxis_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btJacobianEntry_m_aJ_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btJacobianEntry_m_aJ_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btJacobianEntry_m_bJ_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btJacobianEntry_m_bJ_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btJacobianEntry_m_0MinvJt_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btJacobianEntry_m_0MinvJt_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btJacobianEntry_m_1MinvJt_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btJacobianEntry_m_1MinvJt_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btJacobianEntry_m_Adiag_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btJacobianEntry_m_Adiag_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btJacobianEntry_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_worldTransform_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_worldTransform_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_deltaLinearVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_deltaLinearVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_deltaAngularVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_deltaAngularVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_angularFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_angularFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_linearFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_linearFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_invMass_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_invMass_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_pushVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_pushVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_turnVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_turnVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_linearVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_linearVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_angularVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_angularVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_externalForceImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_externalForceImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_externalTorqueImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_externalTorqueImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_m_originalBody_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_m_originalBody_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_setWorldTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_getWorldTransform_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_getVelocityInLocalPointNoDelta_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSolverBody_getVelocityInLocalPointObsolete_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSolverBody_getAngularVelocity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btSolverBody_applyImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern void _wrap_btSolverBody_internalApplyPushImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern uintptr_t _wrap_btSolverBody_getDeltaLinearVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSolverBody_getDeltaAngularVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSolverBody_getPushVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSolverBody_getTurnVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSolverBody_internalGetDeltaLinearVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSolverBody_internalGetDeltaAngularVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSolverBody_internalGetAngularFactor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSolverBody_internalGetInvMass_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_internalSetInvMass_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverBody_internalGetPushVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSolverBody_internalGetTurnVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_internalGetVelocityInLocalPointObsolete_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSolverBody_internalGetAngularVelocity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btSolverBody_internalApplyImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern void _wrap_btSolverBody_writebackVelocity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverBody_writebackVelocityAndTransform_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3); +extern uintptr_t _wrap_new_btSolverBody_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btSolverBody_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_relpos1CrossNormal_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverConstraint_m_relpos1CrossNormal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_contactNormal1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverConstraint_m_contactNormal1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_relpos2CrossNormal_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverConstraint_m_relpos2CrossNormal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_contactNormal2_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverConstraint_m_contactNormal2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_angularComponentA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverConstraint_m_angularComponentA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_angularComponentB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSolverConstraint_m_angularComponentB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_appliedPushImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSolverConstraint_m_appliedPushImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_appliedImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSolverConstraint_m_appliedImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_friction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSolverConstraint_m_friction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_jacDiagABInv_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSolverConstraint_m_jacDiagABInv_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_rhs_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSolverConstraint_m_rhs_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_cfm_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSolverConstraint_m_cfm_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_lowerLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSolverConstraint_m_lowerLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_upperLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSolverConstraint_m_upperLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_rhsPenetration_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSolverConstraint_m_rhsPenetration_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSolverConstraint_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_frictionIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSolverConstraint_m_frictionIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_solverBodyIdA_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSolverConstraint_m_solverBodyIdA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverConstraint_m_solverBodyIdB_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSolverConstraint_m_solverBodyIdB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_BT_SOLVER_CONTACT_1D_btSolverConstraint_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_SOLVER_FRICTION_1D_btSolverConstraint_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btSolverConstraint_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btSolverConstraint_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_POINT2POINT_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_HINGE_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CONETWIST_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_D6_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SLIDER_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CONTACT_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_D6_SPRING_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_GEAR_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_FIXED_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_D6_SPRING_2_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_MAX_CONSTRAINT_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONSTRAINT_ERP_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONSTRAINT_STOP_ERP_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONSTRAINT_CFM_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONSTRAINT_STOP_CFM_mbt_e879218550ba2e2b(void); +extern void _wrap_btJointFeedback_m_appliedForceBodyA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btJointFeedback_m_appliedForceBodyA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btJointFeedback_m_appliedTorqueBodyA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btJointFeedback_m_appliedTorqueBodyA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btJointFeedback_m_appliedForceBodyB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btJointFeedback_m_appliedForceBodyB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btJointFeedback_m_appliedTorqueBodyB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btJointFeedback_m_appliedTorqueBodyB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btJointFeedback_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btJointFeedback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btTypedConstraint_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTypedConstraint_getFixedBody_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btTypedConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btTypedConstraint_buildJacobian_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4, float arg5); +extern void _wrap_btTypedConstraint_getInfo1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTypedConstraint_getInfo2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTypedConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTypedConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btTypedConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern _Bool _wrap_btTypedConstraint_isEnabled_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraint_setEnabled_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern void _wrap_btTypedConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern uintptr_t _wrap_btTypedConstraint_getRigidBodyA__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTypedConstraint_getRigidBodyB__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTypedConstraint_getRigidBodyA__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTypedConstraint_getRigidBodyB__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btTypedConstraint_getUserConstraintType_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraint_setUserConstraintType_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btTypedConstraint_setUserConstraintId_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraint_getUserConstraintId_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTypedConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraint_setJointFeedback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTypedConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTypedConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btTypedConstraint_getUid_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btTypedConstraint_needsFeedback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraint_enableFeedback_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern float _wrap_btTypedConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btTypedConstraint_getConstraintType_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTypedConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3, swig_intgo arg4); +extern void _wrap_btTypedConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3); +extern float _wrap_btTypedConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern float _wrap_btTypedConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_62 _wrap_btTypedConstraint_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_SetbtTypedConstraint_M_objectType_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtTypedConstraint_M_objectType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btTypedConstraint_getObjectType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btAdjustAngleToLimits_mbt_e879218550ba2e2b(float arg1, float arg2, float arg3); +extern void _wrap_btTypedConstraintFloatData_m_rbA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTypedConstraintFloatData_m_rbA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_rbB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTypedConstraintFloatData_m_rbB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_name_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_63 arg2); +extern swig_type_64 _wrap_btTypedConstraintFloatData_m_name_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_objectType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintFloatData_m_objectType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_userConstraintType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintFloatData_m_userConstraintType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_userConstraintId_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintFloatData_m_userConstraintId_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_needsFeedback_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintFloatData_m_needsFeedback_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_appliedImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTypedConstraintFloatData_m_appliedImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_dbgDrawSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTypedConstraintFloatData_m_dbgDrawSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_disableCollisionsBetweenLinkedBodies_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintFloatData_m_disableCollisionsBetweenLinkedBodies_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintFloatData_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_breakingImpulseThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTypedConstraintFloatData_m_breakingImpulseThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintFloatData_m_isEnabled_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintFloatData_m_isEnabled_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTypedConstraintFloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btTypedConstraintFloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_rbA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTypedConstraintData_m_rbA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_rbB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTypedConstraintData_m_rbB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_name_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_65 arg2); +extern swig_type_66 _wrap_btTypedConstraintData_m_name_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_objectType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintData_m_objectType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_userConstraintType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintData_m_userConstraintType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_userConstraintId_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintData_m_userConstraintId_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_needsFeedback_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintData_m_needsFeedback_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_appliedImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTypedConstraintData_m_appliedImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_dbgDrawSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTypedConstraintData_m_dbgDrawSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_disableCollisionsBetweenLinkedBodies_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintData_m_disableCollisionsBetweenLinkedBodies_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintData_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_breakingImpulseThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTypedConstraintData_m_breakingImpulseThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintData_m_isEnabled_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintData_m_isEnabled_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTypedConstraintData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btTypedConstraintData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_rbA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTypedConstraintDoubleData_m_rbA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_rbB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTypedConstraintDoubleData_m_rbB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_name_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_67 arg2); +extern swig_type_68 _wrap_btTypedConstraintDoubleData_m_name_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_objectType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintDoubleData_m_objectType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_userConstraintType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintDoubleData_m_userConstraintType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_userConstraintId_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintDoubleData_m_userConstraintId_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_needsFeedback_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintDoubleData_m_needsFeedback_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_appliedImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btTypedConstraintDoubleData_m_appliedImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_dbgDrawSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btTypedConstraintDoubleData_m_dbgDrawSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_disableCollisionsBetweenLinkedBodies_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintDoubleData_m_disableCollisionsBetweenLinkedBodies_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintDoubleData_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_breakingImpulseThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btTypedConstraintDoubleData_m_breakingImpulseThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_m_isEnabled_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTypedConstraintDoubleData_m_isEnabled_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTypedConstraintDoubleData_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_69 arg2); +extern swig_type_70 _wrap_btTypedConstraintDoubleData_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTypedConstraintDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btTypedConstraintDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btAngularLimit_mbt_e879218550ba2e2b(void); +extern void _wrap_btAngularLimit_set__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4, float arg5, float arg6); +extern void _wrap_btAngularLimit_set__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4, float arg5); +extern void _wrap_btAngularLimit_set__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4); +extern void _wrap_btAngularLimit_set__SWIG_3_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3); +extern void _wrap_btAngularLimit_test_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btAngularLimit_getSoftness_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btAngularLimit_getBiasFactor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btAngularLimit_getRelaxationFactor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btAngularLimit_getCorrection_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btAngularLimit_getSign_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btAngularLimit_getHalfRange_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btAngularLimit_isLimit_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btAngularLimit_fit_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btAngularLimit_getError_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btAngularLimit_getLow_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btAngularLimit_getHigh_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btAngularLimit_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHashString_m_string1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btHashString_m_string1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHashString_m_hash_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btHashString_m_hash_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btHashString_getHash_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btHashString__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btHashString__SWIG_1_mbt_e879218550ba2e2b(swig_type_71 arg1); +extern _Bool _wrap_btHashString_equals_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btHashString_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_BT_HASH_NULL_get_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btHashInt__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btHashInt__SWIG_1_mbt_e879218550ba2e2b(swig_intgo arg1); +extern swig_intgo _wrap_btHashInt_getUid1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHashInt_setUid1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern _Bool _wrap_btHashInt_equals_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btHashInt_getHash_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btHashInt_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btHashPtr__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btHashPtr__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHashPtr_getPointer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btHashPtr_equals_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btHashPtr_getHash_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btHashPtr_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_sBulletDNAstr_set_mbt_e879218550ba2e2b(swig_type_72 arg1); +extern swig_type_73 _wrap_sBulletDNAstr_get_mbt_e879218550ba2e2b(void); +extern void _wrap_sBulletDNAlen_set_mbt_e879218550ba2e2b(swig_intgo arg1); +extern swig_intgo _wrap_sBulletDNAlen_get_mbt_e879218550ba2e2b(void); +extern void _wrap_sBulletDNAstr64_set_mbt_e879218550ba2e2b(swig_type_74 arg1); +extern swig_type_75 _wrap_sBulletDNAstr64_get_mbt_e879218550ba2e2b(void); +extern void _wrap_sBulletDNAlen64_set_mbt_e879218550ba2e2b(swig_intgo arg1); +extern swig_intgo _wrap_sBulletDNAlen64_get_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btStrLen_mbt_e879218550ba2e2b(swig_type_76 arg1); +extern void _wrap_btChunk_m_chunkCode_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btChunk_m_chunkCode_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btChunk_m_length_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btChunk_m_length_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btChunk_m_oldPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btChunk_m_oldPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btChunk_m_dna_nr_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btChunk_m_dna_nr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btChunk_m_number_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btChunk_m_number_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btChunk_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btChunk_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_BT_SERIALIZE_NO_BVH_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_SERIALIZE_NO_TRIANGLEINFOMAP_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_SERIALIZE_NO_DUPLICATE_ASSERT_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_SERIALIZE_CONTACT_MANIFOLDS_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btSerializer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_voidp _wrap_btSerializer_getBufferPointer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btSerializer_getCurrentBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSerializer_allocate_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_77 arg2, swig_intgo arg3); +extern void _wrap_btSerializer_finalizeChunk_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_type_78 arg3, swig_intgo arg4, uintptr_t arg5); +extern uintptr_t _wrap_btSerializer_findPointer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSerializer_getUniquePointer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btSerializer_startSerialization_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSerializer_finishSerialization_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_79 _wrap_btSerializer_findNameForPointer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btSerializer_registerNameForPointer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_type_80 arg3); +extern void _wrap_btSerializer_serializeName_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_81 arg2); +extern swig_intgo _wrap_btSerializer_getSerializationFlags_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSerializer_setSerializationFlags_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSerializer_getNumChunks_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSerializer_getChunk_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_new_btPointerUid_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btPointerUid_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btBulletSerializedArrays_mbt_e879218550ba2e2b(void); +extern void _wrap_btBulletSerializedArrays_m_bvhsDouble_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_bvhsDouble_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_bvhsFloat_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_bvhsFloat_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_colShapeData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_colShapeData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataDouble_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataDouble_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataFloat_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataFloat_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_rigidBodyDataDouble_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_rigidBodyDataDouble_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_rigidBodyDataFloat_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_rigidBodyDataFloat_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_collisionObjectDataDouble_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_collisionObjectDataDouble_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_collisionObjectDataFloat_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_collisionObjectDataFloat_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_constraintDataFloat_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_constraintDataFloat_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_constraintDataDouble_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_constraintDataDouble_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_constraintData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_constraintData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_softBodyFloatData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_softBodyFloatData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBulletSerializedArrays_m_softBodyDoubleData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBulletSerializedArrays_m_softBodyDoubleData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btBulletSerializedArrays_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultSerializer_m_skipPointers_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDefaultSerializer_m_skipPointers_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDefaultSerializer__SWIG_0_mbt_e879218550ba2e2b(swig_intgo arg1, swig_voidp arg2); +extern uintptr_t _wrap_new_btDefaultSerializer__SWIG_1_mbt_e879218550ba2e2b(swig_intgo arg1); +extern uintptr_t _wrap_new_btDefaultSerializer__SWIG_2_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDefaultSerializer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btDefaultSerializer_getMemoryDnaSizeInBytes_mbt_e879218550ba2e2b(void); +extern swig_type_82 _wrap_btDefaultSerializer_getMemoryDna_mbt_e879218550ba2e2b(void); +extern void _wrap_btDefaultSerializer_insertHeader_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultSerializer_writeHeader_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern void _wrap_btDefaultSerializer_startSerialization_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultSerializer_finishSerialization_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDefaultSerializer_getUniquePointer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_voidp _wrap_btDefaultSerializer_getBufferPointer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btDefaultSerializer_getCurrentBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultSerializer_finalizeChunk_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_type_83 arg3, swig_intgo arg4, uintptr_t arg5); +extern swig_voidp _wrap_btDefaultSerializer_internalAlloc_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_84 arg2); +extern uintptr_t _wrap_btDefaultSerializer_allocate_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_85 arg2, swig_intgo arg3); +extern swig_type_86 _wrap_btDefaultSerializer_findNameForPointer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDefaultSerializer_registerNameForPointer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_type_87 arg3); +extern void _wrap_btDefaultSerializer_serializeName_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_88 arg2); +extern swig_intgo _wrap_btDefaultSerializer_getSerializationFlags_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultSerializer_setSerializationFlags_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDefaultSerializer_getNumChunks_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDefaultSerializer_getChunk_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btDefaultSerializer_findPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_uniqueId_set_mbt_e879218550ba2e2b(swig_intgo arg1); +extern swig_intgo _wrap_uniqueId_get_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_evalEulerEqn_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5); +extern uintptr_t _wrap_evalEulerEqnDeriv_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, uintptr_t arg4); +extern uintptr_t _wrap_new_btDbvtAabbMm_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_btDbvtAabbMm_Center_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDbvtAabbMm_Lengths_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDbvtAabbMm_Extents_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDbvtAabbMm_Mins_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDbvtAabbMm_Maxs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDbvtAabbMm_FromCE_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtAabbMm_FromCR_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern uintptr_t _wrap_btDbvtAabbMm_FromMM_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtAabbMm_FromPoints__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btDbvtAabbMm_FromPoints__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btDbvtAabbMm_Expand_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDbvtAabbMm_SignedExpand_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btDbvtAabbMm_Contain_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btDbvtAabbMm_Classify_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, swig_intgo arg4); +extern float _wrap_btDbvtAabbMm_ProjectMinimum_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern _Bool _wrap_Intersect__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_Intersect__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_Proximity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_Select_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_Merge_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_NotEqual_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtAabbMm_tMins_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDbvtAabbMm_tMaxs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btDbvtAabbMm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtNode_volume_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtNode_volume_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtNode_parent_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtNode_parent_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btDbvtNode_isleaf_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btDbvtNode_isinternal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDbvtNode_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDbvtNode_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvntNode_volume_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvntNode_volume_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvntNode_normal_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvntNode_normal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvntNode_angle_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btDbvntNode_angle_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btDbvntNode_isleaf_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btDbvntNode_isinternal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvntNode_childs_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvntNode_childs_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvntNode_data_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvntNode_data_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDbvntNode_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btDbvntNode_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_SIMPLE_STACKSIZE_btDbvt_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DOUBLE_STACKSIZE_btDbvt_mbt_e879218550ba2e2b(void); +extern void _wrap_btDbvt_m_root_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvt_m_root_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvt_m_free_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvt_m_free_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvt_m_lkhd_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvt_m_lkhd_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvt_m_leaves_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvt_m_leaves_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvt_m_opath_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvt_m_opath_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvt_m_stkStack_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvt_m_stkStack_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDbvt_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDbvt_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvt_clear_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btDbvt_empty_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvt_optimizeBottomUp_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvt_optimizeTopDown__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btDbvt_optimizeTopDown__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvt_optimizeIncremental_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btDbvt_insert_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDbvt_update__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btDbvt_update__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDbvt_update__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btDbvt_update__SWIG_3_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5); +extern _Bool _wrap_btDbvt_update__SWIG_4_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern _Bool _wrap_btDbvt_update__SWIG_5_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern void _wrap_btDbvt_remove_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDbvt_write_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDbvt_clone__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDbvt_clone__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btDbvt_maxdepth_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btDbvt_countLeaves_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvt_extractLeaves_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDbvt_benchmark_mbt_e879218550ba2e2b(void); +extern void _wrap_btDbvt_enumNodes_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDbvt_enumLeaves_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDbvt_collideTT_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDbvt_selfCollideT_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDbvt_selfCollideTT_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDbvt_collideTTpersistentStack_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDbvt_collideTV_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDbvt_collideTVNoStackAlloc_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btDbvt_rayTest_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDbvt_rayTestInternal_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, swig_voidp arg6, float arg7, uintptr_t arg8, uintptr_t arg9, uintptr_t arg10, uintptr_t arg11); +extern void _wrap_btDbvt_collideKDOP_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_intgo arg4, uintptr_t arg5); +extern void _wrap_btDbvt_collideOCL__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, uintptr_t arg4, swig_intgo arg5, uintptr_t arg6, _Bool arg7); +extern void _wrap_btDbvt_collideOCL__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, uintptr_t arg4, swig_intgo arg5, uintptr_t arg6); +extern void _wrap_btDbvt_collideTU_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btDbvt_nearest_mbt_e879218550ba2e2b(swig_voidp arg1, uintptr_t arg2, float arg3, swig_intgo arg4, swig_intgo arg5); +extern swig_intgo _wrap_btDbvt_allocate_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDbvtNodeEnumerator_nodes_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtNodeEnumerator_nodes_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtNodeEnumerator_Process_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btDbvtNodeEnumerator_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDbvtNodeEnumerator_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_indexof_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_size_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_getmaxdepth_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_voidp arg3); +extern void _wrap_deletenode_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_recursedeletenode_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_createnode__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_createnode__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_createnode__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_insertleaf_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_removeleaf_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_fetchleaves__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4); +extern void _wrap_fetchleaves__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_leftOfAxis_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_split_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_bounds_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_bottomup_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern uintptr_t _wrap_topdown_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern uintptr_t _wrap_sort_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btBroadphaseAabbCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btBroadphaseAabbCallback_process_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btBroadphaseRayCallback_m_rayDirectionInverse_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBroadphaseRayCallback_m_rayDirectionInverse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBroadphaseRayCallback_m_signs_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btBroadphaseRayCallback_m_signs_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBroadphaseRayCallback_m_lambda_max_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btBroadphaseRayCallback_m_lambda_max_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btBroadphaseRayCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btBroadphaseRayCallback_process_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_delete_btBroadphaseInterface_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btBroadphaseInterface_createProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4, uintptr_t arg5, swig_intgo arg6, swig_intgo arg7, uintptr_t arg8); +extern void _wrap_btBroadphaseInterface_destroyProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btBroadphaseInterface_setAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btBroadphaseInterface_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btBroadphaseInterface_rayTest__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btBroadphaseInterface_rayTest__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btBroadphaseInterface_rayTest__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btBroadphaseInterface_aabbTest_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btBroadphaseInterface_calculateOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBroadphaseInterface_getOverlappingPairCache__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btBroadphaseInterface_getOverlappingPairCache__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBroadphaseInterface_getBroadphaseAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btBroadphaseInterface_resetPool_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btBroadphaseInterface_printStats_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btOverlappingPairCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btOverlappingPairCallback_addOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btOverlappingPairCallback_removeOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btOverlappingPairCallback_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_delete_btOverlapCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btOverlapCallback_processOverlap_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btOverlapFilterCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btOverlapFilterCallback_needBroadphaseCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_BT_NULL_PAIR_get_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btOverlappingPairCache_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btOverlappingPairCache_getOverlappingPairArray_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOverlappingPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btOverlappingPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btOverlappingPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btOverlappingPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOverlappingPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btOverlappingPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btOverlappingPairCache_processAllOverlappingPairs__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btOverlappingPairCache_processAllOverlappingPairs__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_btOverlappingPairCache_findPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btOverlappingPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOverlappingPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btOverlappingPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btOverlappingPairCache_addOverlappingPair_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btOverlappingPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btOverlappingPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btHashedOverlappingPairCache_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btHashedOverlappingPairCache_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHashedOverlappingPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btHashedOverlappingPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern _Bool _wrap_btHashedOverlappingPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btHashedOverlappingPairCache_addOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btHashedOverlappingPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btHashedOverlappingPairCache_processAllOverlappingPairs__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btHashedOverlappingPairCache_processAllOverlappingPairs__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_btHashedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHashedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHashedOverlappingPairCache_getOverlappingPairArray__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHashedOverlappingPairCache_getOverlappingPairArray__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHashedOverlappingPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btHashedOverlappingPairCache_findPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btHashedOverlappingPairCache_GetCount_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHashedOverlappingPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHashedOverlappingPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btHashedOverlappingPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btHashedOverlappingPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btHashedOverlappingPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btHashedOverlappingPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_new_btSortedOverlappingPairCache_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btSortedOverlappingPairCache_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSortedOverlappingPairCache_processAllOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btSortedOverlappingPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btSortedOverlappingPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btSortedOverlappingPairCache_addOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btSortedOverlappingPairCache_findPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSortedOverlappingPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSortedOverlappingPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btSortedOverlappingPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btSortedOverlappingPairCache_getOverlappingPairArray__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSortedOverlappingPairCache_getOverlappingPairArray__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSortedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSortedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btSortedOverlappingPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btSortedOverlappingPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSortedOverlappingPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btSortedOverlappingPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSortedOverlappingPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btSortedOverlappingPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btNullPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btNullPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btNullPairCache_getOverlappingPairArray_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btNullPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btNullPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btNullPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btNullPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btNullPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btNullPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btNullPairCache_processAllOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btNullPairCache_findPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btNullPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btNullPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btNullPairCache_addOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btNullPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btNullPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btNullPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btNullPairCache_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btNullPairCache_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_MyPairIndex_m_orgIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_MyPairIndex_m_orgIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_MyPairIndex_m_uidA0_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_MyPairIndex_m_uidA0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_MyPairIndex_m_uidA1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_MyPairIndex_m_uidA1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_MyPairIndex_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_MyPairIndex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_MyPairIndeSortPredicate_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_MyPairIndeSortPredicate_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_gDbvtMargin_set_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_gDbvtMargin_get_mbt_e879218550ba2e2b(void); +extern void _wrap_btDbvtProxy_leaf_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtProxy_leaf_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtProxy_links_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtProxy_links_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtProxy_stage_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtProxy_stage_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDbvtProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4, swig_intgo arg5); +extern void _wrap_delete_btDbvtProxy_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SetbtDbvtProxy_M_clientObject_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_GetbtDbvtProxy_M_clientObject_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtDbvtProxy_M_collisionFilterGroup_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtDbvtProxy_M_collisionFilterGroup_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtDbvtProxy_M_collisionFilterMask_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtDbvtProxy_M_collisionFilterMask_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtDbvtProxy_M_uniqueId_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtDbvtProxy_M_uniqueId_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtDbvtProxy_M_aabbMin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_GetbtDbvtProxy_M_aabbMin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtDbvtProxy_M_aabbMax_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_GetbtDbvtProxy_M_aabbMax_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btDbvtProxy_getUid_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btDbvtProxy_isPolyhedral_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btDbvtProxy_isConvex_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btDbvtProxy_isNonMoving_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btDbvtProxy_isConcave_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btDbvtProxy_isCompound_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btDbvtProxy_isSoftBody_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btDbvtProxy_isInfinite_mbt_e879218550ba2e2b(swig_intgo arg1); +extern _Bool _wrap_btDbvtProxy_isConvex2d_mbt_e879218550ba2e2b(swig_intgo arg1); +extern swig_intgo _wrap_DYNAMIC_SET_btDbvtBroadphase_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_FIXED_SET_btDbvtBroadphase_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_STAGECOUNT_btDbvtBroadphase_mbt_e879218550ba2e2b(void); +extern void _wrap_btDbvtBroadphase_m_sets_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtBroadphase_m_sets_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_stageRoots_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtBroadphase_m_stageRoots_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_paircache_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtBroadphase_m_paircache_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_prediction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btDbvtBroadphase_m_prediction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_stageCurrent_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_stageCurrent_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_fupdates_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_fupdates_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_dupdates_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_dupdates_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_cupdates_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_cupdates_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_newpairs_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_newpairs_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_fixedleft_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_fixedleft_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_updates_call_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_updates_call_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_updates_done_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_updates_done_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_updates_ratio_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btDbvtBroadphase_m_updates_ratio_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_pid_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_pid_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_cid_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_cid_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_gid_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDbvtBroadphase_m_gid_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_releasepaircache_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDbvtBroadphase_m_releasepaircache_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_deferedcollide_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDbvtBroadphase_m_deferedcollide_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_needcleanup_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDbvtBroadphase_m_needcleanup_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_m_rayTestStacks_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtBroadphase_m_rayTestStacks_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDbvtBroadphase__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDbvtBroadphase__SWIG_1_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDbvtBroadphase_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_collide_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDbvtBroadphase_optimize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDbvtBroadphase_createProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4, uintptr_t arg5, swig_intgo arg6, swig_intgo arg7, uintptr_t arg8); +extern void _wrap_btDbvtBroadphase_destroyProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDbvtBroadphase_setAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btDbvtBroadphase_rayTest__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btDbvtBroadphase_rayTest__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btDbvtBroadphase_rayTest__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDbvtBroadphase_aabbTest_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDbvtBroadphase_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDbvtBroadphase_calculateOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtBroadphase_getOverlappingPairCache__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDbvtBroadphase_getOverlappingPairCache__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_getBroadphaseAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDbvtBroadphase_printStats_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_resetPool_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDbvtBroadphase_performDeferredRemoval_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDbvtBroadphase_setVelocityPrediction_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btDbvtBroadphase_getVelocityPrediction_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtBroadphase_setAabbForceUpdate_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btDbvtBroadphase_benchmark_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_BT_MAX_THREAD_COUNT_get_mbt_e879218550ba2e2b(void); +extern _Bool _wrap_btIsMainThread_mbt_e879218550ba2e2b(void); +extern _Bool _wrap_btThreadsAreRunning_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btGetCurrentThreadIndex_mbt_e879218550ba2e2b(void); +extern void _wrap_btResetThreadIndexCounter_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btSpinMutex_mbt_e879218550ba2e2b(void); +extern void _wrap_btSpinMutex_lock_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSpinMutex_unlock_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btSpinMutex_tryLock_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btSpinMutex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMutexLock_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMutexUnlock_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btMutexTryLock_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btIParallelForBody_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btIParallelForBody_forLoop_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern void _wrap_delete_btIParallelSumBody_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btIParallelSumBody_sumLoop_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern void _wrap_delete_btITaskScheduler_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_89 _wrap_btITaskScheduler_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btITaskScheduler_getMaxNumThreads_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btITaskScheduler_getNumThreads_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btITaskScheduler_setNumThreads_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btITaskScheduler_parallelFor_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, swig_intgo arg4, uintptr_t arg5); +extern float _wrap_btITaskScheduler_parallelSum_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, swig_intgo arg4, uintptr_t arg5); +extern void _wrap_btITaskScheduler_sleepWorkerThreadsHint_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btITaskScheduler_activate_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btITaskScheduler_deactivate_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSetTaskScheduler_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btGetTaskScheduler_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_btGetSequentialTaskScheduler_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_btGetOpenMPTaskScheduler_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_btGetTBBTaskScheduler_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_btGetPPLTaskScheduler_mbt_e879218550ba2e2b(void); +extern void _wrap_btParallelFor_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2, swig_intgo arg3, uintptr_t arg4); +extern float _wrap_btParallelSum_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2, swig_intgo arg3, uintptr_t arg4); +extern void _wrap_ThreadsafeCounter_mCounter_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_ThreadsafeCounter_mCounter_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ThreadsafeCounter_mMutex_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_ThreadsafeCounter_mMutex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_ThreadsafeCounter_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_ThreadsafeCounter_getNext_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_ThreadsafeCounter_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_gBtTaskScheduler_set_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_gBtTaskScheduler_get_mbt_e879218550ba2e2b(void); +extern void _wrap_gThreadsRunningCounter_set_mbt_e879218550ba2e2b(swig_intgo arg1); +extern swig_intgo _wrap_gThreadsRunningCounter_get_mbt_e879218550ba2e2b(void); +extern void _wrap_gThreadsRunningCounterMutex_set_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_gThreadsRunningCounterMutex_get_mbt_e879218550ba2e2b(void); +extern void _wrap_gThreadCounter_set_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_gThreadCounter_get_mbt_e879218550ba2e2b(void); +extern void _wrap_btPushThreadsAreRunning_mbt_e879218550ba2e2b(void); +extern void _wrap_btPopThreadsAreRunning_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btTaskSchedulerSequential_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btTaskSchedulerSequential_getMaxNumThreads_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btTaskSchedulerSequential_getNumThreads_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTaskSchedulerSequential_setNumThreads_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btTaskSchedulerSequential_parallelFor_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, swig_intgo arg4, uintptr_t arg5); +extern float _wrap_btTaskSchedulerSequential_parallelSum_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, swig_intgo arg4, uintptr_t arg5); +extern void _wrap_delete_btTaskSchedulerSequential_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_90 _wrap_btTaskSchedulerSequential_getName_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btTaskSchedulerSequential_sleepWorkerThreadsHint_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btTaskSchedulerSequential_activate_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btTaskSchedulerSequential_deactivate_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDbvtTreeCollider_pbp_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtTreeCollider_pbp_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtTreeCollider_proxy_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDbvtTreeCollider_proxy_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDbvtTreeCollider_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDbvtTreeCollider_Process__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDbvtTreeCollider_Process__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btDbvtTreeCollider_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_BroadphaseRayTester_m_rayCallback_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_BroadphaseRayTester_m_rayCallback_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_BroadphaseRayTester_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_BroadphaseRayTester_Process_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_BroadphaseRayTester_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_BroadphaseAabbTester_m_aabbCallback_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_BroadphaseAabbTester_m_aabbCallback_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_BroadphaseAabbTester_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_BroadphaseAabbTester_Process_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_BroadphaseAabbTester_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_DISPATCH_DISCRETE_btDispatcherInfo_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DISPATCH_CONTINUOUS_btDispatcherInfo_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btDispatcherInfo_mbt_e879218550ba2e2b(void); +extern void _wrap_btDispatcherInfo_m_timeStep_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btDispatcherInfo_m_timeStep_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_stepCount_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDispatcherInfo_m_stepCount_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_dispatchFunc_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDispatcherInfo_m_dispatchFunc_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_timeOfImpact_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btDispatcherInfo_m_timeOfImpact_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_useContinuous_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDispatcherInfo_m_useContinuous_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_debugDraw_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDispatcherInfo_m_debugDraw_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_enableSatConvex_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDispatcherInfo_m_enableSatConvex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_enableSPU_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDispatcherInfo_m_enableSPU_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_useEpa_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDispatcherInfo_m_useEpa_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_allowedCcdPenetration_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btDispatcherInfo_m_allowedCcdPenetration_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_useConvexConservativeDistanceUtil_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDispatcherInfo_m_useConvexConservativeDistanceUtil_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_convexConservativeDistanceThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btDispatcherInfo_m_convexConservativeDistanceThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDispatcherInfo_m_deterministicOverlappingPairs_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDispatcherInfo_m_deterministicOverlappingPairs_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btDispatcherInfo_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_BT_CONTACT_POINT_ALGORITHMS_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CLOSEST_POINT_ALGORITHMS_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDispatcher_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDispatcher_findAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, swig_intgo arg5); +extern uintptr_t _wrap_btDispatcher_getNewManifold_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDispatcher_releaseManifold_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDispatcher_clearManifold_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btDispatcher_needsCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btDispatcher_needsResponse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDispatcher_dispatchAllCollisionPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern swig_intgo _wrap_btDispatcher_getNumManifolds_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDispatcher_getManifoldByIndexInternal_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btDispatcher_getInternalManifoldPointer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDispatcher_getInternalManifoldPool__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDispatcher_getInternalManifoldPool__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDispatcher_allocateCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btDispatcher_freeCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConstraintRow_m_normal_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btConstraintRow_m_normal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConstraintRow_m_rhs_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConstraintRow_m_rhs_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConstraintRow_m_jacDiagInv_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConstraintRow_m_jacDiagInv_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConstraintRow_m_lowerLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConstraintRow_m_lowerLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConstraintRow_m_upperLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConstraintRow_m_upperLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConstraintRow_m_accumImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConstraintRow_m_accumImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btConstraintRow_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btConstraintRow_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONTACT_FLAG_HAS_CONTACT_CFM_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONTACT_FLAG_HAS_CONTACT_ERP_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONTACT_FLAG_FRICTION_ANCHOR_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btManifoldPoint__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btManifoldPoint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern void _wrap_btManifoldPoint_m_localPointA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btManifoldPoint_m_localPointA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_localPointB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btManifoldPoint_m_localPointB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_positionWorldOnB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btManifoldPoint_m_positionWorldOnB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_positionWorldOnA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btManifoldPoint_m_positionWorldOnA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_normalWorldOnB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btManifoldPoint_m_normalWorldOnB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_distance1_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_distance1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_combinedFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_combinedFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_combinedRollingFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_combinedRollingFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_combinedSpinningFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_combinedSpinningFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_combinedRestitution_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_combinedRestitution_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_partId0_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btManifoldPoint_m_partId0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_partId1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btManifoldPoint_m_partId1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_index0_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btManifoldPoint_m_index0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_index1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btManifoldPoint_m_index1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_userPersistentData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btManifoldPoint_m_userPersistentData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_contactPointFlags_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btManifoldPoint_m_contactPointFlags_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_appliedImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_appliedImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_prevRHS_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_prevRHS_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_appliedImpulseLateral1_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_appliedImpulseLateral1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_appliedImpulseLateral2_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_appliedImpulseLateral2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_contactMotion1_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_contactMotion1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_contactMotion2_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_contactMotion2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_frictionCFM_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_m_frictionCFM_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_lifeTime_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btManifoldPoint_m_lifeTime_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_lateralFrictionDir1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btManifoldPoint_m_lateralFrictionDir1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_m_lateralFrictionDir2_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btManifoldPoint_m_lateralFrictionDir2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btManifoldPoint_getDistance_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btManifoldPoint_getLifeTime_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btManifoldPoint_getPositionWorldOnA_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btManifoldPoint_getPositionWorldOnB_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldPoint_setDistance_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldPoint_getAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btManifoldPoint_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_gContactBreakingThreshold_set_mbt_e879218550ba2e2b(float arg1); +extern float _wrap_gContactBreakingThreshold_get_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_MIN_CONTACT_MANIFOLD_TYPE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_PERSISTENT_MANIFOLD_TYPE_mbt_e879218550ba2e2b(void); +extern void _wrap_btPersistentManifold_m_companionIdA_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifold_m_companionIdA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifold_m_companionIdB_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifold_m_companionIdB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifold_m_index1a_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifold_m_index1a_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btPersistentManifold__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btPersistentManifold__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, float arg4, float arg5); +extern uintptr_t _wrap_btPersistentManifold_getBody0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btPersistentManifold_getBody1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifold_setBodies_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btPersistentManifold_clearUserCache_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btPersistentManifold_getNumContacts_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifold_setNumContacts_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btPersistentManifold_getContactPoint__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btPersistentManifold_getContactPoint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern float _wrap_btPersistentManifold_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btPersistentManifold_getContactProcessingThreshold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifold_setContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btPersistentManifold_setContactProcessingThreshold_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern swig_intgo _wrap_btPersistentManifold_getCacheEntry_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btPersistentManifold_addManifoldPoint__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, _Bool arg3); +extern swig_intgo _wrap_btPersistentManifold_addManifoldPoint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btPersistentManifold_removeContactPoint_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btPersistentManifold_replaceContactPoint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern _Bool _wrap_btPersistentManifold_validContactDistance_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btPersistentManifold_refreshContactPoints_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btPersistentManifold_clearManifold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btPersistentManifold_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_91 _wrap_btPersistentManifold_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btPersistentManifold_deSerialize__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btPersistentManifold_deSerialize__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btPersistentManifold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SetbtPersistentManifold_M_objectType_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtPersistentManifold_M_objectType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btPersistentManifold_getObjectType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheNormalWorldOnB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldDoubleData_m_pointCacheNormalWorldOnB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir2_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheDistance_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheDistance_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCachePrevRHS_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCachePrevRHS_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRollingFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRollingFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedSpinningFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedSpinningFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRestitution_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRestitution_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCachePartId0_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCachePartId0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCachePartId1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCachePartId1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheIndex0_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheIndex0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheIndex1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheIndex1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheContactPointFlags_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheContactPointFlags_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral2_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion2_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheContactCFM_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheContactCFM_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactStiffness1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactStiffness1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheContactERP_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheContactERP_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactDamping1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactDamping1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheFrictionCFM_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheFrictionCFM_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_pointCacheLifeTime_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldDoubleData_m_pointCacheLifeTime_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_numCachedPoints_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldDoubleData_m_numCachedPoints_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_companionIdA_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldDoubleData_m_companionIdA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_companionIdB_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldDoubleData_m_companionIdB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_index1a_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldDoubleData_m_index1a_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_objectType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldDoubleData_m_objectType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_contactBreakingThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btPersistentManifoldDoubleData_m_contactBreakingThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btPersistentManifoldDoubleData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldDoubleData_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_body0_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldDoubleData_m_body0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldDoubleData_m_body1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldDoubleData_m_body1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btPersistentManifoldDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btPersistentManifoldDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnA_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheNormalWorldOnB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldFloatData_m_pointCacheNormalWorldOnB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir2_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheDistance_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheDistance_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCachePrevRHS_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCachePrevRHS_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRollingFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRollingFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedSpinningFriction_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedSpinningFriction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRestitution_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRestitution_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCachePartId0_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCachePartId0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCachePartId1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCachePartId1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheIndex0_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheIndex0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheIndex1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheIndex1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheContactPointFlags_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheContactPointFlags_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral2_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion2_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheContactCFM_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheContactCFM_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactStiffness1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactStiffness1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheContactERP_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheContactERP_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactDamping1_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactDamping1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheFrictionCFM_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheFrictionCFM_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_pointCacheLifeTime_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btPersistentManifoldFloatData_m_pointCacheLifeTime_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_numCachedPoints_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldFloatData_m_numCachedPoints_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_companionIdA_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldFloatData_m_companionIdA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_companionIdB_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldFloatData_m_companionIdB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_index1a_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldFloatData_m_index1a_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_objectType_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldFloatData_m_objectType_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_contactBreakingThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btPersistentManifoldFloatData_m_contactBreakingThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btPersistentManifoldFloatData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btPersistentManifoldFloatData_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_body0_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldFloatData_m_body0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btPersistentManifoldFloatData_m_body1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btPersistentManifoldFloatData_m_body1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btPersistentManifoldFloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btPersistentManifoldFloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btDiscreteCollisionDetectorInterface_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteCollisionDetectorInterface_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5); +extern void _wrap_btDiscreteCollisionDetectorInterface_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btStorageResult_m_normalOnSurfaceB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btStorageResult_m_normalOnSurfaceB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStorageResult_m_closestPointInB_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btStorageResult_m_closestPointInB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStorageResult_m_distance_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btStorageResult_m_distance_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btStorageResult_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStorageResult_addContactPoint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern void _wrap_gContactAddedCallback_set_mbt_e879218550ba2e2b(swig_type_92 arg1); +extern swig_type_93 _wrap_gContactAddedCallback_get_mbt_e879218550ba2e2b(void); +extern void _wrap_gCalculateCombinedRestitutionCallback_set_mbt_e879218550ba2e2b(swig_type_94 arg1); +extern swig_type_95 _wrap_gCalculateCombinedRestitutionCallback_get_mbt_e879218550ba2e2b(void); +extern void _wrap_gCalculateCombinedFrictionCallback_set_mbt_e879218550ba2e2b(swig_type_96 arg1); +extern swig_type_97 _wrap_gCalculateCombinedFrictionCallback_get_mbt_e879218550ba2e2b(void); +extern void _wrap_gCalculateCombinedRollingFrictionCallback_set_mbt_e879218550ba2e2b(swig_type_98 arg1); +extern swig_type_99 _wrap_gCalculateCombinedRollingFrictionCallback_get_mbt_e879218550ba2e2b(void); +extern void _wrap_gCalculateCombinedSpinningFrictionCallback_set_mbt_e879218550ba2e2b(swig_type_100 arg1); +extern swig_type_101 _wrap_gCalculateCombinedSpinningFrictionCallback_get_mbt_e879218550ba2e2b(void); +extern void _wrap_gCalculateCombinedContactDampingCallback_set_mbt_e879218550ba2e2b(swig_type_102 arg1); +extern swig_type_103 _wrap_gCalculateCombinedContactDampingCallback_get_mbt_e879218550ba2e2b(void); +extern void _wrap_gCalculateCombinedContactStiffnessCallback_set_mbt_e879218550ba2e2b(swig_type_104 arg1); +extern swig_type_105 _wrap_gCalculateCombinedContactStiffnessCallback_get_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btManifoldResult__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btManifoldResult__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btManifoldResult_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldResult_setPersistentManifold_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btManifoldResult_getPersistentManifold__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btManifoldResult_getPersistentManifold__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldResult_setShapeIdentifiersA_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern void _wrap_btManifoldResult_setShapeIdentifiersB_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern void _wrap_btManifoldResult_addContactPoint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern void _wrap_btManifoldResult_refreshContactPoints_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btManifoldResult_getBody0Wrap_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btManifoldResult_getBody1Wrap_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldResult_setBody0Wrap_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btManifoldResult_setBody1Wrap_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btManifoldResult_getBody0Internal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btManifoldResult_getBody1Internal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btManifoldResult_m_closestPointDistanceThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btManifoldResult_m_closestPointDistanceThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btManifoldResult_calculateCombinedRestitution_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btManifoldResult_calculateCombinedFriction_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btManifoldResult_calculateCombinedRollingFriction_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btManifoldResult_calculateCombinedSpinningFriction_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btManifoldResult_calculateCombinedContactDamping_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btManifoldResult_calculateCombinedContactStiffness_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionAlgorithmCreateFunc_m_swapped_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btCollisionAlgorithmCreateFunc_m_swapped_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern swig_intgo _wrap_CD_STATIC_STATIC_REPORTED_btCollisionDispatcher_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD_btCollisionDispatcher_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION_btCollisionDispatcher_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btCollisionDispatcher_getDispatcherFlags_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionDispatcher_setDispatcherFlags_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btCollisionDispatcher_registerCollisionCreateFunc_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, uintptr_t arg4); +extern void _wrap_btCollisionDispatcher_registerClosestPointsCreateFunc_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, uintptr_t arg4); +extern swig_intgo _wrap_btCollisionDispatcher_getNumManifolds_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionDispatcher_getInternalManifoldPointer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionDispatcher_getManifoldByIndexInternal_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_new_btCollisionDispatcher_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btCollisionDispatcher_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionDispatcher_getNewManifold_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btCollisionDispatcher_releaseManifold_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionDispatcher_clearManifold_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionDispatcher_findAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, swig_intgo arg5); +extern _Bool _wrap_btCollisionDispatcher_needsCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btCollisionDispatcher_needsResponse_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btCollisionDispatcher_dispatchAllCollisionPairs_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btCollisionDispatcher_setNearCallback_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_106 arg2); +extern swig_type_107 _wrap_btCollisionDispatcher_getNearCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionDispatcher_defaultNearCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btCollisionDispatcher_allocateCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btCollisionDispatcher_freeCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionDispatcher_getCollisionConfiguration__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionDispatcher_getCollisionConfiguration__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionDispatcher_setCollisionConfiguration_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionDispatcher_getInternalManifoldPool__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionDispatcher_getInternalManifoldPool__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btCollisionPairCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btCollisionPairCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionPairCallback_processOverlap_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btCollisionWorld_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_delete_btCollisionWorld_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionWorld_setBroadphase_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionWorld_getBroadphase__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionWorld_getBroadphase__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionWorld_getPairCache_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionWorld_getDispatcher__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionWorld_getDispatcher__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionWorld_updateSingleAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionWorld_updateAabbs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionWorld_computeOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionWorld_setDebugDrawer_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionWorld_getDebugDrawer_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionWorld_debugDrawWorld_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionWorld_debugDrawObject_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern swig_intgo _wrap_btCollisionWorld_getNumCollisionObjects_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionWorld_rayTest_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btCollisionWorld_convexSweepTest__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, float arg6); +extern void _wrap_btCollisionWorld_convexSweepTest__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btCollisionWorld_contactTest_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btCollisionWorld_contactPairTest_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btCollisionWorld_rayTestSingle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btCollisionWorld_rayTestSingleInternal_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btCollisionWorld_objectQuerySingle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, float arg8); +extern void _wrap_btCollisionWorld_objectQuerySingleInternal_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, float arg6); +extern void _wrap_btCollisionWorld_addCollisionObject__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern void _wrap_btCollisionWorld_addCollisionObject__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btCollisionWorld_addCollisionObject__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionWorld_refreshBroadphaseProxy_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionWorld_getCollisionObjectArray__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionWorld_getCollisionObjectArray__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionWorld_removeCollisionObject_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btCollisionWorld_performDiscreteCollisionDetection_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionWorld_getDispatchInfo__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionWorld_getDispatchInfo__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btCollisionWorld_getForceUpdateAllAabbs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionWorld_setForceUpdateAllAabbs_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern void _wrap_btCollisionWorld_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btUsageBitfield_mbt_e879218550ba2e2b(void); +extern void _wrap_btUsageBitfield_reset_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btUsageBitfield_usedVertexA_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btUsageBitfield_usedVertexA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btUsageBitfield_usedVertexB_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btUsageBitfield_usedVertexB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btUsageBitfield_usedVertexC_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btUsageBitfield_usedVertexC_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btUsageBitfield_usedVertexD_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btUsageBitfield_usedVertexD_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btUsageBitfield_unused1_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btUsageBitfield_unused1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btUsageBitfield_unused2_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btUsageBitfield_unused2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btUsageBitfield_unused3_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btUsageBitfield_unused3_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btUsageBitfield_unused4_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btUsageBitfield_unused4_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btUsageBitfield_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSubSimplexClosestResult_m_closestPointOnSimplex_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSubSimplexClosestResult_m_closestPointOnSimplex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSubSimplexClosestResult_m_usedVertices_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSubSimplexClosestResult_m_usedVertices_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSubSimplexClosestResult_m_barycentricCoords_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btSubSimplexClosestResult_m_barycentricCoords_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSubSimplexClosestResult_m_degenerate_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btSubSimplexClosestResult_m_degenerate_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSubSimplexClosestResult_reset_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btSubSimplexClosestResult_isValid_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4, float arg5); +extern void _wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4); +extern void _wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3); +extern void _wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_3_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_4_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btSubSimplexClosestResult_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btSubSimplexClosestResult_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_numVertices_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btVoronoiSimplexSolver_m_numVertices_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_simplexVectorW_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btVoronoiSimplexSolver_m_simplexVectorW_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_simplexPointsP_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btVoronoiSimplexSolver_m_simplexPointsP_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_simplexPointsQ_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btVoronoiSimplexSolver_m_simplexPointsQ_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_cachedP1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btVoronoiSimplexSolver_m_cachedP1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_cachedP2_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btVoronoiSimplexSolver_m_cachedP2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_cachedV_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btVoronoiSimplexSolver_m_cachedV_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_lastW_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btVoronoiSimplexSolver_m_lastW_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_equalVertexThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btVoronoiSimplexSolver_m_equalVertexThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_cachedValidClosest_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btVoronoiSimplexSolver_m_cachedValidClosest_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_cachedBC_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btVoronoiSimplexSolver_m_cachedBC_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_m_needsUpdate_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btVoronoiSimplexSolver_m_needsUpdate_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_removeVertex_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btVoronoiSimplexSolver_reduceVertices_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btVoronoiSimplexSolver_updateClosestVectorAndPoints_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btVoronoiSimplexSolver_closestPtPointTetrahedron_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7); +extern swig_intgo _wrap_btVoronoiSimplexSolver_pointOutsideOfPlane_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btVoronoiSimplexSolver_closestPtPointTriangle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern uintptr_t _wrap_new_btVoronoiSimplexSolver_mbt_e879218550ba2e2b(void); +extern void _wrap_btVoronoiSimplexSolver_reset_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_addVertex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btVoronoiSimplexSolver_setEqualVertexThreshold_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btVoronoiSimplexSolver_getEqualVertexThreshold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btVoronoiSimplexSolver_closest_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btVoronoiSimplexSolver_maxVertex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btVoronoiSimplexSolver_fullSimplex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btVoronoiSimplexSolver_getSimplex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern _Bool _wrap_btVoronoiSimplexSolver_inSimplex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btVoronoiSimplexSolver_backup_closest_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btVoronoiSimplexSolver_emptySimplex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btVoronoiSimplexSolver_compute_points_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btVoronoiSimplexSolver_numVertices_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btVoronoiSimplexSolver_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btGjkEpaPenetrationDepthSolver_mbt_e879218550ba2e2b(void); +extern _Bool _wrap_btGjkEpaPenetrationDepthSolver_calcPenDepth_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, uintptr_t arg8, uintptr_t arg9, uintptr_t arg10); +extern void _wrap_delete_btGjkEpaPenetrationDepthSolver_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btTriangleCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleCallback_processTriangle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern void _wrap_delete_btInternalTriangleIndexCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btInternalTriangleIndexCallback_internalProcessTriangleIndex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern swig_intgo _wrap_PHY_FLOAT_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_PHY_DOUBLE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_PHY_INTEGER_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_PHY_SHORT_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_PHY_FIXEDPOINT88_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_PHY_UCHAR_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btConcaveShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConcaveShape_processAllTriangles_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern float _wrap_btConcaveShape_getMargin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConcaveShape_setMargin_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btConcaveShape_getAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btConcaveShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btConcaveShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btConcaveShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btConcaveShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btConcaveShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConcaveShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConcaveShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConcaveShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConcaveShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConcaveShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConcaveShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConcaveShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConcaveShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConcaveShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConcaveShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, uintptr_t arg2); +extern swig_type_108 _wrap_btConcaveShape_getName_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btConcaveShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btConcaveShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConcaveShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConcaveShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConcaveShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btConcaveShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConcaveShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btConcaveShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btConcaveShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_109 _wrap_btConcaveShape_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConcaveShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_delete_btStridingMeshInterface_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStridingMeshInterface_InternalProcessAllTriangles_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btStridingMeshInterface_calculateAabbBruteForce_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btStridingMeshInterface_getLockedVertexIndexBase__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, swig_voidp arg3, swig_voidp arg4, swig_voidp arg5, swig_voidp arg6, swig_voidp arg7, swig_voidp arg8, swig_voidp arg9, swig_intgo arg10); +extern void _wrap_btStridingMeshInterface_getLockedVertexIndexBase__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, swig_voidp arg3, swig_voidp arg4, swig_voidp arg5, swig_voidp arg6, swig_voidp arg7, swig_voidp arg8, swig_voidp arg9); +extern void _wrap_btStridingMeshInterface_getLockedReadOnlyVertexIndexBase__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, swig_voidp arg3, swig_voidp arg4, swig_voidp arg5, swig_voidp arg6, swig_voidp arg7, swig_voidp arg8, swig_voidp arg9, swig_intgo arg10); +extern void _wrap_btStridingMeshInterface_getLockedReadOnlyVertexIndexBase__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, swig_voidp arg3, swig_voidp arg4, swig_voidp arg5, swig_voidp arg6, swig_voidp arg7, swig_voidp arg8, swig_voidp arg9); +extern void _wrap_btStridingMeshInterface_unLockVertexBase_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btStridingMeshInterface_unLockReadOnlyVertexBase_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btStridingMeshInterface_getNumSubParts_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStridingMeshInterface_preallocateVertices_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btStridingMeshInterface_preallocateIndices_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern _Bool _wrap_btStridingMeshInterface_hasPremadeAabb_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStridingMeshInterface_setPremadeAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btStridingMeshInterface_getPremadeAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btStridingMeshInterface_getScaling_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStridingMeshInterface_setScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btStridingMeshInterface_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_110 _wrap_btStridingMeshInterface_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btIntIndexData_m_value_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btIntIndexData_m_value_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btIntIndexData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btIntIndexData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btShortIntIndexData_m_value_set_mbt_e879218550ba2e2b(uintptr_t arg1, short arg2); +extern short _wrap_btShortIntIndexData_m_value_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btShortIntIndexData_m_pad_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_111 arg2); +extern swig_type_112 _wrap_btShortIntIndexData_m_pad_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btShortIntIndexData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btShortIntIndexData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btShortIntIndexTripletData_m_values_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btShortIntIndexTripletData_m_values_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btShortIntIndexTripletData_m_pad_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_113 arg2); +extern swig_type_114 _wrap_btShortIntIndexTripletData_m_pad_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btShortIntIndexTripletData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btShortIntIndexTripletData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCharIndexTripletData_m_values_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btCharIndexTripletData_m_values_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCharIndexTripletData_m_pad_set_mbt_e879218550ba2e2b(uintptr_t arg1, char arg2); +extern char _wrap_btCharIndexTripletData_m_pad_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btCharIndexTripletData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btCharIndexTripletData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMeshPartData_m_vertices3f_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMeshPartData_m_vertices3f_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMeshPartData_m_vertices3d_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMeshPartData_m_vertices3d_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMeshPartData_m_indices32_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMeshPartData_m_indices32_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMeshPartData_m_3indices16_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMeshPartData_m_3indices16_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMeshPartData_m_3indices8_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMeshPartData_m_3indices8_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMeshPartData_m_indices16_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMeshPartData_m_indices16_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMeshPartData_m_numTriangles_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btMeshPartData_m_numTriangles_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMeshPartData_m_numVertices_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btMeshPartData_m_numVertices_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btMeshPartData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btMeshPartData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStridingMeshInterfaceData_m_meshPartsPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btStridingMeshInterfaceData_m_meshPartsPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStridingMeshInterfaceData_m_scaling_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btStridingMeshInterfaceData_m_scaling_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStridingMeshInterfaceData_m_numMeshParts_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btStridingMeshInterfaceData_m_numMeshParts_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStridingMeshInterfaceData_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_115 arg2); +extern swig_type_116 _wrap_btStridingMeshInterfaceData_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btStridingMeshInterfaceData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btStridingMeshInterfaceData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btTriangleMeshShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTriangleMeshShape_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleMeshShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTriangleMeshShape_recalcLocalAabb_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleMeshShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btTriangleMeshShape_processAllTriangles_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btTriangleMeshShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern void _wrap_btTriangleMeshShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleMeshShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTriangleMeshShape_getMeshInterface__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTriangleMeshShape_getMeshInterface__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTriangleMeshShape_getLocalAabbMin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btTriangleMeshShape_getLocalAabbMax_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_117 _wrap_btTriangleMeshShape_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btTriangleMeshShape_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btTriangleMeshShape_setMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btTriangleMeshShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btTriangleMeshShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btTriangleMeshShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btTriangleMeshShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btTriangleMeshShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btTriangleMeshShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btTriangleMeshShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btTriangleMeshShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btTriangleMeshShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btTriangleMeshShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btTriangleMeshShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btTriangleMeshShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btTriangleMeshShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btTriangleMeshShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btTriangleMeshShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btTriangleMeshShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btTriangleMeshShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btTriangleMeshShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btTriangleMeshShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btTriangleMeshShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btTriangleMeshShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_118 _wrap_btTriangleMeshShape_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTriangleMeshShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btQuantizedBvhNode_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btQuantizedBvhNode_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhNode_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btQuantizedBvhNode_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhNode_m_escapeIndexOrTriangleIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhNode_m_escapeIndexOrTriangleIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btQuantizedBvhNode_isLeafNode_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btQuantizedBvhNode_getEscapeIndex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btQuantizedBvhNode_getTriangleIndex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btQuantizedBvhNode_getPartId_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btQuantizedBvhNode_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btQuantizedBvhNode_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNode_m_aabbMinOrg_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btOptimizedBvhNode_m_aabbMinOrg_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNode_m_aabbMaxOrg_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btOptimizedBvhNode_m_aabbMaxOrg_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNode_m_escapeIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btOptimizedBvhNode_m_escapeIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNode_m_subPart_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btOptimizedBvhNode_m_subPart_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNode_m_triangleIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btOptimizedBvhNode_m_triangleIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNode_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_119 arg2); +extern swig_type_120 _wrap_btOptimizedBvhNode_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btOptimizedBvhNode_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btOptimizedBvhNode_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhSubtreeInfo_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btBvhSubtreeInfo_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhSubtreeInfo_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btBvhSubtreeInfo_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhSubtreeInfo_m_rootNodeIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btBvhSubtreeInfo_m_rootNodeIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhSubtreeInfo_m_subtreeSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btBvhSubtreeInfo_m_subtreeSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhSubtreeInfo_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btBvhSubtreeInfo_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btBvhSubtreeInfo_mbt_e879218550ba2e2b(void); +extern void _wrap_btBvhSubtreeInfo_setAabbFromQuantizeNode_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btBvhSubtreeInfo_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btNodeOverlapCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btNodeOverlapCallback_processNode_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern swig_intgo _wrap_TRAVERSAL_STACKLESS_btQuantizedBvh_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_TRAVERSAL_STACKLESS_CACHE_FRIENDLY_btQuantizedBvh_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_TRAVERSAL_RECURSIVE_btQuantizedBvh_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btQuantizedBvh_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btQuantizedBvh_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvh_setQuantizationValues__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern void _wrap_btQuantizedBvh_setQuantizationValues__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btQuantizedBvh_getLeafNodeArray_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvh_buildInternal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvh_reportAabbOverlappingNodex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btQuantizedBvh_reportRayOverlappingNodex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btQuantizedBvh_reportBoxCastOverlappingNodex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btQuantizedBvh_quantize_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, uintptr_t arg3, swig_intgo arg4); +extern void _wrap_btQuantizedBvh_quantizeWithClamp_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, uintptr_t arg3, swig_intgo arg4); +extern uintptr_t _wrap_btQuantizedBvh_unQuantize_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern void _wrap_btQuantizedBvh_setTraversalMode_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btQuantizedBvh_getQuantizedNodeArray_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btQuantizedBvh_getSubtreeInfoArray_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btQuantizedBvh_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btQuantizedBvh_serialize__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, _Bool arg4); +extern uintptr_t _wrap_btQuantizedBvh_deSerializeInPlace_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, _Bool arg3); +extern swig_intgo _wrap_btQuantizedBvh_getAlignmentSerializationPadding_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btQuantizedBvh_calculateSerializeBufferSizeNew_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_121 _wrap_btQuantizedBvh_serialize__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btQuantizedBvh_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btQuantizedBvh_deSerializeDouble_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btQuantizedBvh_isQuantized_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhSubtreeInfoData_m_rootNodeIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btBvhSubtreeInfoData_m_rootNodeIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhSubtreeInfoData_m_subtreeSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btBvhSubtreeInfoData_m_subtreeSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhSubtreeInfoData_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btBvhSubtreeInfoData_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhSubtreeInfoData_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btBvhSubtreeInfoData_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btBvhSubtreeInfoData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btBvhSubtreeInfoData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeFloatData_m_aabbMinOrg_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btOptimizedBvhNodeFloatData_m_aabbMinOrg_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeFloatData_m_aabbMaxOrg_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btOptimizedBvhNodeFloatData_m_aabbMaxOrg_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeFloatData_m_escapeIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btOptimizedBvhNodeFloatData_m_escapeIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeFloatData_m_subPart_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btOptimizedBvhNodeFloatData_m_subPart_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeFloatData_m_triangleIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btOptimizedBvhNodeFloatData_m_triangleIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeFloatData_m_pad_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_122 arg2); +extern swig_type_123 _wrap_btOptimizedBvhNodeFloatData_m_pad_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btOptimizedBvhNodeFloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btOptimizedBvhNodeFloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeDoubleData_m_aabbMinOrg_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btOptimizedBvhNodeDoubleData_m_aabbMinOrg_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeDoubleData_m_aabbMaxOrg_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btOptimizedBvhNodeDoubleData_m_aabbMaxOrg_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeDoubleData_m_escapeIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btOptimizedBvhNodeDoubleData_m_escapeIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeDoubleData_m_subPart_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btOptimizedBvhNodeDoubleData_m_subPart_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeDoubleData_m_triangleIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btOptimizedBvhNodeDoubleData_m_triangleIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvhNodeDoubleData_m_pad_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_124 arg2); +extern swig_type_125 _wrap_btOptimizedBvhNodeDoubleData_m_pad_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btOptimizedBvhNodeDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btOptimizedBvhNodeDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhNodeData_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btQuantizedBvhNodeData_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhNodeData_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btQuantizedBvhNodeData_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhNodeData_m_escapeIndexOrTriangleIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhNodeData_m_escapeIndexOrTriangleIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btQuantizedBvhNodeData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btQuantizedBvhNodeData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_bvhAabbMin_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhFloatData_m_bvhAabbMin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_bvhAabbMax_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhFloatData_m_bvhAabbMax_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_bvhQuantization_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhFloatData_m_bvhQuantization_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_curNodeIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhFloatData_m_curNodeIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_useQuantization_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhFloatData_m_useQuantization_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_numContiguousLeafNodes_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhFloatData_m_numContiguousLeafNodes_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_numQuantizedContiguousNodes_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhFloatData_m_numQuantizedContiguousNodes_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_contiguousNodesPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhFloatData_m_contiguousNodesPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_quantizedContiguousNodesPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhFloatData_m_quantizedContiguousNodesPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_subTreeInfoPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhFloatData_m_subTreeInfoPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_traversalMode_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhFloatData_m_traversalMode_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhFloatData_m_numSubtreeHeaders_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhFloatData_m_numSubtreeHeaders_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btQuantizedBvhFloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btQuantizedBvhFloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_bvhAabbMin_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhDoubleData_m_bvhAabbMin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_bvhAabbMax_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhDoubleData_m_bvhAabbMax_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_bvhQuantization_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhDoubleData_m_bvhQuantization_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_curNodeIndex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhDoubleData_m_curNodeIndex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_useQuantization_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhDoubleData_m_useQuantization_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_numContiguousLeafNodes_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhDoubleData_m_numContiguousLeafNodes_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_numQuantizedContiguousNodes_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhDoubleData_m_numQuantizedContiguousNodes_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_contiguousNodesPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhDoubleData_m_contiguousNodesPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_quantizedContiguousNodesPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhDoubleData_m_quantizedContiguousNodesPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_traversalMode_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhDoubleData_m_traversalMode_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_numSubtreeHeaders_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btQuantizedBvhDoubleData_m_numSubtreeHeaders_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btQuantizedBvhDoubleData_m_subTreeInfoPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btQuantizedBvhDoubleData_m_subTreeInfoPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btQuantizedBvhDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btQuantizedBvhDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btOptimizedBvh_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btOptimizedBvh_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btOptimizedBvh_build_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, _Bool arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btOptimizedBvh_refit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btOptimizedBvh_refitPartial_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btOptimizedBvh_updateBvhNodes_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4, swig_intgo arg5); +extern _Bool _wrap_btOptimizedBvh_serializeInPlace_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, _Bool arg4); +extern uintptr_t _wrap_btOptimizedBvh_deSerializeInPlace_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, _Bool arg3); +extern void _wrap_btOptimizedBvh_setQuantizationValues__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, float arg3); +extern void _wrap_btOptimizedBvh_setQuantizationValues__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btOptimizedBvh_getLeafNodeArray_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btOptimizedBvh_buildInternal_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btOptimizedBvh_reportAabbOverlappingNodex_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btOptimizedBvh_reportRayOverlappingNodex_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btOptimizedBvh_reportBoxCastOverlappingNodex_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btOptimizedBvh_quantize_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_voidp arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btOptimizedBvh_quantizeWithClamp_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_voidp arg1, uintptr_t arg2, swig_intgo arg3); +extern uintptr_t _wrap_btOptimizedBvh_unQuantize_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_voidp arg1); +extern void _wrap_btOptimizedBvh_setTraversalMode_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern uintptr_t _wrap_btOptimizedBvh_getQuantizedNodeArray_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btOptimizedBvh_getSubtreeInfoArray_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btOptimizedBvh_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btOptimizedBvh_serialize__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_intgo arg2, _Bool arg3); +extern swig_type_126 _wrap_btOptimizedBvh_serialize__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btOptimizedBvh_getAlignmentSerializationPadding_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btOptimizedBvh_calculateSerializeBufferSizeNew_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btOptimizedBvh_deSerializeFloat_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btOptimizedBvh_deSerializeDouble_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern _Bool _wrap_btOptimizedBvh_isQuantized_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_new_btTriangleInfo_mbt_e879218550ba2e2b(void); +extern void _wrap_btTriangleInfo_m_flags_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTriangleInfo_m_flags_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfo_m_edgeV0V1Angle_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfo_m_edgeV0V1Angle_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfo_m_edgeV1V2Angle_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfo_m_edgeV1V2Angle_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfo_m_edgeV2V0Angle_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfo_m_edgeV2V0Angle_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btTriangleInfo_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMap_m_convexEpsilon_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMap_m_convexEpsilon_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMap_m_planarEpsilon_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMap_m_planarEpsilon_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMap_m_equalVertexThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMap_m_equalVertexThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMap_m_edgeDistanceThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMap_m_edgeDistanceThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMap_m_maxEdgeAngleThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMap_m_maxEdgeAngleThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMap_m_zeroAreaThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMap_m_zeroAreaThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTriangleInfoMap_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btTriangleInfoMap_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btTriangleInfoMap_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_127 _wrap_btTriangleInfoMap_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btTriangleInfoMap_deSerialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btTriangleInfoData_m_flags_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTriangleInfoData_m_flags_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoData_m_edgeV0V1Angle_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoData_m_edgeV0V1Angle_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoData_m_edgeV1V2Angle_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoData_m_edgeV1V2Angle_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoData_m_edgeV2V0Angle_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoData_m_edgeV2V0Angle_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTriangleInfoData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btTriangleInfoData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_hashTablePtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btTriangleInfoMapData_m_hashTablePtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_nextPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btTriangleInfoMapData_m_nextPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_valueArrayPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleInfoMapData_m_valueArrayPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_keyArrayPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btTriangleInfoMapData_m_keyArrayPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_convexEpsilon_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMapData_m_convexEpsilon_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_planarEpsilon_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMapData_m_planarEpsilon_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_equalVertexThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMapData_m_equalVertexThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_edgeDistanceThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMapData_m_edgeDistanceThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_zeroAreaThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleInfoMapData_m_zeroAreaThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_nextSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTriangleInfoMapData_m_nextSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_hashTableSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTriangleInfoMapData_m_hashTableSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_numValues_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTriangleInfoMapData_m_numValues_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_numKeys_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTriangleInfoMapData_m_numKeys_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleInfoMapData_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_128 arg2); +extern swig_type_129 _wrap_btTriangleInfoMapData_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTriangleInfoMapData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btTriangleInfoMapData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btBvhTriangleMeshShape__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2, _Bool arg3); +extern uintptr_t _wrap_new_btBvhTriangleMeshShape__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern uintptr_t _wrap_new_btBvhTriangleMeshShape__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5); +extern uintptr_t _wrap_new_btBvhTriangleMeshShape__SWIG_3_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_delete_btBvhTriangleMeshShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btBvhTriangleMeshShape_getOwnsBvh_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhTriangleMeshShape_performRaycast_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btBvhTriangleMeshShape_performConvexcast_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btBvhTriangleMeshShape_processAllTriangles_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btBvhTriangleMeshShape_refitTree_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btBvhTriangleMeshShape_partialRefitTree_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_type_130 _wrap_btBvhTriangleMeshShape_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhTriangleMeshShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBvhTriangleMeshShape_getOptimizedBvh_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhTriangleMeshShape_setOptimizedBvh__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btBvhTriangleMeshShape_setOptimizedBvh__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btBvhTriangleMeshShape_buildOptimizedBvh_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btBvhTriangleMeshShape_usesQuantizedAabbCompression_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBvhTriangleMeshShape_setTriangleInfoMap_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBvhTriangleMeshShape_getTriangleInfoMap__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btBvhTriangleMeshShape_getTriangleInfoMap__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btBvhTriangleMeshShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_131 _wrap_btBvhTriangleMeshShape_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btBvhTriangleMeshShape_serializeSingleBvh_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btBvhTriangleMeshShape_serializeSingleTriangleInfoMap_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBvhTriangleMeshShape_localGetSupportingVertex_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btBvhTriangleMeshShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btBvhTriangleMeshShape_recalcLocalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBvhTriangleMeshShape_getAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btBvhTriangleMeshShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBvhTriangleMeshShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBvhTriangleMeshShape_getMeshInterface__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBvhTriangleMeshShape_getMeshInterface__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBvhTriangleMeshShape_getLocalAabbMin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBvhTriangleMeshShape_getLocalAabbMax_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btBvhTriangleMeshShape_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBvhTriangleMeshShape_setMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btBvhTriangleMeshShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btBvhTriangleMeshShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btBvhTriangleMeshShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btBvhTriangleMeshShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btBvhTriangleMeshShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBvhTriangleMeshShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBvhTriangleMeshShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBvhTriangleMeshShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBvhTriangleMeshShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBvhTriangleMeshShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBvhTriangleMeshShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btBvhTriangleMeshShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btBvhTriangleMeshShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBvhTriangleMeshShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBvhTriangleMeshShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btBvhTriangleMeshShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBvhTriangleMeshShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btBvhTriangleMeshShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBvhTriangleMeshShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btBvhTriangleMeshShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBvhTriangleMeshShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btTriangleMeshShapeData_m_collisionShapeData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleMeshShapeData_m_collisionShapeData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleMeshShapeData_m_meshInterface_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleMeshShapeData_m_meshInterface_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleMeshShapeData_m_quantizedFloatBvh_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleMeshShapeData_m_quantizedFloatBvh_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleMeshShapeData_m_quantizedDoubleBvh_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleMeshShapeData_m_quantizedDoubleBvh_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleMeshShapeData_m_triangleInfoMap_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleMeshShapeData_m_triangleInfoMap_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleMeshShapeData_m_collisionMargin_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleMeshShapeData_m_collisionMargin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleMeshShapeData_m_pad3_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_132 arg2); +extern swig_type_133 _wrap_btTriangleMeshShapeData_m_pad3_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTriangleMeshShapeData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btTriangleMeshShapeData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btHeightfieldTerrainShape__SWIG_0_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2, swig_voidp arg3, float arg4, float arg5, swig_intgo arg6, _Bool arg7); +extern uintptr_t _wrap_new_btHeightfieldTerrainShape__SWIG_1_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2, swig_voidp arg3, float arg4, float arg5, swig_intgo arg6, _Bool arg7); +extern uintptr_t _wrap_new_btHeightfieldTerrainShape__SWIG_2_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2, swig_voidp arg3, float arg4, float arg5, float arg6, swig_intgo arg7, _Bool arg8); +extern uintptr_t _wrap_new_btHeightfieldTerrainShape__SWIG_3_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2, swig_voidp arg3, float arg4, float arg5, float arg6, swig_intgo arg7, _Bool arg8); +extern uintptr_t _wrap_new_btHeightfieldTerrainShape__SWIG_4_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2, uintptr_t arg3, float arg4, float arg5, float arg6, swig_intgo arg7, swig_intgo arg8, _Bool arg9); +extern uintptr_t _wrap_new_btHeightfieldTerrainShape__SWIG_5_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2, uintptr_t arg3, float arg4, swig_intgo arg5, _Bool arg6, _Bool arg7); +extern void _wrap_delete_btHeightfieldTerrainShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHeightfieldTerrainShape_setUseDiamondSubdivision__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern void _wrap_btHeightfieldTerrainShape_setUseDiamondSubdivision__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHeightfieldTerrainShape_setUseZigzagSubdivision__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern void _wrap_btHeightfieldTerrainShape_setUseZigzagSubdivision__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHeightfieldTerrainShape_setFlipTriangleWinding_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern void _wrap_btHeightfieldTerrainShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btHeightfieldTerrainShape_processAllTriangles_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btHeightfieldTerrainShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern void _wrap_btHeightfieldTerrainShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btHeightfieldTerrainShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHeightfieldTerrainShape_getVertex_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, uintptr_t arg4); +extern void _wrap_btHeightfieldTerrainShape_performRaycast_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btHeightfieldTerrainShape_buildAccelerator__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btHeightfieldTerrainShape_buildAccelerator__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHeightfieldTerrainShape_clearAccelerator_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btHeightfieldTerrainShape_getUpAxis_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_134 _wrap_btHeightfieldTerrainShape_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHeightfieldTerrainShape_setUserValue3_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btHeightfieldTerrainShape_getUserValue3_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHeightfieldTerrainShape_getTriangleInfoMap__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHeightfieldTerrainShape_getTriangleInfoMap__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHeightfieldTerrainShape_setTriangleInfoMap_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_voidp _wrap_btHeightfieldTerrainShape_getHeightfieldRawData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btHeightfieldTerrainShape_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btHeightfieldTerrainShape_setMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btHeightfieldTerrainShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btHeightfieldTerrainShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btHeightfieldTerrainShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btHeightfieldTerrainShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btHeightfieldTerrainShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btHeightfieldTerrainShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btHeightfieldTerrainShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btHeightfieldTerrainShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btHeightfieldTerrainShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btHeightfieldTerrainShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btHeightfieldTerrainShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btHeightfieldTerrainShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btHeightfieldTerrainShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btHeightfieldTerrainShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btHeightfieldTerrainShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btHeightfieldTerrainShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btHeightfieldTerrainShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btHeightfieldTerrainShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btHeightfieldTerrainShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btHeightfieldTerrainShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btHeightfieldTerrainShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_135 _wrap_btHeightfieldTerrainShape_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btHeightfieldTerrainShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btTriangleRaycastCallback_m_from_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleRaycastCallback_m_from_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleRaycastCallback_m_to_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleRaycastCallback_m_to_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_kF_None_btTriangleRaycastCallback_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_kF_FilterBackfaces_btTriangleRaycastCallback_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_kF_KeepUnflippedNormal_btTriangleRaycastCallback_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_kF_UseSubSimplexConvexCastRaytest_btTriangleRaycastCallback_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_kF_UseGjkConvexCastRaytest_btTriangleRaycastCallback_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_kF_DisableHeightfieldAccelerator_btTriangleRaycastCallback_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_kF_Terminator_btTriangleRaycastCallback_mbt_e879218550ba2e2b(void); +extern void _wrap_btTriangleRaycastCallback_m_flags_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTriangleRaycastCallback_m_flags_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleRaycastCallback_m_hitFraction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleRaycastCallback_m_hitFraction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleRaycastCallback_processTriangle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern float _wrap_btTriangleRaycastCallback_reportHit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, swig_intgo arg4, swig_intgo arg5); +extern void _wrap_delete_btTriangleRaycastCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleConvexcastCallback_m_convexShape_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleConvexcastCallback_m_convexShape_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleConvexcastCallback_m_convexShapeFrom_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleConvexcastCallback_m_convexShapeFrom_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleConvexcastCallback_m_convexShapeTo_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleConvexcastCallback_m_convexShapeTo_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleConvexcastCallback_m_triangleToWorld_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTriangleConvexcastCallback_m_triangleToWorld_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleConvexcastCallback_m_hitFraction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleConvexcastCallback_m_hitFraction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleConvexcastCallback_m_triangleCollisionMargin_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleConvexcastCallback_m_triangleCollisionMargin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleConvexcastCallback_m_allowedPenetration_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTriangleConvexcastCallback_m_allowedPenetration_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTriangleConvexcastCallback_processTriangle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern float _wrap_btTriangleConvexcastCallback_reportHit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, swig_intgo arg5, swig_intgo arg6); +extern void _wrap_delete_btTriangleConvexcastCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_DBG_NoDebug_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_DrawWireframe_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_DrawAabb_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_DrawFeaturesText_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_DrawContactPoints_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_NoDeactivation_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_NoHelpText_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_DrawText_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_ProfileTimings_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_EnableSatComparison_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_DisableBulletLCP_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_EnableCCD_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_DrawConstraints_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_DrawConstraintLimits_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_FastWireframe_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_DrawNormals_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_DrawFrames_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_DBG_MAX_DEBUG_DRAW_MODE_btIDebugDraw_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btIDebugDraw_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btIDebugDraw_getDefaultColors_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btIDebugDraw_setDefaultColors_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btIDebugDraw_drawLine__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btIDebugDraw_drawLine__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btIDebugDraw_drawSphere__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btIDebugDraw_drawSphere__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, uintptr_t arg4); +extern void _wrap_btIDebugDraw_drawTriangle__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, uintptr_t arg8, float arg9); +extern void _wrap_btIDebugDraw_drawTriangle__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, float arg6); +extern void _wrap_btIDebugDraw_drawContactPoint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, swig_intgo arg5, uintptr_t arg6); +extern void _wrap_btIDebugDraw_reportErrorWarning_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_136 arg2); +extern void _wrap_btIDebugDraw_draw3dText_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_type_137 arg3); +extern void _wrap_btIDebugDraw_setDebugMode_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btIDebugDraw_getDebugMode_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btIDebugDraw_drawAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btIDebugDraw_drawTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern void _wrap_btIDebugDraw_drawArc__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, float arg6, float arg7, float arg8, uintptr_t arg9, _Bool arg10, float arg11); +extern void _wrap_btIDebugDraw_drawArc__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, float arg6, float arg7, float arg8, uintptr_t arg9, _Bool arg10); +extern void _wrap_btIDebugDraw_drawSpherePatch__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, float arg6, float arg7, float arg8, float arg9, uintptr_t arg10, float arg11, _Bool arg12); +extern void _wrap_btIDebugDraw_drawSpherePatch__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, float arg6, float arg7, float arg8, float arg9, uintptr_t arg10, float arg11); +extern void _wrap_btIDebugDraw_drawSpherePatch__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, float arg6, float arg7, float arg8, float arg9, uintptr_t arg10); +extern void _wrap_btIDebugDraw_drawBox__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btIDebugDraw_drawBox__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btIDebugDraw_drawCapsule_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, swig_intgo arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btIDebugDraw_drawCylinder_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, swig_intgo arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btIDebugDraw_drawCone_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, swig_intgo arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btIDebugDraw_drawPlane_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btIDebugDraw_clearLines_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btIDebugDraw_flushLines_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btConvexCast_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btConvexCast_calcTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern uintptr_t _wrap_new_btSubsimplexConvexCast_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btSubsimplexConvexCast_calcTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_delete_btSubsimplexConvexCast_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btGjkConvexCast_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btGjkConvexCast_calcTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_delete_btGjkConvexCast_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btContinuousConvexCollision__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_new_btContinuousConvexCollision__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btContinuousConvexCollision_calcTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_delete_btContinuousConvexCollision_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleRayCallback_m_rayFromWorld_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleRayCallback_m_rayFromWorld_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleRayCallback_m_rayToWorld_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleRayCallback_m_rayToWorld_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleRayCallback_m_rayFromTrans_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleRayCallback_m_rayFromTrans_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleRayCallback_m_rayToTrans_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleRayCallback_m_rayToTrans_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleRayCallback_m_hitNormal_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleRayCallback_m_hitNormal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleRayCallback_m_world_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleRayCallback_m_world_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleRayCallback_m_resultCallback_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleRayCallback_m_resultCallback_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btSingleRayCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern _Bool _wrap_btSingleRayCallback_process_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btSingleRayCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SetbtSingleRayCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_GetbtSingleRayCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtSingleRayCallback_M_signs_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_voidp arg1); +extern swig_voidp _wrap_GetbtSingleRayCallback_M_signs_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtSingleRayCallback_M_lambda_max_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtSingleRayCallback_M_lambda_max_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSingleSweepCallback_m_convexFromTrans_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleSweepCallback_m_convexFromTrans_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleSweepCallback_m_convexToTrans_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleSweepCallback_m_convexToTrans_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleSweepCallback_m_hitNormal_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleSweepCallback_m_hitNormal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleSweepCallback_m_world_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleSweepCallback_m_world_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleSweepCallback_m_resultCallback_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleSweepCallback_m_resultCallback_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleSweepCallback_m_allowedCcdPenetration_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSingleSweepCallback_m_allowedCcdPenetration_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleSweepCallback_m_castShape_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleSweepCallback_m_castShape_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btSingleSweepCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, float arg6); +extern _Bool _wrap_btSingleSweepCallback_process_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btSingleSweepCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SetbtSingleSweepCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_GetbtSingleSweepCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtSingleSweepCallback_M_signs_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_voidp arg1); +extern swig_voidp _wrap_GetbtSingleSweepCallback_M_signs_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtSingleSweepCallback_M_lambda_max_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtSingleSweepCallback_M_lambda_max_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBridgedManifoldResult_m_resultCallback_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBridgedManifoldResult_m_resultCallback_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btBridgedManifoldResult_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btBridgedManifoldResult_addContactPoint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern void _wrap_delete_btBridgedManifoldResult_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBridgedManifoldResult_setPersistentManifold_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btBridgedManifoldResult_getPersistentManifold__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBridgedManifoldResult_getPersistentManifold__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBridgedManifoldResult_setShapeIdentifiersA_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, swig_intgo arg2); +extern void _wrap_btBridgedManifoldResult_setShapeIdentifiersB_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, swig_intgo arg2); +extern void _wrap_btBridgedManifoldResult_refreshContactPoints_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBridgedManifoldResult_getBody0Wrap_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBridgedManifoldResult_getBody1Wrap_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btBridgedManifoldResult_setBody0Wrap_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btBridgedManifoldResult_setBody1Wrap_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btBridgedManifoldResult_getBody0Internal_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btBridgedManifoldResult_getBody1Internal_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtBridgedManifoldResult_M_closestPointDistanceThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtBridgedManifoldResult_M_closestPointDistanceThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btBridgedManifoldResult_calculateCombinedRestitution_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btBridgedManifoldResult_calculateCombinedFriction_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btBridgedManifoldResult_calculateCombinedRollingFriction_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btBridgedManifoldResult_calculateCombinedSpinningFriction_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btBridgedManifoldResult_calculateCombinedContactDamping_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern float _wrap_btBridgedManifoldResult_calculateCombinedContactStiffness_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btSingleContactCallback_m_collisionObject_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleContactCallback_m_collisionObject_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleContactCallback_m_world_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleContactCallback_m_world_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSingleContactCallback_m_resultCallback_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSingleContactCallback_m_resultCallback_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btSingleContactCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btSingleContactCallback_process_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btSingleContactCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_DebugDrawcallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_DebugDrawcallback_internalProcessTriangleIndex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern void _wrap_DebugDrawcallback_processTriangle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern void _wrap_delete_DebugDrawcallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_DebugDrawcallback_SwigGetBtInternalTriangleIndexCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_SOLVER_RANDMIZE_ORDER_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_FRICTION_SEPARATE_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_USE_WARMSTARTING_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_USE_2_FRICTION_DIRECTIONS_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_ENABLE_FRICTION_DIRECTION_CACHING_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_CACHE_FRIENDLY_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_SIMD_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_DISABLE_IMPLICIT_CONE_FRICTION_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_SOLVER_USE_ARTICULATED_WARMSTARTING_mbt_e879218550ba2e2b(void); +extern void _wrap_btContactSolverInfoData_m_tau_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_tau_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_damping_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_damping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_friction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_friction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_timeStep_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_timeStep_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_restitution_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_restitution_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_numIterations_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoData_m_numIterations_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_maxErrorReduction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_maxErrorReduction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_sor_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_sor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_erp_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_erp_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_erp2_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_erp2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_deformable_erp_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_deformable_erp_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_deformable_cfm_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_deformable_cfm_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_deformable_maxErrorReduction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_deformable_maxErrorReduction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_globalCfm_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_globalCfm_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_frictionERP_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_frictionERP_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_frictionCFM_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_frictionCFM_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_splitImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoData_m_splitImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_splitImpulsePenetrationThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_splitImpulsePenetrationThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_splitImpulseTurnErp_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_splitImpulseTurnErp_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_linearSlop_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_linearSlop_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_warmstartingFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_warmstartingFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_articulatedWarmstartingFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_articulatedWarmstartingFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_solverMode_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoData_m_solverMode_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_restingContactRestitutionThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoData_m_restingContactRestitutionThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_minimumSolverBatchSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoData_m_minimumSolverBatchSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_maxGyroscopicForce_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_maxGyroscopicForce_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_singleAxisRollingFrictionThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_singleAxisRollingFrictionThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_leastSquaresResidualThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_leastSquaresResidualThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_restitutionVelocityThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoData_m_restitutionVelocityThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_jointFeedbackInWorldSpace_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btContactSolverInfoData_m_jointFeedbackInWorldSpace_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_jointFeedbackInJointFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btContactSolverInfoData_m_jointFeedbackInJointFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_reportSolverAnalytics_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoData_m_reportSolverAnalytics_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoData_m_numNonContactInnerIterations_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoData_m_numNonContactInnerIterations_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btContactSolverInfoData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btContactSolverInfoData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btContactSolverInfo_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btContactSolverInfo_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SetbtContactSolverInfo_M_tau_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_tau_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_damping_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_damping_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_friction_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_friction_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_timeStep_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_timeStep_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_restitution_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_restitution_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_numIterations_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtContactSolverInfo_M_numIterations_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_maxErrorReduction_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_maxErrorReduction_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_sor_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_sor_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_erp_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_erp_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_erp2_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_erp2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_deformable_erp_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_deformable_erp_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_deformable_cfm_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_deformable_cfm_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_deformable_maxErrorReduction_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_deformable_maxErrorReduction_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_globalCfm_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_globalCfm_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_frictionERP_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_frictionERP_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_frictionCFM_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_frictionCFM_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_splitImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtContactSolverInfo_M_splitImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_splitImpulsePenetrationThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_splitImpulsePenetrationThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_splitImpulseTurnErp_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_splitImpulseTurnErp_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_linearSlop_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_linearSlop_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_warmstartingFactor_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_warmstartingFactor_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_articulatedWarmstartingFactor_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_articulatedWarmstartingFactor_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_solverMode_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtContactSolverInfo_M_solverMode_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_restingContactRestitutionThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtContactSolverInfo_M_restingContactRestitutionThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_minimumSolverBatchSize_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtContactSolverInfo_M_minimumSolverBatchSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_maxGyroscopicForce_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_maxGyroscopicForce_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_singleAxisRollingFrictionThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_singleAxisRollingFrictionThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_leastSquaresResidualThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_leastSquaresResidualThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_restitutionVelocityThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_GetbtContactSolverInfo_M_restitutionVelocityThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_jointFeedbackInWorldSpace_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern _Bool _wrap_GetbtContactSolverInfo_M_jointFeedbackInWorldSpace_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_jointFeedbackInJointFrame_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern _Bool _wrap_GetbtContactSolverInfo_M_jointFeedbackInJointFrame_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_reportSolverAnalytics_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtContactSolverInfo_M_reportSolverAnalytics_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtContactSolverInfo_M_numNonContactInnerIterations_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtContactSolverInfo_M_numNonContactInnerIterations_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btContactSolverInfoDoubleData_m_tau_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_tau_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_damping_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_damping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_friction_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_friction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_timeStep_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_timeStep_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_restitution_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_restitution_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_maxErrorReduction_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_maxErrorReduction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_sor_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_sor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_erp_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_erp_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_erp2_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_erp2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_globalCfm_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_globalCfm_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_splitImpulsePenetrationThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_splitImpulsePenetrationThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_splitImpulseTurnErp_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_splitImpulseTurnErp_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_linearSlop_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_linearSlop_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_warmstartingFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_warmstartingFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_articulatedWarmstartingFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_articulatedWarmstartingFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_maxGyroscopicForce_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_maxGyroscopicForce_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_singleAxisRollingFrictionThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btContactSolverInfoDoubleData_m_singleAxisRollingFrictionThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_numIterations_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoDoubleData_m_numIterations_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_solverMode_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoDoubleData_m_solverMode_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_restingContactRestitutionThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoDoubleData_m_restingContactRestitutionThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_minimumSolverBatchSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoDoubleData_m_minimumSolverBatchSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_splitImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoDoubleData_m_splitImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoDoubleData_m_padding_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_138 arg2); +extern swig_type_139 _wrap_btContactSolverInfoDoubleData_m_padding_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btContactSolverInfoDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btContactSolverInfoDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_tau_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_tau_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_damping_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_damping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_friction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_friction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_timeStep_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_timeStep_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_restitution_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_restitution_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_maxErrorReduction_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_maxErrorReduction_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_sor_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_sor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_erp_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_erp_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_erp2_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_erp2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_globalCfm_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_globalCfm_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_splitImpulsePenetrationThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_splitImpulsePenetrationThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_splitImpulseTurnErp_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_splitImpulseTurnErp_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_linearSlop_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_linearSlop_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_warmstartingFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_warmstartingFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_articulatedWarmstartingFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_articulatedWarmstartingFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_maxGyroscopicForce_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_maxGyroscopicForce_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_singleAxisRollingFrictionThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btContactSolverInfoFloatData_m_singleAxisRollingFrictionThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_numIterations_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoFloatData_m_numIterations_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_solverMode_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoFloatData_m_solverMode_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_restingContactRestitutionThreshold_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoFloatData_m_restingContactRestitutionThreshold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_minimumSolverBatchSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoFloatData_m_minimumSolverBatchSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btContactSolverInfoFloatData_m_splitImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btContactSolverInfoFloatData_m_splitImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btContactSolverInfoFloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btContactSolverInfoFloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_BT_SIMPLE_DYNAMICS_WORLD_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_DISCRETE_DYNAMICS_WORLD_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONTINUOUS_DYNAMICS_WORLD_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_SOFT_RIGID_DYNAMICS_WORLD_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_GPU_DYNAMICS_WORLD_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_SOFT_MULTIBODY_DYNAMICS_WORLD_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDynamicsWorld_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btDynamicsWorld_stepSimulation__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, swig_intgo arg3, float arg4); +extern swig_intgo _wrap_btDynamicsWorld_stepSimulation__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, swig_intgo arg3); +extern swig_intgo _wrap_btDynamicsWorld_stepSimulation__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btDynamicsWorld_debugDrawWorld_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDynamicsWorld_addConstraint__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, _Bool arg3); +extern void _wrap_btDynamicsWorld_addConstraint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_removeConstraint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_addAction_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_removeAction_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_setGravity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDynamicsWorld_getGravity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDynamicsWorld_synchronizeMotionStates_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDynamicsWorld_addRigidBody__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_addRigidBody__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern void _wrap_btDynamicsWorld_removeRigidBody_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_setConstraintSolver_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDynamicsWorld_getConstraintSolver_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btDynamicsWorld_getNumConstraints_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDynamicsWorld_getConstraint__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btDynamicsWorld_getConstraint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDynamicsWorld_getWorldType_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDynamicsWorld_clearForces_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDynamicsWorld_setInternalTickCallback__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_140 arg2, uintptr_t arg3, _Bool arg4); +extern void _wrap_btDynamicsWorld_setInternalTickCallback__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_141 arg2, uintptr_t arg3); +extern void _wrap_btDynamicsWorld_setInternalTickCallback__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_142 arg2); +extern void _wrap_btDynamicsWorld_setWorldUserInfo_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDynamicsWorld_getWorldUserInfo_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDynamicsWorld_getSolverInfo__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDynamicsWorld_getSolverInfo__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDynamicsWorld_addVehicle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_removeVehicle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_addCharacter_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_removeCharacter_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_setBroadphase_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btDynamicsWorld_getBroadphase__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDynamicsWorld_getBroadphase__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDynamicsWorld_getPairCache_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDynamicsWorld_getDispatcher__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDynamicsWorld_getDispatcher__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDynamicsWorld_updateSingleAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btDynamicsWorld_updateAabbs_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDynamicsWorld_computeOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDynamicsWorld_setDebugDrawer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btDynamicsWorld_getDebugDrawer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDynamicsWorld_debugDrawObject_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btDynamicsWorld_getNumCollisionObjects_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDynamicsWorld_rayTest_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDynamicsWorld_convexSweepTest__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5); +extern void _wrap_btDynamicsWorld_convexSweepTest__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDynamicsWorld_contactTest_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDynamicsWorld_contactPairTest_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDynamicsWorld_rayTestSingle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btDynamicsWorld_rayTestSingleInternal_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDynamicsWorld_objectQuerySingle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, float arg8); +extern void _wrap_btDynamicsWorld_objectQuerySingleInternal_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, float arg6); +extern void _wrap_btDynamicsWorld_addCollisionObject__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern void _wrap_btDynamicsWorld_addCollisionObject__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btDynamicsWorld_addCollisionObject__SWIG_2_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btDynamicsWorld_refreshBroadphaseProxy_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btDynamicsWorld_getCollisionObjectArray__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDynamicsWorld_getCollisionObjectArray__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDynamicsWorld_removeCollisionObject_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btDynamicsWorld_performDiscreteCollisionDetection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDynamicsWorld_getDispatchInfo__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDynamicsWorld_getDispatchInfo__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btDynamicsWorld_getForceUpdateAllAabbs_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDynamicsWorld_setForceUpdateAllAabbs_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern void _wrap_btDynamicsWorld_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btDynamicsWorldDoubleData_m_solverInfo_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDynamicsWorldDoubleData_m_solverInfo_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDynamicsWorldDoubleData_m_gravity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDynamicsWorldDoubleData_m_gravity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDynamicsWorldDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDynamicsWorldDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDynamicsWorldFloatData_m_solverInfo_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDynamicsWorldFloatData_m_solverInfo_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDynamicsWorldFloatData_m_gravity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDynamicsWorldFloatData_m_gravity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDynamicsWorldFloatData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDynamicsWorldFloatData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDiscreteDynamicsWorld_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_delete_btDiscreteDynamicsWorld_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btDiscreteDynamicsWorld_stepSimulation__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, swig_intgo arg3, float arg4); +extern swig_intgo _wrap_btDiscreteDynamicsWorld_stepSimulation__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, swig_intgo arg3); +extern swig_intgo _wrap_btDiscreteDynamicsWorld_stepSimulation__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btDiscreteDynamicsWorld_solveConstraints_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_synchronizeMotionStates_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_synchronizeSingleMotionState_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_addConstraint__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, _Bool arg3); +extern void _wrap_btDiscreteDynamicsWorld_addConstraint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_removeConstraint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_addAction_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_removeAction_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getSimulationIslandManager__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getSimulationIslandManager__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getCollisionWorld_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_setGravity_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getGravity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_addCollisionObject__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern void _wrap_btDiscreteDynamicsWorld_addCollisionObject__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_btDiscreteDynamicsWorld_addCollisionObject__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_addRigidBody__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_addRigidBody__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern void _wrap_btDiscreteDynamicsWorld_removeRigidBody_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_removeCollisionObject_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_debugDrawConstraint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_debugDrawWorld_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_setConstraintSolver_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getConstraintSolver_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btDiscreteDynamicsWorld_getNumConstraints_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getConstraint__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getConstraint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDiscreteDynamicsWorld_getWorldType_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_clearForces_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_applyGravity_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_setNumTasks_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btDiscreteDynamicsWorld_updateVehicles_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btDiscreteDynamicsWorld_addVehicle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_removeVehicle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_addCharacter_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_removeCharacter_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_setSynchronizeAllMotionStates_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDiscreteDynamicsWorld_getSynchronizeAllMotionStates_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_setApplySpeculativeContactRestitution_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDiscreteDynamicsWorld_getApplySpeculativeContactRestitution_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_setLatencyMotionStateInterpolation_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btDiscreteDynamicsWorld_getLatencyMotionStateInterpolation_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getNonStaticRigidBodies__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getNonStaticRigidBodies__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_setInternalTickCallback__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_type_143 arg1, uintptr_t arg2, _Bool arg3); +extern void _wrap_btDiscreteDynamicsWorld_setInternalTickCallback__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_type_144 arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_setInternalTickCallback__SWIG_2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_type_145 arg1); +extern void _wrap_btDiscreteDynamicsWorld_setWorldUserInfo_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getWorldUserInfo_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getSolverInfo__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getSolverInfo__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDiscreteDynamicsWorld_setBroadphase_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getBroadphase__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getBroadphase__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getPairCache_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getDispatcher__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getDispatcher__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDiscreteDynamicsWorld_updateSingleAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btDiscreteDynamicsWorld_updateAabbs_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDiscreteDynamicsWorld_computeOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDiscreteDynamicsWorld_setDebugDrawer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getDebugDrawer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDiscreteDynamicsWorld_debugDrawObject_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btDiscreteDynamicsWorld_getNumCollisionObjects_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDiscreteDynamicsWorld_rayTest_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDiscreteDynamicsWorld_convexSweepTest__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5); +extern void _wrap_btDiscreteDynamicsWorld_convexSweepTest__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDiscreteDynamicsWorld_contactTest_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btDiscreteDynamicsWorld_contactPairTest_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btDiscreteDynamicsWorld_rayTestSingle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btDiscreteDynamicsWorld_rayTestSingleInternal_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btDiscreteDynamicsWorld_objectQuerySingle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, float arg8); +extern void _wrap_btDiscreteDynamicsWorld_objectQuerySingleInternal_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, float arg6); +extern void _wrap_btDiscreteDynamicsWorld_refreshBroadphaseProxy_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getCollisionObjectArray__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getCollisionObjectArray__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDiscreteDynamicsWorld_performDiscreteCollisionDetection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getDispatchInfo__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btDiscreteDynamicsWorld_getDispatchInfo__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btDiscreteDynamicsWorld_getForceUpdateAllAabbs_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btDiscreteDynamicsWorld_setForceUpdateAllAabbs_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern void _wrap_btElement_m_id_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btElement_m_id_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btElement_m_sz_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btElement_m_sz_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btElement_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btElement_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btUnionFind_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btUnionFind_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btUnionFind_sortIslands_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btUnionFind_reset_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btUnionFind_getNumElements_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btUnionFind_isRoot_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btUnionFind_getElement__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btUnionFind_getElement__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btUnionFind_allocate_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btUnionFind_Free_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btUnionFind_find__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern void _wrap_btUnionFind_unite_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern swig_intgo _wrap_btUnionFind_find__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_new_btSimulationIslandManager_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btSimulationIslandManager_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSimulationIslandManager_initUnionFind_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btSimulationIslandManager_getUnionFind_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSimulationIslandManager_updateActivationState_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSimulationIslandManager_storeIslandActivationState_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btSimulationIslandManager_findUnions_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSimulationIslandManager_buildAndProcessIslands_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btSimulationIslandManager_buildIslands_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btSimulationIslandManager_processIslands_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern _Bool _wrap_btSimulationIslandManager_getSplitIslands_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSimulationIslandManager_setSplitIslands_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern swig_intgo _wrap_BT_SEQUENTIAL_IMPULSE_SOLVER_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_MLCP_SOLVER_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_NNCG_SOLVER_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_MULTIBODY_SOLVER_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_BLOCK_SOLVER_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btConstraintSolver_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConstraintSolver_prepareSolve_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern float _wrap_btConstraintSolver_solveGroup_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, uintptr_t arg4, swig_intgo arg5, uintptr_t arg6, swig_intgo arg7, uintptr_t arg8, uintptr_t arg9, uintptr_t arg10); +extern void _wrap_btConstraintSolver_allSolved_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btConstraintSolver_reset_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btConstraintSolver_getSolverType_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btSolverAnalyticsData_mbt_e879218550ba2e2b(void); +extern void _wrap_btSolverAnalyticsData_m_islandId_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSolverAnalyticsData_m_islandId_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverAnalyticsData_m_numBodies_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSolverAnalyticsData_m_numBodies_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverAnalyticsData_m_numContactManifolds_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSolverAnalyticsData_m_numContactManifolds_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverAnalyticsData_m_numSolverCalls_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSolverAnalyticsData_m_numSolverCalls_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverAnalyticsData_m_numIterationsUsed_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSolverAnalyticsData_m_numIterationsUsed_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSolverAnalyticsData_m_remainingLeastSquaresResidual_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btSolverAnalyticsData_m_remainingLeastSquaresResidual_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btSolverAnalyticsData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btSequentialImpulseConstraintSolver_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btSequentialImpulseConstraintSolver_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btSequentialImpulseConstraintSolver_solveGroup_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, uintptr_t arg4, swig_intgo arg5, uintptr_t arg6, swig_intgo arg7, uintptr_t arg8, uintptr_t arg9, uintptr_t arg10); +extern void _wrap_btSequentialImpulseConstraintSolver_reset_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_146 _wrap_btSequentialImpulseConstraintSolver_btRand2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btSequentialImpulseConstraintSolver_btRandInt2_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btSequentialImpulseConstraintSolver_setRandSeed_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_147 arg2); +extern swig_type_148 _wrap_btSequentialImpulseConstraintSolver_getRandSeed_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btSequentialImpulseConstraintSolver_getSolverType_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_149 _wrap_btSequentialImpulseConstraintSolver_getActiveConstraintRowSolverGeneric_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSequentialImpulseConstraintSolver_setConstraintRowSolverGeneric_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_150 arg2); +extern swig_type_151 _wrap_btSequentialImpulseConstraintSolver_getActiveConstraintRowSolverLowerLimit_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSequentialImpulseConstraintSolver_setConstraintRowSolverLowerLimit_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_152 arg2); +extern swig_type_153 _wrap_btSequentialImpulseConstraintSolver_getScalarConstraintRowSolverGeneric_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_154 _wrap_btSequentialImpulseConstraintSolver_getScalarConstraintRowSolverLowerLimit_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSequentialImpulseConstraintSolver_m_analyticsData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSequentialImpulseConstraintSolver_m_analyticsData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSequentialImpulseConstraintSolver_prepareSolve_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, swig_intgo arg2); +extern void _wrap_btSequentialImpulseConstraintSolver_allSolved_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_BT_CONETWIST_FLAGS_LIN_CFM_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONETWIST_FLAGS_LIN_ERP_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_CONETWIST_FLAGS_ANG_CFM_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btConeTwistConstraint__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_new_btConeTwistConstraint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConeTwistConstraint_buildJacobian_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraint_getInfo1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConeTwistConstraint_getInfo1NonVirtual_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConeTwistConstraint_getInfo2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConeTwistConstraint_getInfo2NonVirtual_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btConeTwistConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern void _wrap_btConeTwistConstraint_updateRHS_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern uintptr_t _wrap_btConeTwistConstraint_getRigidBodyA_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btConeTwistConstraint_getRigidBodyB_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraint_setAngularOnly_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btConeTwistConstraint_getAngularOnly_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraint_setLimit__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3); +extern float _wrap_btConeTwistConstraint_getLimit_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btConeTwistConstraint_setLimit__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4, float arg5, float arg6, float arg7); +extern void _wrap_btConeTwistConstraint_setLimit__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4, float arg5, float arg6); +extern void _wrap_btConeTwistConstraint_setLimit__SWIG_3_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4, float arg5); +extern void _wrap_btConeTwistConstraint_setLimit__SWIG_4_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, float arg4); +extern uintptr_t _wrap_btConeTwistConstraint_getAFrame_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btConeTwistConstraint_getBFrame_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btConeTwistConstraint_getSolveTwistLimit_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btConeTwistConstraint_getSolveSwingLimit_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConeTwistConstraint_getTwistLimitSign_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraint_calcAngleInfo_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraint_calcAngleInfo2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btConeTwistConstraint_getSwingSpan1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConeTwistConstraint_getSwingSpan2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConeTwistConstraint_getTwistSpan_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConeTwistConstraint_getLimitSoftness_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConeTwistConstraint_getBiasFactor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConeTwistConstraint_getRelaxationFactor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConeTwistConstraint_getTwistAngle_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btConeTwistConstraint_isPastSwingLimit_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConeTwistConstraint_getDamping_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraint_setDamping_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btConeTwistConstraint_enableMotor_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btConeTwistConstraint_isMotorEnabled_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConeTwistConstraint_getMaxMotorImpulse_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btConeTwistConstraint_isMaxMotorImpulseNormalized_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraint_setMaxMotorImpulse_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btConeTwistConstraint_setMaxMotorImpulseNormalized_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConeTwistConstraint_getFixThresh_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraint_setFixThresh_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_btConeTwistConstraint_setMotorTarget_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConeTwistConstraint_getMotorTarget_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraint_setMotorTargetInConstraintSpace_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConeTwistConstraint_GetPointForAngle_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3); +extern void _wrap_btConeTwistConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3, swig_intgo arg4); +extern void _wrap_btConeTwistConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3); +extern void _wrap_btConeTwistConstraint_setFrames_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btConeTwistConstraint_getFrameOffsetA_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btConeTwistConstraint_getFrameOffsetB_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btConeTwistConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern float _wrap_btConeTwistConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btConeTwistConstraint_getFlags_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btConeTwistConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_155 _wrap_btConeTwistConstraint_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_delete_btConeTwistConstraint_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btConeTwistConstraint_getFixedBody_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btConeTwistConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConeTwistConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btConeTwistConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, float arg4); +extern void _wrap_btConeTwistConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btConeTwistConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btConeTwistConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConeTwistConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern _Bool _wrap_btConeTwistConstraint_isEnabled_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConeTwistConstraint_setEnabled_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern swig_intgo _wrap_btConeTwistConstraint_getUserConstraintType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConeTwistConstraint_setUserConstraintType_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btConeTwistConstraint_setUserConstraintId_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btConeTwistConstraint_getUserConstraintId_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConeTwistConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConeTwistConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConeTwistConstraint_setJointFeedback_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btConeTwistConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btConeTwistConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btConeTwistConstraint_getUid_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btConeTwistConstraint_needsFeedback_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConeTwistConstraint_enableFeedback_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern float _wrap_btConeTwistConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btConeTwistConstraint_getConstraintType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConeTwistConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btConeTwistConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtConeTwistConstraint_M_objectType_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtConeTwistConstraint_M_objectType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btConeTwistConstraint_getObjectType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btConeTwistConstraintDoubleData_m_typeConstraintData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConeTwistConstraintDoubleData_m_typeConstraintData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintDoubleData_m_rbAFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConeTwistConstraintDoubleData_m_rbAFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintDoubleData_m_rbBFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConeTwistConstraintDoubleData_m_rbBFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintDoubleData_m_swingSpan1_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btConeTwistConstraintDoubleData_m_swingSpan1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintDoubleData_m_swingSpan2_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btConeTwistConstraintDoubleData_m_swingSpan2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintDoubleData_m_twistSpan_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btConeTwistConstraintDoubleData_m_twistSpan_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintDoubleData_m_limitSoftness_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btConeTwistConstraintDoubleData_m_limitSoftness_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintDoubleData_m_biasFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btConeTwistConstraintDoubleData_m_biasFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintDoubleData_m_relaxationFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btConeTwistConstraintDoubleData_m_relaxationFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintDoubleData_m_damping_set_mbt_e879218550ba2e2b(uintptr_t arg1, double arg2); +extern double _wrap_btConeTwistConstraintDoubleData_m_damping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btConeTwistConstraintDoubleData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btConeTwistConstraintDoubleData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_typeConstraintData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConeTwistConstraintData_m_typeConstraintData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_rbAFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConeTwistConstraintData_m_rbAFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_rbBFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConeTwistConstraintData_m_rbBFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_swingSpan1_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConeTwistConstraintData_m_swingSpan1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_swingSpan2_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConeTwistConstraintData_m_swingSpan2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_twistSpan_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConeTwistConstraintData_m_twistSpan_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_limitSoftness_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConeTwistConstraintData_m_limitSoftness_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_biasFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConeTwistConstraintData_m_biasFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_relaxationFactor_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConeTwistConstraintData_m_relaxationFactor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_damping_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btConeTwistConstraintData_m_damping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConeTwistConstraintData_m_pad_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_156 arg2); +extern swig_type_157 _wrap_btConeTwistConstraintData_m_pad_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btConeTwistConstraintData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btConeTwistConstraintData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_loLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_loLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_hiLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_hiLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_targetVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_targetVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_maxMotorForce_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_maxMotorForce_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_maxLimitForce_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_maxLimitForce_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_damping_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_damping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_limitSoftness_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_limitSoftness_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_normalCFM_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_normalCFM_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_stopERP_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_stopERP_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_stopCFM_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_stopCFM_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_bounce_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_bounce_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_enableMotor_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btRotationalLimitMotor_m_enableMotor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_currentLimitError_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_currentLimitError_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_currentPosition_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_currentPosition_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_currentLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btRotationalLimitMotor_m_currentLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btRotationalLimitMotor_m_accumulatedImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_m_accumulatedImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btRotationalLimitMotor__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btRotationalLimitMotor__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btRotationalLimitMotor_isLimited_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btRotationalLimitMotor_needApplyTorques_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btRotationalLimitMotor_testLimitValue_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btRotationalLimitMotor_solveAngularLimits_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_delete_btRotationalLimitMotor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_lowerLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTranslationalLimitMotor_m_lowerLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_upperLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTranslationalLimitMotor_m_upperLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_accumulatedImpulse_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTranslationalLimitMotor_m_accumulatedImpulse_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_limitSoftness_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTranslationalLimitMotor_m_limitSoftness_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_damping_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTranslationalLimitMotor_m_damping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_restitution_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btTranslationalLimitMotor_m_restitution_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_normalCFM_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTranslationalLimitMotor_m_normalCFM_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_stopERP_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTranslationalLimitMotor_m_stopERP_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_stopCFM_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTranslationalLimitMotor_m_stopCFM_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_enableMotor_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btTranslationalLimitMotor_m_enableMotor_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_targetVelocity_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTranslationalLimitMotor_m_targetVelocity_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_maxMotorForce_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTranslationalLimitMotor_m_maxMotorForce_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_currentLimitError_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTranslationalLimitMotor_m_currentLimitError_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_currentLinearDiff_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btTranslationalLimitMotor_m_currentLinearDiff_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btTranslationalLimitMotor_m_currentLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btTranslationalLimitMotor_m_currentLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btTranslationalLimitMotor__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btTranslationalLimitMotor__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btTranslationalLimitMotor_isLimited_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern _Bool _wrap_btTranslationalLimitMotor_needApplyForce_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btTranslationalLimitMotor_testLimitValue_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3); +extern float _wrap_btTranslationalLimitMotor_solveLinearAxis_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, swig_intgo arg8, uintptr_t arg9, uintptr_t arg10); +extern void _wrap_delete_btTranslationalLimitMotor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_BT_6DOF_FLAGS_CFM_NORM_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_6DOF_FLAGS_CFM_STOP_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_BT_6DOF_FLAGS_ERP_STOP_mbt_e879218550ba2e2b(void); +extern void _wrap_btGeneric6DofConstraint_m_useSolveConstraintObsolete_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btGeneric6DofConstraint_m_useSolveConstraintObsolete_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btGeneric6DofConstraint__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5); +extern uintptr_t _wrap_new_btGeneric6DofConstraint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, _Bool arg3); +extern void _wrap_btGeneric6DofConstraint_calculateTransforms__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btGeneric6DofConstraint_calculateTransforms__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofConstraint_getCalculatedTransformA_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofConstraint_getCalculatedTransformB_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofConstraint_getFrameOffsetA__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofConstraint_getFrameOffsetB__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofConstraint_getFrameOffsetA__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofConstraint_getFrameOffsetB__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraint_buildJacobian_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraint_getInfo1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofConstraint_getInfo1NonVirtual_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofConstraint_getInfo2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofConstraint_getInfo2NonVirtual_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, uintptr_t arg8); +extern void _wrap_btGeneric6DofConstraint_updateRHS_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern uintptr_t _wrap_btGeneric6DofConstraint_getAxis_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern float _wrap_btGeneric6DofConstraint_getAngle_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern float _wrap_btGeneric6DofConstraint_getRelativePivotPosition_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btGeneric6DofConstraint_setFrames_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_btGeneric6DofConstraint_testAngularLimitMotor_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btGeneric6DofConstraint_setLinearLowerLimit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofConstraint_getLinearLowerLimit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofConstraint_setLinearUpperLimit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofConstraint_getLinearUpperLimit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofConstraint_setAngularLowerLimit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofConstraint_getAngularLowerLimit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofConstraint_setAngularUpperLimit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofConstraint_getAngularUpperLimit_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraint_getRotationalLimitMotor_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btGeneric6DofConstraint_getTranslationalLimitMotor_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraint_setLimit_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3, float arg4); +extern _Bool _wrap_btGeneric6DofConstraint_isLimited_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btGeneric6DofConstraint_calcAnchorPos_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btGeneric6DofConstraint_get_limit_motor_info2__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, uintptr_t arg8, uintptr_t arg9, swig_intgo arg10, uintptr_t arg11, swig_intgo arg12, swig_intgo arg13); +extern swig_intgo _wrap_btGeneric6DofConstraint_get_limit_motor_info2__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, uintptr_t arg8, uintptr_t arg9, swig_intgo arg10, uintptr_t arg11, swig_intgo arg12); +extern _Bool _wrap_btGeneric6DofConstraint_getUseFrameOffset_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraint_setUseFrameOffset_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btGeneric6DofConstraint_getUseLinearReferenceFrameA_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraint_setUseLinearReferenceFrameA_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern void _wrap_btGeneric6DofConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3, swig_intgo arg4); +extern void _wrap_btGeneric6DofConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3); +extern float _wrap_btGeneric6DofConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern float _wrap_btGeneric6DofConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btGeneric6DofConstraint_setAxis_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern swig_intgo _wrap_btGeneric6DofConstraint_getFlags_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btGeneric6DofConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_158 _wrap_btGeneric6DofConstraint_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_delete_btGeneric6DofConstraint_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofConstraint_getFixedBody_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btGeneric6DofConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btGeneric6DofConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, float arg4); +extern void _wrap_btGeneric6DofConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btGeneric6DofConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btGeneric6DofConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern _Bool _wrap_btGeneric6DofConstraint_isEnabled_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofConstraint_setEnabled_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern void _wrap_btGeneric6DofConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, float arg3); +extern uintptr_t _wrap_btGeneric6DofConstraint_getRigidBodyA__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofConstraint_getRigidBodyA__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofConstraint_getRigidBodyB__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofConstraint_getRigidBodyB__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btGeneric6DofConstraint_getUserConstraintType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofConstraint_setUserConstraintType_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btGeneric6DofConstraint_setUserConstraintId_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btGeneric6DofConstraint_getUserConstraintId_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofConstraint_setJointFeedback_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btGeneric6DofConstraint_getUid_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btGeneric6DofConstraint_needsFeedback_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofConstraint_enableFeedback_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern float _wrap_btGeneric6DofConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btGeneric6DofConstraint_getConstraintType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btGeneric6DofConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtGeneric6DofConstraint_M_objectType_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtGeneric6DofConstraint_M_objectType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btGeneric6DofConstraint_getObjectType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofConstraintData_m_typeConstraintData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintData_m_typeConstraintData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintData_m_rbAFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintData_m_rbAFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintData_m_rbBFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintData_m_rbBFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintData_m_linearUpperLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintData_m_linearUpperLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintData_m_linearLowerLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintData_m_linearLowerLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintData_m_angularUpperLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintData_m_angularUpperLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintData_m_angularLowerLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintData_m_angularLowerLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintData_m_useLinearReferenceFrameA_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btGeneric6DofConstraintData_m_useLinearReferenceFrameA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintData_m_useOffsetForConstraintFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btGeneric6DofConstraintData_m_useOffsetForConstraintFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btGeneric6DofConstraintData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btGeneric6DofConstraintData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintDoubleData2_m_typeConstraintData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintDoubleData2_m_typeConstraintData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintDoubleData2_m_rbAFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintDoubleData2_m_rbAFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintDoubleData2_m_rbBFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintDoubleData2_m_rbBFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintDoubleData2_m_linearUpperLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintDoubleData2_m_linearUpperLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintDoubleData2_m_linearLowerLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintDoubleData2_m_linearLowerLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintDoubleData2_m_angularUpperLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintDoubleData2_m_angularUpperLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintDoubleData2_m_angularLowerLimit_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofConstraintDoubleData2_m_angularLowerLimit_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintDoubleData2_m_useLinearReferenceFrameA_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btGeneric6DofConstraintDoubleData2_m_useLinearReferenceFrameA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofConstraintDoubleData2_m_useOffsetForConstraintFrame_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btGeneric6DofConstraintDoubleData2_m_useOffsetForConstraintFrame_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btGeneric6DofConstraintDoubleData2_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btGeneric6DofConstraintDoubleData2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btGetConstraintIslandId_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btSortConstraintOnIslandPredicate_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btSortConstraintOnIslandPredicate_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_InplaceSolverIslandCallback_m_solverInfo_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_InplaceSolverIslandCallback_m_solverInfo_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_InplaceSolverIslandCallback_m_solver_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_InplaceSolverIslandCallback_m_solver_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_InplaceSolverIslandCallback_m_sortedConstraints_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_InplaceSolverIslandCallback_m_sortedConstraints_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_InplaceSolverIslandCallback_m_numConstraints_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_InplaceSolverIslandCallback_m_numConstraints_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_InplaceSolverIslandCallback_m_debugDrawer_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_InplaceSolverIslandCallback_m_debugDrawer_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_InplaceSolverIslandCallback_m_dispatcher_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_InplaceSolverIslandCallback_m_dispatcher_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_InplaceSolverIslandCallback_m_bodies_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_InplaceSolverIslandCallback_m_bodies_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_InplaceSolverIslandCallback_m_manifolds_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_InplaceSolverIslandCallback_m_manifolds_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_InplaceSolverIslandCallback_m_constraints_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_InplaceSolverIslandCallback_m_constraints_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_InplaceSolverIslandCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_InplaceSolverIslandCallback_setup_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_intgo arg4, uintptr_t arg5); +extern void _wrap_InplaceSolverIslandCallback_processIsland_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, uintptr_t arg4, swig_intgo arg5, swig_intgo arg6); +extern void _wrap_InplaceSolverIslandCallback_processConstraints_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_InplaceSolverIslandCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btClosestNotMeConvexResultCallback_m_me_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btClosestNotMeConvexResultCallback_m_me_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btClosestNotMeConvexResultCallback_m_allowedPenetration_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btClosestNotMeConvexResultCallback_m_allowedPenetration_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btClosestNotMeConvexResultCallback_m_pairCache_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btClosestNotMeConvexResultCallback_m_pairCache_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btClosestNotMeConvexResultCallback_m_dispatcher_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btClosestNotMeConvexResultCallback_m_dispatcher_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btClosestNotMeConvexResultCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btClosestNotMeConvexResultCallback_addSingleResult_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, _Bool arg3); +extern _Bool _wrap_btClosestNotMeConvexResultCallback_needsCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btClosestNotMeConvexResultCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_gNumClampedCcdMotions_set_mbt_e879218550ba2e2b(swig_intgo arg1); +extern swig_intgo _wrap_gNumClampedCcdMotions_get_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btUnionFindElementSortPredicate_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btUnionFindElementSortPredicate_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_getIslandId_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btPersistentManifoldSortPredicate_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btPersistentManifoldSortPredicate_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btPersistentManifoldSortPredicateDeterministic_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btPersistentManifoldSortPredicateDeterministic_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGjkPairDetector_m_lastUsedMethod_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btGjkPairDetector_m_lastUsedMethod_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGjkPairDetector_m_curIter_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btGjkPairDetector_m_curIter_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGjkPairDetector_m_degenerateSimplex_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btGjkPairDetector_m_degenerateSimplex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGjkPairDetector_m_catchDegeneracies_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btGjkPairDetector_m_catchDegeneracies_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGjkPairDetector_m_fixContactNormalDirection_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btGjkPairDetector_m_fixContactNormalDirection_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btGjkPairDetector__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_new_btGjkPairDetector__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4, float arg5, float arg6, uintptr_t arg7, uintptr_t arg8); +extern void _wrap_delete_btGjkPairDetector_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGjkPairDetector_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5); +extern void _wrap_btGjkPairDetector_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btGjkPairDetector_getClosestPointsNonVirtual_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btGjkPairDetector_setMinkowskiA_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGjkPairDetector_setMinkowskiB_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGjkPairDetector_setCachedSeparatingAxis_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGjkPairDetector_getCachedSeparatingAxis_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btGjkPairDetector_getCachedSeparatingDistance_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGjkPairDetector_setPenetrationDepthSolver_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGjkPairDetector_setIgnoreMargin_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern void _wrap_SupportVertexCallback_m_worldTrans_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_SupportVertexCallback_m_worldTrans_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SupportVertexCallback_m_maxDot_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_SupportVertexCallback_m_maxDot_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SupportVertexCallback_m_supportVecLocal_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_SupportVertexCallback_m_supportVecLocal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_SupportVertexCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_SupportVertexCallback_processTriangle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern uintptr_t _wrap_SupportVertexCallback_GetSupportVertexWorldSpace_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_SupportVertexCallback_GetSupportVertexLocal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_SupportVertexCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_getQuantized_mbt_e879218550ba2e2b(float arg1); +extern uintptr_t _wrap_minmaxRange_mbt_e879218550ba2e2b(float arg1, float arg2, float arg3); +extern void _wrap_ProcessTrianglesAction_shape_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_ProcessTrianglesAction_shape_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessTrianglesAction_flipQuadEdges_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_ProcessTrianglesAction_flipQuadEdges_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessTrianglesAction_useDiamondSubdivision_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_ProcessTrianglesAction_useDiamondSubdivision_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessTrianglesAction_width_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_ProcessTrianglesAction_width_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessTrianglesAction_length_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_ProcessTrianglesAction_length_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessTrianglesAction_callback_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_ProcessTrianglesAction_callback_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessTrianglesAction_exec_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern uintptr_t _wrap_new_ProcessTrianglesAction_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_ProcessTrianglesAction_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_ProcessVBoundsAction_vbounds_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessVBoundsAction_width_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_ProcessVBoundsAction_width_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessVBoundsAction_length_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_ProcessVBoundsAction_length_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessVBoundsAction_chunkSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_ProcessVBoundsAction_chunkSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessVBoundsAction_rayBegin_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_ProcessVBoundsAction_rayBegin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessVBoundsAction_rayEnd_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_ProcessVBoundsAction_rayEnd_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessVBoundsAction_rayDir_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_ProcessVBoundsAction_rayDir_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessVBoundsAction_m_indices_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_ProcessVBoundsAction_m_indices_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_ProcessVBoundsAction_processTriangles_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_ProcessVBoundsAction_processTriangles_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_ProcessVBoundsAction_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern void _wrap_delete_ProcessVBoundsAction_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btGjkEpaSolver2_StackSizeRequirement_mbt_e879218550ba2e2b(void); +extern _Bool _wrap_btGjkEpaSolver2_Distance_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btGjkEpaSolver2_Penetration__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, _Bool arg7); +extern _Bool _wrap_btGjkEpaSolver2_Penetration__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern float _wrap_btGjkEpaSolver2_SignedDistance__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern _Bool _wrap_btGjkEpaSolver2_SignedDistance__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern uintptr_t _wrap_new_btGjkEpaSolver2_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btGjkEpaSolver2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_EPA_MAX_FACES_mbt_e879218550ba2e2b(void); +extern void _wrap_MinkowskiDiff_m_shapes_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_MinkowskiDiff_m_shapes_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_MinkowskiDiff_m_toshape1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_MinkowskiDiff_m_toshape1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_MinkowskiDiff_m_toshape0_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_MinkowskiDiff_m_toshape0_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_MinkowskiDiff_Ls_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_159 arg2); +extern swig_type_160 _wrap_MinkowskiDiff_Ls_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_MinkowskiDiff_mbt_e879218550ba2e2b(void); +extern void _wrap_MinkowskiDiff_EnableMargin_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern uintptr_t _wrap_MinkowskiDiff_Support0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_MinkowskiDiff_Support1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_MinkowskiDiff_Support__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_MinkowskiDiff_Support__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3); +extern void _wrap_delete_MinkowskiDiff_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_m_shape_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_GJK_m_shape_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_m_ray_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_GJK_m_ray_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_m_distance_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_GJK_m_distance_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_m_simplices_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_GJK_m_simplices_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_m_store_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_GJK_m_store_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_m_free_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_GJK_m_free_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_m_nfree_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_GJK_m_nfree_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_m_current_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_GJK_m_current_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_m_simplex_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_GJK_m_simplex_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_m_status_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_GJK_m_status_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_GJK_mbt_e879218550ba2e2b(void); +extern void _wrap_GJK_Initialize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_GJK_Evaluate_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_GJK_EncloseOrigin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_GJK_getsupport_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_GJK_removevertice_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_GJK_appendvertice_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern float _wrap_GJK_det_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern float _wrap_GJK_projectorigin__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, swig_voidp arg4); +extern float _wrap_GJK_projectorigin__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, swig_voidp arg4, swig_voidp arg5); +extern float _wrap_GJK_projectorigin__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, swig_voidp arg5, swig_voidp arg6); +extern void _wrap_delete_GJK_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_EPA_m_status_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_EPA_m_status_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_EPA_m_result_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_EPA_m_result_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_EPA_m_normal_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_EPA_m_normal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_EPA_m_depth_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_EPA_m_depth_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_EPA_m_sv_store_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_EPA_m_sv_store_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_EPA_m_fc_store_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_EPA_m_fc_store_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_EPA_m_nextsv_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_EPA_m_nextsv_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_EPA_m_hull_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_EPA_m_hull_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_EPA_m_stock_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_EPA_m_stock_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_EPA_mbt_e879218550ba2e2b(void); +extern void _wrap_EPA_bind_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3, swig_intgo arg4); +extern void _wrap_EPA_append_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_EPA_remove_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_EPA_Initialize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_EPA_Evaluate_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern _Bool _wrap_EPA_getedgedist_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, swig_voidp arg5); +extern uintptr_t _wrap_EPA_newface_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5); +extern uintptr_t _wrap_EPA_findbest_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_EPA_expand_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, uintptr_t arg3, uintptr_t arg4, swig_intgo arg5, uintptr_t arg6); +extern void _wrap_delete_EPA_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_Initialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, _Bool arg7); +extern void _wrap_delete_btCollisionConfiguration_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionConfiguration_getPersistentManifoldPool_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionConfiguration_getCollisionAlgorithmPool_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCollisionConfiguration_getCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern uintptr_t _wrap_btCollisionConfiguration_getClosestPointsAlgorithmCreateFunc_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern void _wrap_btDefaultCollisionConstructionInfo_m_persistentManifoldPool_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDefaultCollisionConstructionInfo_m_persistentManifoldPool_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultCollisionConstructionInfo_m_collisionAlgorithmPool_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btDefaultCollisionConstructionInfo_m_collisionAlgorithmPool_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultCollisionConstructionInfo_m_defaultMaxPersistentManifoldPoolSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDefaultCollisionConstructionInfo_m_defaultMaxPersistentManifoldPoolSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultCollisionConstructionInfo_m_defaultMaxCollisionAlgorithmPoolSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDefaultCollisionConstructionInfo_m_defaultMaxCollisionAlgorithmPoolSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultCollisionConstructionInfo_m_customCollisionAlgorithmMaxElementSize_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDefaultCollisionConstructionInfo_m_customCollisionAlgorithmMaxElementSize_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultCollisionConstructionInfo_m_useEpaPenetrationAlgorithm_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btDefaultCollisionConstructionInfo_m_useEpaPenetrationAlgorithm_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDefaultCollisionConstructionInfo_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDefaultCollisionConstructionInfo_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDefaultCollisionConfiguration__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btDefaultCollisionConfiguration__SWIG_1_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btDefaultCollisionConfiguration_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDefaultCollisionConfiguration_getPersistentManifoldPool_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDefaultCollisionConfiguration_getCollisionAlgorithmPool_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btDefaultCollisionConfiguration_getCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern uintptr_t _wrap_btDefaultCollisionConfiguration_getClosestPointsAlgorithmCreateFunc_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern void _wrap_btDefaultCollisionConfiguration_setConvexConvexMultipointIterations__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern void _wrap_btDefaultCollisionConfiguration_setConvexConvexMultipointIterations__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btDefaultCollisionConfiguration_setConvexConvexMultipointIterations__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btDefaultCollisionConfiguration_setPlaneConvexMultipointIterations__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern void _wrap_btDefaultCollisionConfiguration_setPlaneConvexMultipointIterations__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btDefaultCollisionConfiguration_setPlaneConvexMultipointIterations__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btCollisionAlgorithmConstructionInfo__SWIG_0_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btCollisionAlgorithmConstructionInfo__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btCollisionAlgorithmConstructionInfo_m_dispatcher1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionAlgorithmConstructionInfo_m_dispatcher1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionAlgorithmConstructionInfo_m_manifold_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCollisionAlgorithmConstructionInfo_m_manifold_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btCollisionAlgorithmConstructionInfo_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btActivatingCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btActivatingCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern float _wrap_btActivatingCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btActivatingCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btPolyhedralContactClipping_clipHullAgainstHull_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, float arg6, float arg7, uintptr_t arg8, uintptr_t arg9, uintptr_t arg10); +extern void _wrap_btPolyhedralContactClipping_clipFaceAgainstHull_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, float arg6, float arg7, uintptr_t arg8); +extern _Bool _wrap_btPolyhedralContactClipping_findSeparatingAxis_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btPolyhedralContactClipping_clipFace_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4); +extern uintptr_t _wrap_new_btPolyhedralContactClipping_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btPolyhedralContactClipping_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btConvexConvexAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, swig_intgo arg6, swig_intgo arg7); +extern void _wrap_delete_btConvexConvexAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexConvexAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btConvexConvexAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btConvexConvexAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConvexConvexAlgorithm_setLowLevelOfDetail_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern uintptr_t _wrap_btConvexConvexAlgorithm_getManifold_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btEmptyAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btEmptyAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btEmptyAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btEmptyAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btEmptyAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexTriangleCallback_m_triangleCount_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btConvexTriangleCallback_m_triangleCount_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexTriangleCallback_m_manifoldPtr_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btConvexTriangleCallback_m_manifoldPtr_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btConvexTriangleCallback_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, _Bool arg4); +extern void _wrap_btConvexTriangleCallback_setTimeStepAndCounters_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btConvexTriangleCallback_clearWrapperData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btConvexTriangleCallback_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexTriangleCallback_processTriangle_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_intgo arg3, swig_intgo arg4); +extern void _wrap_btConvexTriangleCallback_clearCache_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btConvexTriangleCallback_getAabbMin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btConvexTriangleCallback_getAabbMax_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btConvexConcaveCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, _Bool arg4); +extern void _wrap_delete_btConvexConcaveCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexConcaveCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btConvexConcaveCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btConvexConcaveCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btConvexConcaveCollisionAlgorithm_clearCache_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_gCompoundChildShapePairCallback_set_mbt_e879218550ba2e2b(swig_type_161 arg1); +extern swig_type_162 _wrap_gCompoundChildShapePairCallback_get_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, _Bool arg4); +extern void _wrap_delete_btCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btCompoundCollisionAlgorithm_getChildAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btCompoundCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btCompoundCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btCompoundCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_BT_SIMPLE_NULL_PAIR_get_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btSimplePair_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2); +extern void _wrap_btSimplePair_m_indexA_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSimplePair_m_indexA_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSimplePair_m_indexB_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btSimplePair_m_indexB_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btSimplePair_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btHashedSimplePairCache_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btHashedSimplePairCache_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btHashedSimplePairCache_removeAllPairs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHashedSimplePairCache_removeOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern uintptr_t _wrap_btHashedSimplePairCache_addOverlappingPair_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern uintptr_t _wrap_btHashedSimplePairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHashedSimplePairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHashedSimplePairCache_getOverlappingPairArray__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHashedSimplePairCache_getOverlappingPairArray__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btHashedSimplePairCache_findPair_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_intgo arg3); +extern swig_intgo _wrap_btHashedSimplePairCache_GetCount_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btHashedSimplePairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_gCompoundCompoundChildShapePairCallback_set_mbt_e879218550ba2e2b(swig_type_163 arg1); +extern swig_type_164 _wrap_gCompoundCompoundChildShapePairCallback_get_mbt_e879218550ba2e2b(void); +extern uintptr_t _wrap_new_btCompoundCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, _Bool arg4); +extern void _wrap_delete_btCompoundCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCompoundCompoundCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btCompoundCompoundCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btCompoundCompoundCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btCompoundCompoundCollisionAlgorithm_getChildAlgorithm_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern uintptr_t _wrap_new_btConvexPlaneCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5, swig_intgo arg6, swig_intgo arg7); +extern void _wrap_delete_btConvexPlaneCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btConvexPlaneCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btConvexPlaneCollisionAlgorithm_collideSingleContact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6); +extern float _wrap_btConvexPlaneCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btConvexPlaneCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btBoxBoxCollisionAlgorithm__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBoxBoxCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btBoxBoxCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern uintptr_t _wrap_new_btBoxBoxCollisionAlgorithm__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_delete_btBoxBoxCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBoxBoxCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btSphereSphereCollisionAlgorithm__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_new_btSphereSphereCollisionAlgorithm__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSphereSphereCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btSphereSphereCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btSphereSphereCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btSphereSphereCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btSphereBoxCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5); +extern void _wrap_delete_btSphereBoxCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSphereBoxCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btSphereBoxCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btSphereBoxCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btSphereBoxCollisionAlgorithm_getSphereDistance_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, swig_voidp arg5, uintptr_t arg6, float arg7, float arg8); +extern float _wrap_btSphereBoxCollisionAlgorithm_getSpherePenetration_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern uintptr_t _wrap_new_btSphereTriangleCollisionAlgorithm__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5); +extern uintptr_t _wrap_new_btSphereTriangleCollisionAlgorithm__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSphereTriangleCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern float _wrap_btSphereTriangleCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btSphereTriangleCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btSphereTriangleCollisionAlgorithm_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_delete_btConvexPenetrationDepthSolver_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btConvexPenetrationDepthSolver_calcPenDepth_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, uintptr_t arg8, uintptr_t arg9, uintptr_t arg10); +extern _Bool _wrap_btMinkowskiPenetrationDepthSolver_calcPenDepth_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, uintptr_t arg8, uintptr_t arg9, uintptr_t arg10); +extern uintptr_t _wrap_new_btMinkowskiPenetrationDepthSolver_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btMinkowskiPenetrationDepthSolver_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btPoolAllocator_mbt_e879218550ba2e2b(swig_intgo arg1, swig_intgo arg2); +extern void _wrap_delete_btPoolAllocator_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btPoolAllocator_getFreeCount_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btPoolAllocator_getUsedCount_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btPoolAllocator_getMaxCount_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btPoolAllocator_allocate_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern _Bool _wrap_btPoolAllocator_validPtr_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btPoolAllocator_freeMemory_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btPoolAllocator_getElementSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_voidp _wrap_btPoolAllocator_getPoolAddress__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_voidp _wrap_btPoolAllocator_getPoolAddress__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMultiIndex_ijk_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btMultiIndex_ijk_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btMultiIndex_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btMultiIndex_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btAlignedBox3d_m_min_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btAlignedBox3d_m_min_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btAlignedBox3d_m_max_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btAlignedBox3d_m_max_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btAlignedBox3d_min_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btAlignedBox3d_max_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btAlignedBox3d_contains_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btAlignedBox3d__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_new_btAlignedBox3d__SWIG_1_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btAlignedBox3d_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btShapeMatrix_m_vec_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btShapeMatrix_m_vec_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btShapeMatrix_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btShapeMatrix_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btShapeGradients_m_vec_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btShapeGradients_m_vec_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btShapeGradients_topRowsDivide_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, double arg3); +extern void _wrap_btShapeGradients_bottomRowsMul_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, double arg3); +extern uintptr_t _wrap_new_btShapeGradients_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btShapeGradients_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btCell32_m_cells_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btCell32_m_cells_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btCell32_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btCell32_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMiniSDF_m_domain_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMiniSDF_m_domain_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMiniSDF_m_resolution_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btMiniSDF_m_resolution_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMiniSDF_m_cell_size_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMiniSDF_m_cell_size_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMiniSDF_m_inv_cell_size_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMiniSDF_m_inv_cell_size_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMiniSDF_m_n_cells_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMiniSDF_m_n_cells_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMiniSDF_m_n_fields_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMiniSDF_m_n_fields_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMiniSDF_m_isValid_set_mbt_e879218550ba2e2b(uintptr_t arg1, _Bool arg2); +extern _Bool _wrap_btMiniSDF_m_isValid_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMiniSDF_m_nodes_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMiniSDF_m_nodes_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMiniSDF_m_cells_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMiniSDF_m_cells_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMiniSDF_m_cell_map_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMiniSDF_m_cell_map_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btMiniSDF_mbt_e879218550ba2e2b(void); +extern _Bool _wrap_btMiniSDF_load_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_165 arg2, swig_intgo arg3); +extern _Bool _wrap_btMiniSDF_isValid_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btMiniSDF_multiToSingleIndex_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMiniSDF_subdomain__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMiniSDF_singleToMultiIndex_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btMiniSDF_subdomain__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern uintptr_t _wrap_btMiniSDF_shape_function___SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern uintptr_t _wrap_btMiniSDF_shape_function___SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btMiniSDF_interpolate_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, swig_voidp arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_delete_btMiniSDF_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBoxBoxDetector_m_box1_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBoxBoxDetector_m_box1_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBoxBoxDetector_m_box2_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btBoxBoxDetector_m_box2_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btBoxBoxDetector_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_delete_btBoxBoxDetector_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btBoxBoxDetector_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5); +extern void _wrap_btBoxBoxDetector_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern float _wrap_dDOT_mbt_e879218550ba2e2b(swig_voidp arg1, swig_voidp arg2); +extern float _wrap_dDOT44_mbt_e879218550ba2e2b(swig_voidp arg1, swig_voidp arg2); +extern float _wrap_dDOT41_mbt_e879218550ba2e2b(swig_voidp arg1, swig_voidp arg2); +extern float _wrap_dDOT14_mbt_e879218550ba2e2b(swig_voidp arg1, swig_voidp arg2); +extern void _wrap_dLineClosestApproach_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, swig_voidp arg5, swig_voidp arg6); +extern swig_intgo _wrap_intersectRectQuad2_mbt_e879218550ba2e2b(swig_voidp arg1, swig_voidp arg2, swig_voidp arg3); +extern void _wrap_cullPoints2_mbt_e879218550ba2e2b(swig_intgo arg1, swig_voidp arg2, swig_intgo arg3, swig_intgo arg4, swig_voidp arg5); +extern swig_intgo _wrap_dBoxBox2_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2, uintptr_t arg3, uintptr_t arg4, swig_voidp arg5, uintptr_t arg6, uintptr_t arg7, swig_voidp arg8, swig_voidp arg9, swig_intgo arg10, uintptr_t arg11, swig_intgo arg12, uintptr_t arg13); +extern uintptr_t _wrap_new_btSdfCollisionShape_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btSdfCollisionShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_btSdfCollisionShape_initializeSDF_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_166 arg2, swig_intgo arg3); +extern void _wrap_btSdfCollisionShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btSdfCollisionShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSdfCollisionShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSdfCollisionShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern swig_type_167 _wrap_btSdfCollisionShape_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSdfCollisionShape_setMargin_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSdfCollisionShape_getMargin_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSdfCollisionShape_processAllTriangles_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern _Bool _wrap_btSdfCollisionShape_queryPoint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_voidp arg3, uintptr_t arg4); +extern void _wrap_btSdfCollisionShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btSdfCollisionShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btSdfCollisionShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btSdfCollisionShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btSdfCollisionShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSdfCollisionShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSdfCollisionShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSdfCollisionShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSdfCollisionShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSdfCollisionShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSdfCollisionShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btSdfCollisionShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btSdfCollisionShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btSdfCollisionShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSdfCollisionShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btSdfCollisionShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSdfCollisionShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btSdfCollisionShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btSdfCollisionShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btSdfCollisionShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btSdfCollisionShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_type_168 _wrap_btSdfCollisionShape_serialize_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btSdfCollisionShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btSdfCollisionShapeInternalData_m_localScaling_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSdfCollisionShapeInternalData_m_localScaling_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSdfCollisionShapeInternalData_m_margin_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btSdfCollisionShapeInternalData_m_margin_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btSdfCollisionShapeInternalData_m_sdf_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btSdfCollisionShapeInternalData_m_sdf_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btSdfCollisionShapeInternalData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btSdfCollisionShapeInternalData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SphereTriangleDetector_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5); +extern void _wrap_SphereTriangleDetector_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_new_SphereTriangleDetector_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern void _wrap_delete_SphereTriangleDetector_mbt_e879218550ba2e2b(uintptr_t arg1); +extern _Bool _wrap_SphereTriangleDetector_collide_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, swig_voidp arg5, swig_voidp arg6, float arg7); +extern float _wrap_SegmentSqrDistance_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_new_btStaticPlaneShape_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern void _wrap_delete_btStaticPlaneShape_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStaticPlaneShape_getAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btStaticPlaneShape_processAllTriangles_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btStaticPlaneShape_calculateLocalInertia_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3); +extern void _wrap_btStaticPlaneShape_setLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btStaticPlaneShape_getLocalScaling_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btStaticPlaneShape_getPlaneNormal_mbt_e879218550ba2e2b(uintptr_t arg1); +extern float _wrap_btStaticPlaneShape_getPlaneConstant_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_169 _wrap_btStaticPlaneShape_getName_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_intgo _wrap_btStaticPlaneShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_170 _wrap_btStaticPlaneShape_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern float _wrap_btStaticPlaneShape_getMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btStaticPlaneShape_setMargin_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btStaticPlaneShape_getBoundingSphere_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_voidp arg2); +extern float _wrap_btStaticPlaneShape_getAngularMotionDisc_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btStaticPlaneShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern void _wrap_btStaticPlaneShape_calculateTemporalAabb_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, uintptr_t arg5, uintptr_t arg6); +extern _Bool _wrap_btStaticPlaneShape_isPolyhedral_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btStaticPlaneShape_isConvex2d_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btStaticPlaneShape_isConvex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btStaticPlaneShape_isNonMoving_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btStaticPlaneShape_isConcave_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btStaticPlaneShape_isCompound_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btStaticPlaneShape_isSoftBody_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btStaticPlaneShape_isInfinite_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btStaticPlaneShape_getShapeType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btStaticPlaneShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btStaticPlaneShape_setUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btStaticPlaneShape_getUserPointer_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btStaticPlaneShape_setUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btStaticPlaneShape_getUserIndex_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btStaticPlaneShape_setUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btStaticPlaneShape_getUserIndex2_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btStaticPlaneShape_serializeSingleShape_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btStaticPlaneShapeData_m_collisionShapeData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btStaticPlaneShapeData_m_collisionShapeData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStaticPlaneShapeData_m_localScaling_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btStaticPlaneShapeData_m_localScaling_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStaticPlaneShapeData_m_planeNormal_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btStaticPlaneShapeData_m_planeNormal_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStaticPlaneShapeData_m_planeConstant_set_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2); +extern float _wrap_btStaticPlaneShapeData_m_planeConstant_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btStaticPlaneShapeData_m_pad_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_171 arg2); +extern swig_type_172 _wrap_btStaticPlaneShapeData_m_pad_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btStaticPlaneShapeData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btStaticPlaneShapeData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btGeneric6DofSpringConstraint__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, _Bool arg5); +extern uintptr_t _wrap_new_btGeneric6DofSpringConstraint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, _Bool arg3); +extern void _wrap_btGeneric6DofSpringConstraint_enableSpring_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, _Bool arg3); +extern void _wrap_btGeneric6DofSpringConstraint_setStiffness_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3); +extern void _wrap_btGeneric6DofSpringConstraint_setDamping_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3); +extern void _wrap_btGeneric6DofSpringConstraint_setEquilibriumPoint__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraint_setEquilibriumPoint__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btGeneric6DofSpringConstraint_setEquilibriumPoint__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2, float arg3); +extern _Bool _wrap_btGeneric6DofSpringConstraint_isSpringEnabled_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern float _wrap_btGeneric6DofSpringConstraint_getStiffness_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern float _wrap_btGeneric6DofSpringConstraint_getDamping_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern float _wrap_btGeneric6DofSpringConstraint_getEquilibriumPoint_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern void _wrap_btGeneric6DofSpringConstraint_setAxis_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_btGeneric6DofSpringConstraint_getInfo2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern swig_intgo _wrap_btGeneric6DofSpringConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(uintptr_t arg1); +extern swig_type_173 _wrap_btGeneric6DofSpringConstraint_serialize_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); +extern void _wrap_delete_btGeneric6DofSpringConstraint_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_SetbtGeneric6DofSpringConstraint_M_useSolveConstraintObsolete_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern _Bool _wrap_GetbtGeneric6DofSpringConstraint_M_useSolveConstraintObsolete_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_calculateTransforms__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btGeneric6DofSpringConstraint_calculateTransforms__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getCalculatedTransformA_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getCalculatedTransformB_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getFrameOffsetA__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getFrameOffsetA__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getFrameOffsetB__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getFrameOffsetB__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_buildJacobian_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_getInfo1_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraint_getInfo1NonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraint_getInfo2NonVirtual_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7); +extern void _wrap_btGeneric6DofSpringConstraint_updateRHS_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getAxis_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern float _wrap_btGeneric6DofSpringConstraint_getAngle_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern float _wrap_btGeneric6DofSpringConstraint_getRelativePivotPosition_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btGeneric6DofSpringConstraint_setFrames_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2); +extern _Bool _wrap_btGeneric6DofSpringConstraint_testAngularLimitMotor_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btGeneric6DofSpringConstraint_setLinearLowerLimit_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraint_getLinearLowerLimit_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraint_setLinearUpperLimit_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraint_getLinearUpperLimit_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraint_setAngularLowerLimit_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraint_getAngularLowerLimit_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraint_setAngularUpperLimit_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraint_getAngularUpperLimit_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getRotationalLimitMotor_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getTranslationalLimitMotor_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_setLimit_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, float arg2, float arg3); +extern _Bool _wrap_btGeneric6DofSpringConstraint_isLimited_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btGeneric6DofSpringConstraint_calcAnchorPos_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btGeneric6DofSpringConstraint_get_limit_motor_info2__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, uintptr_t arg8, swig_intgo arg9, uintptr_t arg10, swig_intgo arg11, swig_intgo arg12); +extern swig_intgo _wrap_btGeneric6DofSpringConstraint_get_limit_motor_info2__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, uintptr_t arg8, swig_intgo arg9, uintptr_t arg10, swig_intgo arg11); +extern _Bool _wrap_btGeneric6DofSpringConstraint_getUseFrameOffset_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_setUseFrameOffset_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern _Bool _wrap_btGeneric6DofSpringConstraint_getUseLinearReferenceFrameA_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_setUseLinearReferenceFrameA_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern void _wrap_btGeneric6DofSpringConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, float arg2, swig_intgo arg3); +extern void _wrap_btGeneric6DofSpringConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, float arg2); +extern float _wrap_btGeneric6DofSpringConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1, swig_intgo arg2); +extern float _wrap_btGeneric6DofSpringConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btGeneric6DofSpringConstraint_getFlags_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getFixedBody_mbt_e879218550ba2e2b(void); +extern swig_intgo _wrap_btGeneric6DofSpringConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btGeneric6DofSpringConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, swig_intgo arg2, swig_intgo arg3, float arg4); +extern void _wrap_btGeneric6DofSpringConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btGeneric6DofSpringConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern float _wrap_btGeneric6DofSpringConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern _Bool _wrap_btGeneric6DofSpringConstraint_isEnabled_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_setEnabled_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern void _wrap_btGeneric6DofSpringConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1, uintptr_t arg2, float arg3); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getRigidBodyA__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getRigidBodyA__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getRigidBodyB__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getRigidBodyB__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btGeneric6DofSpringConstraint_getUserConstraintType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_setUserConstraintType_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern void _wrap_btGeneric6DofSpringConstraint_setUserConstraintId_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_btGeneric6DofSpringConstraint_getUserConstraintId_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_setJointFeedback_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern uintptr_t _wrap_btGeneric6DofSpringConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btGeneric6DofSpringConstraint_getUid_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern _Bool _wrap_btGeneric6DofSpringConstraint_needsFeedback_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_enableFeedback_mbt_e879218550ba2e2b(uintptr_t _swig_base, _Bool arg1); +extern float _wrap_btGeneric6DofSpringConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btGeneric6DofSpringConstraint_getConstraintType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(uintptr_t _swig_base, float arg1); +extern float _wrap_btGeneric6DofSpringConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_SetbtGeneric6DofSpringConstraint_M_objectType_mbt_e879218550ba2e2b(uintptr_t _swig_base, swig_intgo arg1); +extern swig_intgo _wrap_GetbtGeneric6DofSpringConstraint_M_objectType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern swig_intgo _wrap_btGeneric6DofSpringConstraint_getObjectType_mbt_e879218550ba2e2b(uintptr_t _swig_base); +extern void _wrap_btGeneric6DofSpringConstraintData_m_6dofData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofSpringConstraintData_m_6dofData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraintData_m_springEnabled_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btGeneric6DofSpringConstraintData_m_springEnabled_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraintData_m_equilibriumPoint_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btGeneric6DofSpringConstraintData_m_equilibriumPoint_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraintData_m_springStiffness_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btGeneric6DofSpringConstraintData_m_springStiffness_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraintData_m_springDamping_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btGeneric6DofSpringConstraintData_m_springDamping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btGeneric6DofSpringConstraintData_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btGeneric6DofSpringConstraintData_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraintDoubleData2_m_6dofData_set_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btGeneric6DofSpringConstraintDoubleData2_m_6dofData_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraintDoubleData2_m_springEnabled_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btGeneric6DofSpringConstraintDoubleData2_m_springEnabled_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraintDoubleData2_m_equilibriumPoint_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btGeneric6DofSpringConstraintDoubleData2_m_equilibriumPoint_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraintDoubleData2_m_springStiffness_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btGeneric6DofSpringConstraintDoubleData2_m_springStiffness_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btGeneric6DofSpringConstraintDoubleData2_m_springDamping_set_mbt_e879218550ba2e2b(uintptr_t arg1, swig_voidp arg2); +extern swig_voidp _wrap_btGeneric6DofSpringConstraintDoubleData2_m_springDamping_get_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btGeneric6DofSpringConstraintDoubleData2_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btGeneric6DofSpringConstraintDoubleData2_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btMDefaultColors_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7); +extern void _wrap_delete_btMDefaultColors_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap__swig_NewDirectorBtMDebugDrawLinerBtMDebugDrawLiner_mbt_e879218550ba2e2b(int); +extern void _wrap_DeleteDirectorBtMDebugDrawLiner_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_new_btMDebugDrawLiner_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btMDebugDrawLiner_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMDebugDrawLiner_drawLine_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern uintptr_t _wrap_new_btMDebugDraw_mbt_e879218550ba2e2b(void); +extern void _wrap_delete_btMDebugDraw_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMDebugDraw_drawLine__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btMDebugDraw_drawSphere__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btMDebugDraw_drawSphere__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, uintptr_t arg4); +extern void _wrap_btMDebugDraw_drawTriangle__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6, uintptr_t arg7, uintptr_t arg8, float arg9); +extern void _wrap_btMDebugDraw_drawTriangle__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, float arg6); +extern void _wrap_btMDebugDraw_drawAabb_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btMDebugDraw_drawTransform_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3); +extern void _wrap_btMDebugDraw_drawArc__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, float arg6, float arg7, float arg8, uintptr_t arg9, _Bool arg10, float arg11); +extern void _wrap_btMDebugDraw_drawArc__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, float arg6, float arg7, float arg8, uintptr_t arg9, _Bool arg10); +extern void _wrap_btMDebugDraw_drawSpherePatch__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, float arg6, float arg7, float arg8, float arg9, uintptr_t arg10, float arg11, _Bool arg12); +extern void _wrap_btMDebugDraw_drawSpherePatch__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, float arg6, float arg7, float arg8, float arg9, uintptr_t arg10, float arg11); +extern void _wrap_btMDebugDraw_drawSpherePatch__SWIG_2_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, float arg5, float arg6, float arg7, float arg8, float arg9, uintptr_t arg10); +extern void _wrap_btMDebugDraw_drawBox__SWIG_0_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btMDebugDraw_drawBox__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btMDebugDraw_drawCapsule_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, swig_intgo arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btMDebugDraw_drawCylinder_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, swig_intgo arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btMDebugDraw_drawCone_mbt_e879218550ba2e2b(uintptr_t arg1, float arg2, float arg3, swig_intgo arg4, uintptr_t arg5, uintptr_t arg6); +extern void _wrap_btMDebugDraw_drawPlane_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, float arg3, uintptr_t arg4, uintptr_t arg5); +extern void _wrap_btMDebugDraw_clearLines_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMDebugDraw_flushLines_mbt_e879218550ba2e2b(uintptr_t arg1); +extern uintptr_t _wrap_btMDebugDraw_getDefaultColors_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMDebugDraw_setMDefaultColors_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern void _wrap_btMDebugDraw_setLiner_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2); +extern uintptr_t _wrap_btMDebugDraw_getLiner_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMDebugDraw_setDebugMode_mbt_e879218550ba2e2b(uintptr_t arg1, swig_intgo arg2); +extern swig_intgo _wrap_btMDebugDraw_getDebugMode_mbt_e879218550ba2e2b(uintptr_t arg1); +extern void _wrap_btMDebugDraw_drawLine__SWIG_1_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4); +extern void _wrap_btMDebugDraw_drawContactPoint_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, float arg4, swig_intgo arg5, uintptr_t arg6); +extern void _wrap_btMDebugDraw_reportErrorWarning_mbt_e879218550ba2e2b(uintptr_t arg1, swig_type_174 arg2); +extern void _wrap_btMDebugDraw_draw3dText_mbt_e879218550ba2e2b(uintptr_t arg1, uintptr_t arg2, swig_type_175 arg3); +extern void _wrap_btMDebugDraw_setDefaultColors_mbt_e879218550ba2e2b(uintptr_t _swig_base, uintptr_t arg1); +#undef intgo +*/ +import "C" + +import ( + _ "runtime/cgo" + "sync" + "unsafe" +) + +type _ unsafe.Pointer + +var Swig_escape_always_false bool +var Swig_escape_val interface{} + +type _swig_fnptr *byte +type _swig_memberptr *byte + +func getSwigcptr(v interface{ Swigcptr() uintptr }) uintptr { + if v == nil { + return 0 + } + return v.Swigcptr() +} + +type _ sync.Mutex + +//export cgo_panic__mbt_e879218550ba2e2b +func cgo_panic__mbt_e879218550ba2e2b(p *byte) { + s := (*[1024]byte)(unsafe.Pointer(p))[:] + for i, b := range s { + if b == 0 { + panic(string(s[:i])) + } + } + panic(string(s)) +} + +type swig_gostring struct { + p uintptr + n int +} + +func swigCopyString(s string) string { + p := *(*swig_gostring)(unsafe.Pointer(&s)) + r := string((*[0x7fffffff]byte)(unsafe.Pointer(p.p))[:p.n]) + Swig_free(p.p) + return r +} + +func Swig_free(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_Swig_free_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func Swig_malloc(arg1 int) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_Swig_malloc_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +const BT_BULLET_VERSION int = 326 + +func BtGetVersion() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGetVersion_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtIsDoublePrecision() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btIsDoublePrecision_mbt_e879218550ba2e2b()) + return swig_r +} + +const BT_LARGE_FLOAT float32 = 1e18 + +type SwigcptrBtInfMaskConverter uintptr + +func (p SwigcptrBtInfMaskConverter) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtInfMaskConverter) SwigIsBtInfMaskConverter() { +} + +func NewBtInfMaskConverter__SWIG_0(arg1 int) (_swig_ret BtInfMaskConverter) { + var swig_r BtInfMaskConverter + _swig_i_0 := arg1 + swig_r = (BtInfMaskConverter)(SwigcptrBtInfMaskConverter(C._wrap_new_btInfMaskConverter__SWIG_0_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0)))) + return swig_r +} + +func NewBtInfMaskConverter__SWIG_1() (_swig_ret BtInfMaskConverter) { + var swig_r BtInfMaskConverter + swig_r = (BtInfMaskConverter)(SwigcptrBtInfMaskConverter(C._wrap_new_btInfMaskConverter__SWIG_1_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtInfMaskConverter(a ...interface{}) BtInfMaskConverter { + argc := len(a) + if argc == 0 { + return NewBtInfMaskConverter__SWIG_1() + } + if argc == 1 { + return NewBtInfMaskConverter__SWIG_0(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func DeleteBtInfMaskConverter(arg1 BtInfMaskConverter) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btInfMaskConverter_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtInfMaskConverter interface { + Swigcptr() uintptr + SwigIsBtInfMaskConverter() +} + +func SetBtInfinityMask(arg1 BtInfMaskConverter) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btInfinityMask_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func GetBtInfinityMask() (_swig_ret BtInfMaskConverter) { + var swig_r BtInfMaskConverter + swig_r = (BtInfMaskConverter)(SwigcptrBtInfMaskConverter(C._wrap_btInfinityMask_get_mbt_e879218550ba2e2b())) + return swig_r +} + +func BtGetInfinityMask() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGetInfinityMask_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtSqrt(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSqrt_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtFabs(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btFabs_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtCos(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCos_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtSin(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSin_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtTan(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTan_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtAcos(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAcos_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtAsin(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAsin_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtAtan(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAtan_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtAtan2(arg1 float32, arg2 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btAtan2_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +func BtExp(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btExp_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtLog(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btLog_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtPow(arg1 float32, arg2 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btPow_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +func BtFmod(arg1 float32, arg2 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btFmod_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +const BT_ONE float32 = 1.0 +const BT_ZERO float32 = 0.0 +const BT_TWO float32 = 2.0 +const BT_HALF float32 = 0.5 + +func BtAtan2Fast(arg1 float32, arg2 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btAtan2Fast_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +func BtFuzzyZero(arg1 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btFuzzyZero_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtEqual(arg1 float32, arg2 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btEqual_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +func BtGreaterEqual(arg1 float32, arg2 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btGreaterEqual_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +func BtIsNegative(arg1 float32) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btIsNegative_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtRadians(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRadians_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtDegrees(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btDegrees_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtFsel(arg1 float32, arg2 float32, arg3 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btFsel_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2))) + return swig_r +} + +func BtMachineIsLittleEndian() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btMachineIsLittleEndian_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtSelect__SWIG_0(arg1 uint, arg2 uint, arg3 uint) (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (uint)(C._wrap_btSelect__SWIG_0_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func BtSelect__SWIG_1(arg1 uint, arg2 int, arg3 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (int)(C._wrap_btSelect__SWIG_1_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func BtSelect__SWIG_2(arg1 uint, arg2 float32, arg3 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btSelect__SWIG_2_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2))) + return swig_r +} + +func BtSelect(a ...interface{}) interface{} { + argc := len(a) + if argc == 3 { + if _, ok := a[1].(uint); !ok { + goto check_1 + } + if _, ok := a[2].(uint); !ok { + goto check_1 + } + return BtSelect__SWIG_0(a[0].(uint), a[1].(uint), a[2].(uint)) + } +check_1: + if argc == 3 { + if _, ok := a[1].(int); !ok { + goto check_2 + } + if _, ok := a[2].(int); !ok { + goto check_2 + } + return BtSelect__SWIG_1(a[0].(uint), a[1].(int), a[2].(int)) + } +check_2: + if argc == 3 { + return BtSelect__SWIG_2(a[0].(uint), a[1].(float32), a[2].(float32)) + } + panic("No match for overloaded function call") +} + +func BtSwapEndian__SWIG_0(arg1 uint) (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btSwapEndian__SWIG_0_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtSwapEndian__SWIG_1(arg1 uint16) (_swig_ret uint16) { + var swig_r uint16 + _swig_i_0 := arg1 + swig_r = (uint16)(C._wrap_btSwapEndian__SWIG_1_mbt_e879218550ba2e2b(C.short(_swig_i_0))) + return swig_r +} + +func BtSwapEndian__SWIG_2(arg1 int) (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btSwapEndian__SWIG_2_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtSwapEndian__SWIG_3(arg1 int16) (_swig_ret uint16) { + var swig_r uint16 + _swig_i_0 := arg1 + swig_r = (uint16)(C._wrap_btSwapEndian__SWIG_3_mbt_e879218550ba2e2b(C.short(_swig_i_0))) + return swig_r +} + +func BtSwapEndian(a ...interface{}) interface{} { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(uint16); !ok { + goto check_1 + } + return BtSwapEndian__SWIG_1(a[0].(uint16)) + } +check_1: + if argc == 1 { + if _, ok := a[0].(int16); !ok { + goto check_2 + } + return BtSwapEndian__SWIG_3(a[0].(int16)) + } +check_2: + if argc == 1 { + if _, ok := a[0].(int); !ok { + goto check_3 + } + return BtSwapEndian__SWIG_2(a[0].(int)) + } +check_3: + if argc == 1 { + return BtSwapEndian__SWIG_0(a[0].(uint)) + } + panic("No match for overloaded function call") +} + +func BtSwapEndianFloat(arg1 float32) (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btSwapEndianFloat_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func BtUnswapEndianFloat(arg1 uint) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btUnswapEndianFloat_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtSwapEndianDouble(arg1 float64, arg2 *byte) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSwapEndianDouble_mbt_e879218550ba2e2b(C.double(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func BtUnswapEndianDouble(arg1 *byte) (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btUnswapEndianDouble_mbt_e879218550ba2e2b(C.swig_voidp(_swig_i_0))) + return swig_r +} + +func BtLargeDot(arg1 *float32, arg2 *float32, arg3 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btLargeDot_mbt_e879218550ba2e2b(C.swig_voidp(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func BtNormalizeAngle(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btNormalizeAngle_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +type SwigcptrBtTypedObject uintptr + +func (p SwigcptrBtTypedObject) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTypedObject) SwigIsBtTypedObject() { +} + +func NewBtTypedObject(arg1 int) (_swig_ret BtTypedObject) { + var swig_r BtTypedObject + _swig_i_0 := arg1 + swig_r = (BtTypedObject)(SwigcptrBtTypedObject(C._wrap_new_btTypedObject_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTypedObject) SetM_objectType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedObject_m_objectType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedObject) GetM_objectType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedObject_m_objectType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedObject) GetObjectType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedObject_getObjectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtTypedObject(arg1 BtTypedObject) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTypedObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTypedObject interface { + Swigcptr() uintptr + SwigIsBtTypedObject() + SetM_objectType(arg2 int) + GetM_objectType() (_swig_ret int) + GetObjectType() (_swig_ret int) +} + +func BtAlignedAllocInternal(arg1 int64, arg2 int) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (uintptr)(C._wrap_btAlignedAllocInternal_mbt_e879218550ba2e2b(C.swig_type_1(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func BtAlignedFreeInternal(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btAlignedFreeInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func BtAlignedAllocSetCustom(arg1 _swig_fnptr, arg2 _swig_fnptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btAlignedAllocSetCustom_mbt_e879218550ba2e2b(C.swig_type_2(_swig_i_0), C.swig_type_3(_swig_i_1)) +} + +func BtAlignedAllocSetCustomAligned(arg1 _swig_fnptr, arg2 _swig_fnptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btAlignedAllocSetCustomAligned_mbt_e879218550ba2e2b(C.swig_type_4(_swig_i_0), C.swig_type_5(_swig_i_1)) +} + +func BtAllocDefault(arg1 int64) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btAllocDefault_mbt_e879218550ba2e2b(C.swig_type_6(_swig_i_0))) + return swig_r +} + +func BtFreeDefault(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btFreeDefault_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func SetSAllocFunc(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_sAllocFunc_set_mbt_e879218550ba2e2b(C.swig_type_7(_swig_i_0)) +} + +func GetSAllocFunc() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_sAllocFunc_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetSFreeFunc(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_sFreeFunc_set_mbt_e879218550ba2e2b(C.swig_type_9(_swig_i_0)) +} + +func GetSFreeFunc() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_sFreeFunc_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtAlignedAllocDefault(arg1 int64, arg2 int) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (uintptr)(C._wrap_btAlignedAllocDefault_mbt_e879218550ba2e2b(C.swig_type_11(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func BtAlignedFreeDefault(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btAlignedFreeDefault_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func SetSAlignedAllocFunc(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_sAlignedAllocFunc_set_mbt_e879218550ba2e2b(C.swig_type_12(_swig_i_0)) +} + +func GetSAlignedAllocFunc() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_sAlignedAllocFunc_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetSAlignedFreeFunc(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_sAlignedFreeFunc_set_mbt_e879218550ba2e2b(C.swig_type_14(_swig_i_0)) +} + +func GetSAlignedFreeFunc() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_sAlignedFreeFunc_get_mbt_e879218550ba2e2b()) + return swig_r +} + +const BtVector3DataName string = "btVector3FloatData" + +type SwigcptrBtVector3 uintptr + +func (p SwigcptrBtVector3) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtVector3) SwigIsBtVector3() { +} + +func (arg1 SwigcptrBtVector3) SetM_floats(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVector3_m_floats_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) GetM_floats() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btVector3_m_floats_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtVector3__SWIG_0() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_new_btVector3__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtVector3__SWIG_1(arg1 float32, arg2 float32, arg3 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_new_btVector3__SWIG_1_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +func NewBtVector3(a ...interface{}) BtVector3 { + argc := len(a) + if argc == 0 { + return NewBtVector3__SWIG_0() + } + if argc == 3 { + return NewBtVector3__SWIG_1(a[0].(float32), a[1].(float32), a[2].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtVector3) Dot(arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btVector3_dot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Length2() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_length2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Length() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_length_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Norm() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_norm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) SafeNorm() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_safeNorm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Distance2(arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btVector3_distance2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Distance(arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btVector3_distance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) SafeNormalize() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector3_safeNormalize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Normalize() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector3_normalize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Normalized() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector3_normalized_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Rotate(arg2 BtVector3, arg3 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector3_rotate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Angle(arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btVector3_angle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Absolute() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector3_absolute_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Cross(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector3_cross_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Triple(arg2 BtVector3, arg3 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (float32)(C._wrap_btVector3_triple_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) MinAxis() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btVector3_minAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) MaxAxis() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btVector3_maxAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) FurthestAxis() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btVector3_furthestAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) ClosestAxis() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btVector3_closestAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) SetInterpolate3(arg2 BtVector3, arg3 BtVector3, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btVector3_setInterpolate3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtVector3) Lerp(arg2 BtVector3, arg3 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector3_lerp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) GetX() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_getX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) GetY() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_getY_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) GetZ() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_getZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) SetX(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVector3_setX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) SetY(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVector3_setY_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) SetZ(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVector3_setZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) SetW(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVector3_setW_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) X() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_x_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Y() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_y_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Z() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_z_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) W() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector3_w_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) SetMax(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVector3_setMax_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) SetMin(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVector3_setMin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) SetValue(arg2 float32, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btVector3_setValue_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtVector3) GetSkewSymmetricMatrix(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btVector3_getSkewSymmetricMatrix_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtVector3) SetZero() { + _swig_i_0 := arg1 + C._wrap_btVector3_setZero_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtVector3) IsZero() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btVector3_isZero_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) FuzzyZero() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btVector3_fuzzyZero_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Serialize(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVector3_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) DeSerialize__SWIG_0(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVector3_deSerialize__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) DeSerialize__SWIG_1(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVector3_deSerialize__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtVector3) DeSerialize(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(SwigcptrBtVector3DoubleData); !ok { + goto check_1 + } + p.DeSerialize__SWIG_0(a[0].(BtVector3DoubleData)) + return + } +check_1: + if argc == 1 { + p.DeSerialize__SWIG_1(a[0].(BtVector3FloatData)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtVector3) SerializeFloat(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVector3_serializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) DeSerializeFloat(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVector3_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) SerializeDouble(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVector3_serializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) DeSerializeDouble(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVector3_deSerializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3) MaxDot(arg2 BtVector3, arg3 int64, arg4 *float32) (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (int64)(C._wrap_btVector3_maxDot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_type_17(_swig_i_2), C.swig_voidp(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) MinDot(arg2 BtVector3, arg3 int64, arg4 *float32) (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (int64)(C._wrap_btVector3_minDot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_type_19(_swig_i_2), C.swig_voidp(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtVector3) Dot3(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector3_dot3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func DeleteBtVector3(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btVector3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtVector3 interface { + Swigcptr() uintptr + SwigIsBtVector3() + SetM_floats(arg2 *float32) + GetM_floats() (_swig_ret *float32) + Dot(arg2 BtVector3) (_swig_ret float32) + Length2() (_swig_ret float32) + Length() (_swig_ret float32) + Norm() (_swig_ret float32) + SafeNorm() (_swig_ret float32) + Distance2(arg2 BtVector3) (_swig_ret float32) + Distance(arg2 BtVector3) (_swig_ret float32) + SafeNormalize() (_swig_ret BtVector3) + Normalize() (_swig_ret BtVector3) + Normalized() (_swig_ret BtVector3) + Rotate(arg2 BtVector3, arg3 float32) (_swig_ret BtVector3) + Angle(arg2 BtVector3) (_swig_ret float32) + Absolute() (_swig_ret BtVector3) + Cross(arg2 BtVector3) (_swig_ret BtVector3) + Triple(arg2 BtVector3, arg3 BtVector3) (_swig_ret float32) + MinAxis() (_swig_ret int) + MaxAxis() (_swig_ret int) + FurthestAxis() (_swig_ret int) + ClosestAxis() (_swig_ret int) + SetInterpolate3(arg2 BtVector3, arg3 BtVector3, arg4 float32) + Lerp(arg2 BtVector3, arg3 float32) (_swig_ret BtVector3) + GetX() (_swig_ret float32) + GetY() (_swig_ret float32) + GetZ() (_swig_ret float32) + SetX(arg2 float32) + SetY(arg2 float32) + SetZ(arg2 float32) + SetW(arg2 float32) + X() (_swig_ret float32) + Y() (_swig_ret float32) + Z() (_swig_ret float32) + W() (_swig_ret float32) + SetMax(arg2 BtVector3) + SetMin(arg2 BtVector3) + SetValue(arg2 float32, arg3 float32, arg4 float32) + GetSkewSymmetricMatrix(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) + SetZero() + IsZero() (_swig_ret bool) + FuzzyZero() (_swig_ret bool) + Serialize(arg2 BtVector3FloatData) + DeSerialize(a ...interface{}) + SerializeFloat(arg2 BtVector3FloatData) + DeSerializeFloat(arg2 BtVector3FloatData) + SerializeDouble(arg2 BtVector3DoubleData) + DeSerializeDouble(arg2 BtVector3DoubleData) + MaxDot(arg2 BtVector3, arg3 int64, arg4 *float32) (_swig_ret int64) + MinDot(arg2 BtVector3, arg3 int64, arg4 *float32) (_swig_ret int64) + Dot3(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) (_swig_ret BtVector3) +} + +func BtDot(arg1 BtVector3, arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btDot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtDistance2(arg1 BtVector3, arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btDistance2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtDistance(arg1 BtVector3, arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btDistance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtAngle__SWIG_0(arg1 BtVector3, arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btAngle__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtCross(arg1 BtVector3, arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCross_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func BtTriple(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (float32)(C._wrap_btTriple_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func Lerp(arg1 BtVector3, arg2 BtVector3, arg3 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_lerp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +type SwigcptrBtVector4 uintptr + +func (p SwigcptrBtVector4) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtVector4) SwigIsBtVector4() { +} + +func NewBtVector4__SWIG_0() (_swig_ret BtVector4) { + var swig_r BtVector4 + swig_r = (BtVector4)(SwigcptrBtVector4(C._wrap_new_btVector4__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtVector4__SWIG_1(arg1 float32, arg2 float32, arg3 float32, arg4 float32) (_swig_ret BtVector4) { + var swig_r BtVector4 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (BtVector4)(SwigcptrBtVector4(C._wrap_new_btVector4__SWIG_1_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)))) + return swig_r +} + +func NewBtVector4(a ...interface{}) BtVector4 { + argc := len(a) + if argc == 0 { + return NewBtVector4__SWIG_0() + } + if argc == 4 { + return NewBtVector4__SWIG_1(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtVector4) Absolute4() (_swig_ret BtVector4) { + var swig_r BtVector4 + _swig_i_0 := arg1 + swig_r = (BtVector4)(SwigcptrBtVector4(C._wrap_btVector4_absolute4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVector4) GetW() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVector4_getW_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector4) MaxAxis4() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btVector4_maxAxis4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector4) MinAxis4() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btVector4_minAxis4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector4) ClosestAxis4() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btVector4_closestAxis4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVector4) SetValue(arg2 float32, arg3 float32, arg4 float32, arg5 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btVector4_setValue_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4)) +} + +func DeleteBtVector4(arg1 BtVector4) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btVector4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) SetM_floats(arg1 *float32) { + _swig_i_0 := arg1 + C._wrap_SetbtVector4_M_floats_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_voidp(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) GetM_floats() (_swig_ret *float32) { + var swig_r *float32 + swig_r = (*float32)(C._wrap_GetbtVector4_M_floats_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtVector4) Operator_Sm__Se_(a ...interface{}) { + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtVector4) Dot(arg1 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float32)(C._wrap_btVector4_dot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Length2() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_length2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Length() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_length_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Norm() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_norm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) SafeNorm() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_safeNorm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Distance2(arg1 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float32)(C._wrap_btVector4_distance2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Distance(arg1 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float32)(C._wrap_btVector4_distance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) SafeNormalize() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector4_safeNormalize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Normalize() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector4_normalize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Normalized() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector4_normalized_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Rotate(arg1 BtVector3, arg2 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector4_rotate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Angle(arg1 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float32)(C._wrap_btVector4_angle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Absolute() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector4_absolute_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Cross(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector4_cross_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Triple(arg1 BtVector3, arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btVector4_triple_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) MinAxis() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btVector4_minAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) MaxAxis() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btVector4_maxAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) FurthestAxis() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btVector4_furthestAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) ClosestAxis() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btVector4_closestAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) SetInterpolate3(arg1 BtVector3, arg2 BtVector3, arg3 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btVector4_setInterpolate3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)) +} + +func (_swig_base SwigcptrBtVector4) Lerp(arg1 BtVector3, arg2 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector4_lerp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) GetX() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_getX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) GetY() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_getY_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) GetZ() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_getZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) SetX(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btVector4_setX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) SetY(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btVector4_setY_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) SetZ(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btVector4_setZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) SetW(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btVector4_setW_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) X() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_x_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Y() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_y_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Z() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_z_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) W() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btVector4_w_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) SetMax(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btVector4_setMax_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) SetMin(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btVector4_setMin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) GetSkewSymmetricMatrix(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btVector4_getSkewSymmetricMatrix_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtVector4) SetZero() { + C._wrap_btVector4_setZero_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtVector4) IsZero() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btVector4_isZero_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) FuzzyZero() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btVector4_fuzzyZero_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Serialize(arg1 BtVector3FloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btVector4_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) DeSerialize__SWIG_0(arg1 BtVector3DoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btVector4_deSerialize__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) DeSerialize__SWIG_1(arg1 BtVector3FloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btVector4_deSerialize__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtVector4) DeSerialize(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(SwigcptrBtVector3DoubleData); !ok { + goto check_1 + } + p.DeSerialize__SWIG_0(a[0].(BtVector3DoubleData)) + return + } +check_1: + if argc == 1 { + p.DeSerialize__SWIG_1(a[0].(BtVector3FloatData)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtVector4) SerializeFloat(arg1 BtVector3FloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btVector4_serializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) DeSerializeFloat(arg1 BtVector3FloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btVector4_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) SerializeDouble(arg1 BtVector3DoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btVector4_serializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) DeSerializeDouble(arg1 BtVector3DoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btVector4_deSerializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtVector4) MaxDot(arg1 BtVector3, arg2 int64, arg3 *float32) (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (int64)(C._wrap_btVector4_maxDot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_type_21(_swig_i_1), C.swig_voidp(_swig_i_2))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) MinDot(arg1 BtVector3, arg2 int64, arg3 *float32) (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (int64)(C._wrap_btVector4_minDot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_type_23(_swig_i_1), C.swig_voidp(_swig_i_2))) + return swig_r +} + +func (_swig_base SwigcptrBtVector4) Dot3(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVector4_dot3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (p SwigcptrBtVector4) SwigIsBtVector3() { +} + +func (p SwigcptrBtVector4) SwigGetBtVector3() BtVector3 { + return SwigcptrBtVector3(getSwigcptr(p)) +} + +type BtVector4 interface { + Swigcptr() uintptr + SwigIsBtVector4() + Absolute4() (_swig_ret BtVector4) + GetW() (_swig_ret float32) + MaxAxis4() (_swig_ret int) + MinAxis4() (_swig_ret int) + ClosestAxis4() (_swig_ret int) + SetValue(arg2 float32, arg3 float32, arg4 float32, arg5 float32) + SetM_floats(arg1 *float32) + GetM_floats() (_swig_ret *float32) + Operator_Sm__Se_(a ...interface{}) + Dot(arg1 BtVector3) (_swig_ret float32) + Length2() (_swig_ret float32) + Length() (_swig_ret float32) + Norm() (_swig_ret float32) + SafeNorm() (_swig_ret float32) + Distance2(arg1 BtVector3) (_swig_ret float32) + Distance(arg1 BtVector3) (_swig_ret float32) + SafeNormalize() (_swig_ret BtVector3) + Normalize() (_swig_ret BtVector3) + Normalized() (_swig_ret BtVector3) + Rotate(arg1 BtVector3, arg2 float32) (_swig_ret BtVector3) + Angle(arg1 BtVector3) (_swig_ret float32) + Absolute() (_swig_ret BtVector3) + Cross(arg1 BtVector3) (_swig_ret BtVector3) + Triple(arg1 BtVector3, arg2 BtVector3) (_swig_ret float32) + MinAxis() (_swig_ret int) + MaxAxis() (_swig_ret int) + FurthestAxis() (_swig_ret int) + ClosestAxis() (_swig_ret int) + SetInterpolate3(arg1 BtVector3, arg2 BtVector3, arg3 float32) + Lerp(arg1 BtVector3, arg2 float32) (_swig_ret BtVector3) + GetX() (_swig_ret float32) + GetY() (_swig_ret float32) + GetZ() (_swig_ret float32) + SetX(arg1 float32) + SetY(arg1 float32) + SetZ(arg1 float32) + SetW(arg1 float32) + X() (_swig_ret float32) + Y() (_swig_ret float32) + Z() (_swig_ret float32) + W() (_swig_ret float32) + SetMax(arg1 BtVector3) + SetMin(arg1 BtVector3) + GetSkewSymmetricMatrix(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) + SetZero() + IsZero() (_swig_ret bool) + FuzzyZero() (_swig_ret bool) + Serialize(arg1 BtVector3FloatData) + DeSerialize(a ...interface{}) + SerializeFloat(arg1 BtVector3FloatData) + DeSerializeFloat(arg1 BtVector3FloatData) + SerializeDouble(arg1 BtVector3DoubleData) + DeSerializeDouble(arg1 BtVector3DoubleData) + MaxDot(arg1 BtVector3, arg2 int64, arg3 *float32) (_swig_ret int64) + MinDot(arg1 BtVector3, arg2 int64, arg3 *float32) (_swig_ret int64) + Dot3(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) (_swig_ret BtVector3) + SwigIsBtVector3() + SwigGetBtVector3() BtVector3 +} + +func BtSwapScalarEndian(arg1 float32, arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSwapScalarEndian_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func BtSwapVector3Endian(arg1 BtVector3, arg2 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSwapVector3Endian_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func BtUnSwapVector3Endian(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btUnSwapVector3Endian_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type SwigcptrBtVector3FloatData uintptr + +func (p SwigcptrBtVector3FloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtVector3FloatData) SwigIsBtVector3FloatData() { +} + +func (arg1 SwigcptrBtVector3FloatData) SetM_floats(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVector3FloatData_m_floats_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3FloatData) GetM_floats() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btVector3FloatData_m_floats_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtVector3FloatData() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_new_btVector3FloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtVector3FloatData(arg1 BtVector3FloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btVector3FloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtVector3FloatData interface { + Swigcptr() uintptr + SwigIsBtVector3FloatData() + SetM_floats(arg2 *float32) + GetM_floats() (_swig_ret *float32) +} + +type SwigcptrBtVector3DoubleData uintptr + +func (p SwigcptrBtVector3DoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtVector3DoubleData) SwigIsBtVector3DoubleData() { +} + +func (arg1 SwigcptrBtVector3DoubleData) SetM_floats(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVector3DoubleData_m_floats_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtVector3DoubleData) GetM_floats() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btVector3DoubleData_m_floats_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtVector3DoubleData() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_new_btVector3DoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtVector3DoubleData(arg1 BtVector3DoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btVector3DoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtVector3DoubleData interface { + Swigcptr() uintptr + SwigIsBtVector3DoubleData() + SetM_floats(arg2 *float64) + GetM_floats() (_swig_ret *float64) +} + +type SwigcptrBtQuadWord uintptr + +func (p SwigcptrBtQuadWord) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtQuadWord) SwigIsBtQuadWord() { +} + +func (arg1 SwigcptrBtQuadWord) GetX() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuadWord_getX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuadWord) GetY() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuadWord_getY_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuadWord) GetZ() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuadWord_getZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuadWord) SetX(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuadWord_setX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuadWord) SetY(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuadWord_setY_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuadWord) SetZ(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuadWord_setZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuadWord) SetW(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuadWord_setW_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuadWord) X() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuadWord_x_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuadWord) Y() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuadWord_y_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuadWord) Z() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuadWord_z_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuadWord) W() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuadWord_w_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuadWord) SetValue__SWIG_0(arg2 float32, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btQuadWord_setValue__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtQuadWord) SetValue__SWIG_1(arg2 float32, arg3 float32, arg4 float32, arg5 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btQuadWord_setValue__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4)) +} + +func (p SwigcptrBtQuadWord) SetValue(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.SetValue__SWIG_0(a[0].(float32), a[1].(float32), a[2].(float32)) + return + } + if argc == 4 { + p.SetValue__SWIG_1(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32)) + return + } + panic("No match for overloaded function call") +} + +func NewBtQuadWord__SWIG_0() (_swig_ret BtQuadWord) { + var swig_r BtQuadWord + swig_r = (BtQuadWord)(SwigcptrBtQuadWord(C._wrap_new_btQuadWord__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtQuadWord__SWIG_1(arg1 float32, arg2 float32, arg3 float32) (_swig_ret BtQuadWord) { + var swig_r BtQuadWord + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtQuadWord)(SwigcptrBtQuadWord(C._wrap_new_btQuadWord__SWIG_1_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +func NewBtQuadWord__SWIG_2(arg1 float32, arg2 float32, arg3 float32, arg4 float32) (_swig_ret BtQuadWord) { + var swig_r BtQuadWord + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (BtQuadWord)(SwigcptrBtQuadWord(C._wrap_new_btQuadWord__SWIG_2_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)))) + return swig_r +} + +func NewBtQuadWord(a ...interface{}) BtQuadWord { + argc := len(a) + if argc == 0 { + return NewBtQuadWord__SWIG_0() + } + if argc == 3 { + return NewBtQuadWord__SWIG_1(a[0].(float32), a[1].(float32), a[2].(float32)) + } + if argc == 4 { + return NewBtQuadWord__SWIG_2(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtQuadWord) SetMax(arg2 BtQuadWord) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuadWord_setMax_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuadWord) SetMin(arg2 BtQuadWord) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuadWord_setMin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBtQuadWord(arg1 BtQuadWord) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btQuadWord_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtQuadWord interface { + Swigcptr() uintptr + SwigIsBtQuadWord() + GetX() (_swig_ret float32) + GetY() (_swig_ret float32) + GetZ() (_swig_ret float32) + SetX(arg2 float32) + SetY(arg2 float32) + SetZ(arg2 float32) + SetW(arg2 float32) + X() (_swig_ret float32) + Y() (_swig_ret float32) + Z() (_swig_ret float32) + W() (_swig_ret float32) + SetValue(a ...interface{}) + SetMax(arg2 BtQuadWord) + SetMin(arg2 BtQuadWord) +} + +const BtQuaternionDataName string = "btQuaternionFloatData" + +type SwigcptrBtQuaternion uintptr + +func (p SwigcptrBtQuaternion) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtQuaternion) SwigIsBtQuaternion() { +} + +func NewBtQuaternion__SWIG_0() (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_new_btQuaternion__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtQuaternion__SWIG_1(arg1 float32, arg2 float32, arg3 float32, arg4 float32) (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_new_btQuaternion__SWIG_1_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)))) + return swig_r +} + +func NewBtQuaternion__SWIG_2(arg1 BtVector3, arg2 float32) (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_new_btQuaternion__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func NewBtQuaternion__SWIG_3(arg1 float32, arg2 float32, arg3 float32) (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_new_btQuaternion__SWIG_3_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +func NewBtQuaternion(a ...interface{}) BtQuaternion { + argc := len(a) + if argc == 0 { + return NewBtQuaternion__SWIG_0() + } + if argc == 2 { + return NewBtQuaternion__SWIG_2(a[0].(BtVector3), a[1].(float32)) + } + if argc == 3 { + return NewBtQuaternion__SWIG_3(a[0].(float32), a[1].(float32), a[2].(float32)) + } + if argc == 4 { + return NewBtQuaternion__SWIG_1(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtQuaternion) SetRotation(arg2 BtVector3, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btQuaternion_setRotation_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtQuaternion) SetEuler(arg2 float32, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btQuaternion_setEuler_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtQuaternion) SetEulerZYX(arg2 float32, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btQuaternion_setEulerZYX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtQuaternion) GetEulerZYX(arg2 *float32, arg3 *float32, arg4 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btQuaternion_getEulerZYX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3)) +} + +func (arg1 SwigcptrBtQuaternion) Dot(arg2 BtQuaternion) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btQuaternion_dot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) Length2() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuaternion_length2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) Length() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuaternion_length_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) SafeNormalize() (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btQuaternion_safeNormalize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) Normalize() (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btQuaternion_normalize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) Normalized() (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btQuaternion_normalized_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) Angle(arg2 BtQuaternion) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btQuaternion_angle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) AngleShortestPath(arg2 BtQuaternion) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btQuaternion_angleShortestPath_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) GetAngle() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuaternion_getAngle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) GetAngleShortestPath() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuaternion_getAngleShortestPath_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) GetAxis() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btQuaternion_getAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) Inverse() (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btQuaternion_inverse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) Farthest(arg2 BtQuaternion) (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btQuaternion_farthest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) Nearest(arg2 BtQuaternion) (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btQuaternion_nearest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) Slerp(arg2 BtQuaternion, arg3 float32) (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btQuaternion_slerp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +func BtQuaternionGetIdentity() (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btQuaternion_getIdentity_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) GetW() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btQuaternion_getW_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuaternion) Serialize(arg2 BtQuaternionFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuaternion_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuaternion) DeSerialize__SWIG_0(arg2 BtQuaternionFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuaternion_deSerialize__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuaternion) DeSerialize__SWIG_1(arg2 BtQuaternionDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuaternion_deSerialize__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtQuaternion) DeSerialize(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(SwigcptrBtQuaternionFloatData); !ok { + goto check_1 + } + p.DeSerialize__SWIG_0(a[0].(BtQuaternionFloatData)) + return + } +check_1: + if argc == 1 { + p.DeSerialize__SWIG_1(a[0].(BtQuaternionDoubleData)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtQuaternion) SerializeFloat(arg2 BtQuaternionFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuaternion_serializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuaternion) DeSerializeFloat(arg2 BtQuaternionFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuaternion_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuaternion) SerializeDouble(arg2 BtQuaternionDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuaternion_serializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuaternion) DeSerializeDouble(arg2 BtQuaternionDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuaternion_deSerializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBtQuaternion(arg1 BtQuaternion) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btQuaternion_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtQuaternion) GetX() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btQuaternion_getX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtQuaternion) GetY() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btQuaternion_getY_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtQuaternion) GetZ() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btQuaternion_getZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtQuaternion) SetX(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btQuaternion_setX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtQuaternion) SetY(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btQuaternion_setY_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtQuaternion) SetZ(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btQuaternion_setZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtQuaternion) SetW(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btQuaternion_setW_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtQuaternion) X() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btQuaternion_x_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtQuaternion) Y() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btQuaternion_y_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtQuaternion) Z() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btQuaternion_z_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtQuaternion) W() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btQuaternion_w_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtQuaternion) SetValue__SWIG_0(arg1 float32, arg2 float32, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btQuaternion_setValue__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)) +} + +func (_swig_base SwigcptrBtQuaternion) SetValue__SWIG_1(arg1 float32, arg2 float32, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btQuaternion_setValue__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (p SwigcptrBtQuaternion) SetValue(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.SetValue__SWIG_0(a[0].(float32), a[1].(float32), a[2].(float32)) + return + } + if argc == 4 { + p.SetValue__SWIG_1(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtQuaternion) SetMax(arg1 BtQuadWord) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btQuaternion_setMax_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtQuaternion) SetMin(arg1 BtQuadWord) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btQuaternion_setMin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtQuaternion) SwigIsBtQuadWord() { +} + +func (p SwigcptrBtQuaternion) SwigGetBtQuadWord() BtQuadWord { + return SwigcptrBtQuadWord(getSwigcptr(p)) +} + +type BtQuaternion interface { + Swigcptr() uintptr + SwigIsBtQuaternion() + SetRotation(arg2 BtVector3, arg3 float32) + SetEuler(arg2 float32, arg3 float32, arg4 float32) + SetEulerZYX(arg2 float32, arg3 float32, arg4 float32) + GetEulerZYX(arg2 *float32, arg3 *float32, arg4 *float32) + Dot(arg2 BtQuaternion) (_swig_ret float32) + Length2() (_swig_ret float32) + Length() (_swig_ret float32) + SafeNormalize() (_swig_ret BtQuaternion) + Normalize() (_swig_ret BtQuaternion) + Normalized() (_swig_ret BtQuaternion) + Angle(arg2 BtQuaternion) (_swig_ret float32) + AngleShortestPath(arg2 BtQuaternion) (_swig_ret float32) + GetAngle() (_swig_ret float32) + GetAngleShortestPath() (_swig_ret float32) + GetAxis() (_swig_ret BtVector3) + Inverse() (_swig_ret BtQuaternion) + Farthest(arg2 BtQuaternion) (_swig_ret BtQuaternion) + Nearest(arg2 BtQuaternion) (_swig_ret BtQuaternion) + Slerp(arg2 BtQuaternion, arg3 float32) (_swig_ret BtQuaternion) + GetW() (_swig_ret float32) + Serialize(arg2 BtQuaternionFloatData) + DeSerialize(a ...interface{}) + SerializeFloat(arg2 BtQuaternionFloatData) + DeSerializeFloat(arg2 BtQuaternionFloatData) + SerializeDouble(arg2 BtQuaternionDoubleData) + DeSerializeDouble(arg2 BtQuaternionDoubleData) + GetX() (_swig_ret float32) + GetY() (_swig_ret float32) + GetZ() (_swig_ret float32) + SetX(arg1 float32) + SetY(arg1 float32) + SetZ(arg1 float32) + SetW(arg1 float32) + X() (_swig_ret float32) + Y() (_swig_ret float32) + Z() (_swig_ret float32) + W() (_swig_ret float32) + SetValue(a ...interface{}) + SetMax(arg1 BtQuadWord) + SetMin(arg1 BtQuadWord) + SwigIsBtQuadWord() + SwigGetBtQuadWord() BtQuadWord +} + +func Dot(arg1 BtQuaternion, arg2 BtQuaternion) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_dot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func Length(arg1 BtQuaternion) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float32)(C._wrap_length_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func BtAngle__SWIG_1(arg1 BtQuaternion, arg2 BtQuaternion) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btAngle__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtAngle(a ...interface{}) float32 { + argc := len(a) + if argc == 2 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + if _, ok := a[1].(BtVector3); !ok { + goto check_1 + } + return BtAngle__SWIG_0(a[0].(BtVector3), a[1].(BtVector3)) + } +check_1: + if argc == 2 { + return BtAngle__SWIG_1(a[0].(BtQuaternion), a[1].(BtQuaternion)) + } + panic("No match for overloaded function call") +} + +func Inverse(arg1 BtQuaternion) (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_inverse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func Slerp(arg1 BtQuaternion, arg2 BtQuaternion, arg3 float32) (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_slerp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +func QuatRotate(arg1 BtQuaternion, arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_quatRotate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func ShortestArcQuat(arg1 BtVector3, arg2 BtVector3) (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_shortestArcQuat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func ShortestArcQuatNormalize2(arg1 BtVector3, arg2 BtVector3) (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_shortestArcQuatNormalize2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +type SwigcptrBtQuaternionFloatData uintptr + +func (p SwigcptrBtQuaternionFloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtQuaternionFloatData) SwigIsBtQuaternionFloatData() { +} + +func (arg1 SwigcptrBtQuaternionFloatData) SetM_floats(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuaternionFloatData_m_floats_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuaternionFloatData) GetM_floats() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btQuaternionFloatData_m_floats_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtQuaternionFloatData() (_swig_ret BtQuaternionFloatData) { + var swig_r BtQuaternionFloatData + swig_r = (BtQuaternionFloatData)(SwigcptrBtQuaternionFloatData(C._wrap_new_btQuaternionFloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtQuaternionFloatData(arg1 BtQuaternionFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btQuaternionFloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtQuaternionFloatData interface { + Swigcptr() uintptr + SwigIsBtQuaternionFloatData() + SetM_floats(arg2 *float32) + GetM_floats() (_swig_ret *float32) +} + +type SwigcptrBtQuaternionDoubleData uintptr + +func (p SwigcptrBtQuaternionDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtQuaternionDoubleData) SwigIsBtQuaternionDoubleData() { +} + +func (arg1 SwigcptrBtQuaternionDoubleData) SetM_floats(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuaternionDoubleData_m_floats_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuaternionDoubleData) GetM_floats() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btQuaternionDoubleData_m_floats_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtQuaternionDoubleData() (_swig_ret BtQuaternionDoubleData) { + var swig_r BtQuaternionDoubleData + swig_r = (BtQuaternionDoubleData)(SwigcptrBtQuaternionDoubleData(C._wrap_new_btQuaternionDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtQuaternionDoubleData(arg1 BtQuaternionDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btQuaternionDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtQuaternionDoubleData interface { + Swigcptr() uintptr + SwigIsBtQuaternionDoubleData() + SetM_floats(arg2 *float64) + GetM_floats() (_swig_ret *float64) +} + +type SwigcptrBtMatrix3x3 uintptr + +func (p SwigcptrBtMatrix3x3) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMatrix3x3) SwigIsBtMatrix3x3() { +} + +func NewBtMatrix3x3__SWIG_0() (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_new_btMatrix3x3__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtMatrix3x3__SWIG_1(arg1 BtQuaternion) (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_new_btMatrix3x3__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtMatrix3x3__SWIG_2(arg1 float32, arg2 float32, arg3 float32, arg4 float32, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 float32) (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_new_btMatrix3x3__SWIG_2_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.float(_swig_i_8)))) + return swig_r +} + +func NewBtMatrix3x3__SWIG_3(arg1 BtMatrix3x3) (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_new_btMatrix3x3__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtMatrix3x3__SWIG_4(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_new_btMatrix3x3__SWIG_4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func NewBtMatrix3x3(a ...interface{}) BtMatrix3x3 { + argc := len(a) + if argc == 0 { + return NewBtMatrix3x3__SWIG_0() + } + if argc == 1 { + if _, ok := a[0].(BtQuaternion); !ok { + goto check_2 + } + return NewBtMatrix3x3__SWIG_1(a[0].(BtQuaternion)) + } +check_2: + if argc == 1 { + return NewBtMatrix3x3__SWIG_3(a[0].(BtMatrix3x3)) + } + if argc == 3 { + return NewBtMatrix3x3__SWIG_4(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3)) + } + if argc == 9 { + return NewBtMatrix3x3__SWIG_2(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(float32), a[8].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMatrix3x3) GetColumn(arg2 int) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btMatrix3x3_getColumn_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) GetRow(arg2 int) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btMatrix3x3_getRow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) SetFromOpenGLSubMatrix(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btMatrix3x3_setFromOpenGLSubMatrix_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtMatrix3x3) SetValue(arg2 float32, arg3 float32, arg4 float32, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 float32, arg10 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + _swig_i_9 := arg10 + C._wrap_btMatrix3x3_setValue_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.float(_swig_i_8), C.float(_swig_i_9)) +} + +func (arg1 SwigcptrBtMatrix3x3) SetRotation(arg2 BtQuaternion) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMatrix3x3_setRotation_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMatrix3x3) SetEulerYPR(arg2 float32, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btMatrix3x3_setEulerYPR_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtMatrix3x3) SetEulerZYX(arg2 float32, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btMatrix3x3_setEulerZYX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtMatrix3x3) SetIdentity() { + _swig_i_0 := arg1 + C._wrap_btMatrix3x3_setIdentity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtMatrix3x3) SetZero() { + _swig_i_0 := arg1 + C._wrap_btMatrix3x3_setZero_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func BtMatrix3x3GetIdentity() (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btMatrix3x3_getIdentity_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) GetOpenGLSubMatrix(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btMatrix3x3_getOpenGLSubMatrix_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtMatrix3x3) GetRotation(arg2 BtQuaternion) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMatrix3x3_getRotation_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMatrix3x3) GetEulerYPR(arg2 *float32, arg3 *float32, arg4 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btMatrix3x3_getEulerYPR_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3)) +} + +func (arg1 SwigcptrBtMatrix3x3) GetEulerZYX__SWIG_0(arg2 *float32, arg3 *float32, arg4 *float32, arg5 uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btMatrix3x3_getEulerZYX__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.swig_intgo(_swig_i_4)) +} + +func (arg1 SwigcptrBtMatrix3x3) GetEulerZYX__SWIG_1(arg2 *float32, arg3 *float32, arg4 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btMatrix3x3_getEulerZYX__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3)) +} + +func (p SwigcptrBtMatrix3x3) GetEulerZYX(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.GetEulerZYX__SWIG_1(a[0].(*float32), a[1].(*float32), a[2].(*float32)) + return + } + if argc == 4 { + p.GetEulerZYX__SWIG_0(a[0].(*float32), a[1].(*float32), a[2].(*float32), a[3].(uint)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMatrix3x3) Scaled(arg2 BtVector3) (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btMatrix3x3_scaled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) Determinant() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btMatrix3x3_determinant_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) Adjoint() (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btMatrix3x3_adjoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) Absolute() (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btMatrix3x3_absolute_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) Transpose() (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btMatrix3x3_transpose_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) Inverse() (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btMatrix3x3_inverse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) Solve33(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btMatrix3x3_solve33_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) TransposeTimes(arg2 BtMatrix3x3) (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btMatrix3x3_transposeTimes_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) TimesTranspose(arg2 BtMatrix3x3) (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btMatrix3x3_timesTranspose_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) Tdotx(arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btMatrix3x3_tdotx_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) Tdoty(arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btMatrix3x3_tdoty_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) Tdotz(arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btMatrix3x3_tdotz_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) ExtractRotation__SWIG_0(arg2 BtQuaternion, arg3 float32, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btMatrix3x3_extractRotation__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtMatrix3x3) ExtractRotation__SWIG_1(arg2 BtQuaternion, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btMatrix3x3_extractRotation__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtMatrix3x3) ExtractRotation__SWIG_2(arg2 BtQuaternion) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMatrix3x3_extractRotation__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtMatrix3x3) ExtractRotation(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.ExtractRotation__SWIG_2(a[0].(BtQuaternion)) + return + } + if argc == 2 { + p.ExtractRotation__SWIG_1(a[0].(BtQuaternion), a[1].(float32)) + return + } + if argc == 3 { + p.ExtractRotation__SWIG_0(a[0].(BtQuaternion), a[1].(float32), a[2].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMatrix3x3) Diagonalize(arg2 BtMatrix3x3, arg3 float32, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btMatrix3x3_diagonalize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtMatrix3x3) Cofac(arg2 int, arg3 int, arg4 int, arg5 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + swig_r = (float32)(C._wrap_btMatrix3x3_cofac_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.swig_intgo(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtMatrix3x3) Serialize(arg2 BtMatrix3x3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMatrix3x3_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMatrix3x3) SerializeFloat(arg2 BtMatrix3x3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMatrix3x3_serializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMatrix3x3) DeSerialize(arg2 BtMatrix3x3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMatrix3x3_deSerialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMatrix3x3) DeSerializeFloat(arg2 BtMatrix3x3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMatrix3x3_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMatrix3x3) DeSerializeDouble(arg2 BtMatrix3x3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMatrix3x3_deSerializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBtMatrix3x3(arg1 BtMatrix3x3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMatrix3x3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtMatrix3x3 interface { + Swigcptr() uintptr + SwigIsBtMatrix3x3() + GetColumn(arg2 int) (_swig_ret BtVector3) + GetRow(arg2 int) (_swig_ret BtVector3) + SetFromOpenGLSubMatrix(arg2 *float32) + SetValue(arg2 float32, arg3 float32, arg4 float32, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 float32, arg10 float32) + SetRotation(arg2 BtQuaternion) + SetEulerYPR(arg2 float32, arg3 float32, arg4 float32) + SetEulerZYX(arg2 float32, arg3 float32, arg4 float32) + SetIdentity() + SetZero() + GetOpenGLSubMatrix(arg2 *float32) + GetRotation(arg2 BtQuaternion) + GetEulerYPR(arg2 *float32, arg3 *float32, arg4 *float32) + GetEulerZYX(a ...interface{}) + Scaled(arg2 BtVector3) (_swig_ret BtMatrix3x3) + Determinant() (_swig_ret float32) + Adjoint() (_swig_ret BtMatrix3x3) + Absolute() (_swig_ret BtMatrix3x3) + Transpose() (_swig_ret BtMatrix3x3) + Inverse() (_swig_ret BtMatrix3x3) + Solve33(arg2 BtVector3) (_swig_ret BtVector3) + TransposeTimes(arg2 BtMatrix3x3) (_swig_ret BtMatrix3x3) + TimesTranspose(arg2 BtMatrix3x3) (_swig_ret BtMatrix3x3) + Tdotx(arg2 BtVector3) (_swig_ret float32) + Tdoty(arg2 BtVector3) (_swig_ret float32) + Tdotz(arg2 BtVector3) (_swig_ret float32) + ExtractRotation(a ...interface{}) + Diagonalize(arg2 BtMatrix3x3, arg3 float32, arg4 int) + Cofac(arg2 int, arg3 int, arg4 int, arg5 int) (_swig_ret float32) + Serialize(arg2 BtMatrix3x3FloatData) + SerializeFloat(arg2 BtMatrix3x3FloatData) + DeSerialize(arg2 BtMatrix3x3FloatData) + DeSerializeFloat(arg2 BtMatrix3x3FloatData) + DeSerializeDouble(arg2 BtMatrix3x3DoubleData) +} + +type SwigcptrBtMatrix3x3FloatData uintptr + +func (p SwigcptrBtMatrix3x3FloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMatrix3x3FloatData) SwigIsBtMatrix3x3FloatData() { +} + +func (arg1 SwigcptrBtMatrix3x3FloatData) SetM_el(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMatrix3x3FloatData_m_el_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMatrix3x3FloatData) GetM_el() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btMatrix3x3FloatData_m_el_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtMatrix3x3FloatData() (_swig_ret BtMatrix3x3FloatData) { + var swig_r BtMatrix3x3FloatData + swig_r = (BtMatrix3x3FloatData)(SwigcptrBtMatrix3x3FloatData(C._wrap_new_btMatrix3x3FloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtMatrix3x3FloatData(arg1 BtMatrix3x3FloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMatrix3x3FloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtMatrix3x3FloatData interface { + Swigcptr() uintptr + SwigIsBtMatrix3x3FloatData() + SetM_el(arg2 BtVector3FloatData) + GetM_el() (_swig_ret BtVector3FloatData) +} + +type SwigcptrBtMatrix3x3DoubleData uintptr + +func (p SwigcptrBtMatrix3x3DoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMatrix3x3DoubleData) SwigIsBtMatrix3x3DoubleData() { +} + +func (arg1 SwigcptrBtMatrix3x3DoubleData) SetM_el(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMatrix3x3DoubleData_m_el_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMatrix3x3DoubleData) GetM_el() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btMatrix3x3DoubleData_m_el_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtMatrix3x3DoubleData() (_swig_ret BtMatrix3x3DoubleData) { + var swig_r BtMatrix3x3DoubleData + swig_r = (BtMatrix3x3DoubleData)(SwigcptrBtMatrix3x3DoubleData(C._wrap_new_btMatrix3x3DoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtMatrix3x3DoubleData(arg1 BtMatrix3x3DoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMatrix3x3DoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtMatrix3x3DoubleData interface { + Swigcptr() uintptr + SwigIsBtMatrix3x3DoubleData() + SetM_el(arg2 BtVector3DoubleData) + GetM_el() (_swig_ret BtVector3DoubleData) +} + +type SwigcptrBtTransform uintptr + +func (p SwigcptrBtTransform) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTransform) SwigIsBtTransform() { +} + +func NewBtTransform__SWIG_0() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_new_btTransform__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtTransform__SWIG_1(arg1 BtQuaternion, arg2 BtVector3) (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_new_btTransform__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func NewBtTransform__SWIG_2(arg1 BtQuaternion) (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_new_btTransform__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtTransform__SWIG_3(arg1 BtMatrix3x3, arg2 BtVector3) (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_new_btTransform__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func NewBtTransform__SWIG_4(arg1 BtMatrix3x3) (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_new_btTransform__SWIG_4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtTransform__SWIG_5(arg1 BtTransform) (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_new_btTransform__SWIG_5_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtTransform(a ...interface{}) BtTransform { + argc := len(a) + if argc == 0 { + return NewBtTransform__SWIG_0() + } + if argc == 1 { + if _, ok := a[0].(BtQuaternion); !ok { + goto check_2 + } + return NewBtTransform__SWIG_2(a[0].(BtQuaternion)) + } +check_2: + if argc == 1 { + if _, ok := a[0].(BtMatrix3x3); !ok { + goto check_3 + } + return NewBtTransform__SWIG_4(a[0].(BtMatrix3x3)) + } +check_3: + if argc == 1 { + return NewBtTransform__SWIG_5(a[0].(BtTransform)) + } + if argc == 2 { + if _, ok := a[0].(BtQuaternion); !ok { + goto check_5 + } + return NewBtTransform__SWIG_1(a[0].(BtQuaternion), a[1].(BtVector3)) + } +check_5: + if argc == 2 { + return NewBtTransform__SWIG_3(a[0].(BtMatrix3x3), a[1].(BtVector3)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtTransform) Mult(arg2 BtTransform, arg3 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btTransform_mult_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtTransform) GetBasis__SWIG_0() (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btTransform_getBasis__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTransform) GetBasis__SWIG_1() (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btTransform_getBasis__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtTransform) GetBasis(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetBasis__SWIG_0() + } + if argc == 0 { + return p.GetBasis__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtTransform) GetOrigin__SWIG_0() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTransform_getOrigin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTransform) GetOrigin__SWIG_1() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTransform_getOrigin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtTransform) GetOrigin(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOrigin__SWIG_0() + } + if argc == 0 { + return p.GetOrigin__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtTransform) GetRotation() (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btTransform_getRotation_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTransform) SetFromOpenGLMatrix(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTransform_setFromOpenGLMatrix_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransform) GetOpenGLMatrix(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTransform_getOpenGLMatrix_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransform) SetOrigin(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransform_setOrigin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransform) InvXform(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTransform_invXform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtTransform) SetBasis(arg2 BtMatrix3x3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransform_setBasis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransform) SetRotation(arg2 BtQuaternion) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransform_setRotation_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransform) SetIdentity() { + _swig_i_0 := arg1 + C._wrap_btTransform_setIdentity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtTransform) Inverse() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btTransform_inverse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTransform) InverseTimes(arg2 BtTransform) (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btTransform_inverseTimes_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func BtTransformGetIdentity() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btTransform_getIdentity_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtTransform) Serialize(arg2 BtTransformFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransform_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransform) SerializeFloat(arg2 BtTransformFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransform_serializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransform) DeSerialize(arg2 BtTransformFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransform_deSerialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransform) DeSerializeDouble(arg2 BtTransformDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransform_deSerializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransform) DeSerializeFloat(arg2 BtTransformFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransform_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBtTransform(arg1 BtTransform) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTransform interface { + Swigcptr() uintptr + SwigIsBtTransform() + Mult(arg2 BtTransform, arg3 BtTransform) + GetBasis(a ...interface{}) interface{} + GetOrigin(a ...interface{}) interface{} + GetRotation() (_swig_ret BtQuaternion) + SetFromOpenGLMatrix(arg2 *float32) + GetOpenGLMatrix(arg2 *float32) + SetOrigin(arg2 BtVector3) + InvXform(arg2 BtVector3) (_swig_ret BtVector3) + SetBasis(arg2 BtMatrix3x3) + SetRotation(arg2 BtQuaternion) + SetIdentity() + Inverse() (_swig_ret BtTransform) + InverseTimes(arg2 BtTransform) (_swig_ret BtTransform) + Serialize(arg2 BtTransformFloatData) + SerializeFloat(arg2 BtTransformFloatData) + DeSerialize(arg2 BtTransformFloatData) + DeSerializeDouble(arg2 BtTransformDoubleData) + DeSerializeFloat(arg2 BtTransformFloatData) +} + +type SwigcptrBtTransformFloatData uintptr + +func (p SwigcptrBtTransformFloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTransformFloatData) SwigIsBtTransformFloatData() { +} + +func (arg1 SwigcptrBtTransformFloatData) SetM_basis(arg2 BtMatrix3x3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransformFloatData_m_basis_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransformFloatData) GetM_basis() (_swig_ret BtMatrix3x3FloatData) { + var swig_r BtMatrix3x3FloatData + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3FloatData)(SwigcptrBtMatrix3x3FloatData(C._wrap_btTransformFloatData_m_basis_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTransformFloatData) SetM_origin(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransformFloatData_m_origin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransformFloatData) GetM_origin() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btTransformFloatData_m_origin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtTransformFloatData() (_swig_ret BtTransformFloatData) { + var swig_r BtTransformFloatData + swig_r = (BtTransformFloatData)(SwigcptrBtTransformFloatData(C._wrap_new_btTransformFloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtTransformFloatData(arg1 BtTransformFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTransformFloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTransformFloatData interface { + Swigcptr() uintptr + SwigIsBtTransformFloatData() + SetM_basis(arg2 BtMatrix3x3FloatData) + GetM_basis() (_swig_ret BtMatrix3x3FloatData) + SetM_origin(arg2 BtVector3FloatData) + GetM_origin() (_swig_ret BtVector3FloatData) +} + +type SwigcptrBtTransformDoubleData uintptr + +func (p SwigcptrBtTransformDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTransformDoubleData) SwigIsBtTransformDoubleData() { +} + +func (arg1 SwigcptrBtTransformDoubleData) SetM_basis(arg2 BtMatrix3x3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransformDoubleData_m_basis_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransformDoubleData) GetM_basis() (_swig_ret BtMatrix3x3DoubleData) { + var swig_r BtMatrix3x3DoubleData + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3DoubleData)(SwigcptrBtMatrix3x3DoubleData(C._wrap_btTransformDoubleData_m_basis_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTransformDoubleData) SetM_origin(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTransformDoubleData_m_origin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTransformDoubleData) GetM_origin() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btTransformDoubleData_m_origin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtTransformDoubleData() (_swig_ret BtTransformDoubleData) { + var swig_r BtTransformDoubleData + swig_r = (BtTransformDoubleData)(SwigcptrBtTransformDoubleData(C._wrap_new_btTransformDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtTransformDoubleData(arg1 BtTransformDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTransformDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTransformDoubleData interface { + Swigcptr() uintptr + SwigIsBtTransformDoubleData() + SetM_basis(arg2 BtMatrix3x3DoubleData) + GetM_basis() (_swig_ret BtMatrix3x3DoubleData) + SetM_origin(arg2 BtVector3DoubleData) + GetM_origin() (_swig_ret BtVector3DoubleData) +} + +type SwigcptrBtMotionState uintptr + +func (p SwigcptrBtMotionState) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMotionState) SwigIsBtMotionState() { +} + +func DeleteBtMotionState(arg1 BtMotionState) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMotionState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtMotionState) GetWorldTransform(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMotionState_getWorldTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMotionState) SetWorldTransform(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMotionState_setWorldTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +type BtMotionState interface { + Swigcptr() uintptr + SwigIsBtMotionState() + GetWorldTransform(arg2 BtTransform) + SetWorldTransform(arg2 BtTransform) +} + +type SwigcptrBtDefaultMotionState uintptr + +func (p SwigcptrBtDefaultMotionState) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDefaultMotionState) SwigIsBtDefaultMotionState() { +} + +func (arg1 SwigcptrBtDefaultMotionState) SetM_graphicsWorldTrans(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDefaultMotionState_m_graphicsWorldTrans_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultMotionState) GetM_graphicsWorldTrans() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btDefaultMotionState_m_graphicsWorldTrans_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultMotionState) SetM_centerOfMassOffset(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDefaultMotionState_m_centerOfMassOffset_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultMotionState) GetM_centerOfMassOffset() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btDefaultMotionState_m_centerOfMassOffset_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultMotionState) SetM_startWorldTrans(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDefaultMotionState_m_startWorldTrans_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultMotionState) GetM_startWorldTrans() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btDefaultMotionState_m_startWorldTrans_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultMotionState) SetM_userPointer(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDefaultMotionState_m_userPointer_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultMotionState) GetM_userPointer() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btDefaultMotionState_m_userPointer_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtDefaultMotionState__SWIG_0(arg1 BtTransform, arg2 BtTransform) (_swig_ret BtDefaultMotionState) { + var swig_r BtDefaultMotionState + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtDefaultMotionState)(SwigcptrBtDefaultMotionState(C._wrap_new_btDefaultMotionState__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func NewBtDefaultMotionState__SWIG_1(arg1 BtTransform) (_swig_ret BtDefaultMotionState) { + var swig_r BtDefaultMotionState + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtDefaultMotionState)(SwigcptrBtDefaultMotionState(C._wrap_new_btDefaultMotionState__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtDefaultMotionState__SWIG_2() (_swig_ret BtDefaultMotionState) { + var swig_r BtDefaultMotionState + swig_r = (BtDefaultMotionState)(SwigcptrBtDefaultMotionState(C._wrap_new_btDefaultMotionState__SWIG_2_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtDefaultMotionState(a ...interface{}) BtDefaultMotionState { + argc := len(a) + if argc == 0 { + return NewBtDefaultMotionState__SWIG_2() + } + if argc == 1 { + return NewBtDefaultMotionState__SWIG_1(a[0].(BtTransform)) + } + if argc == 2 { + return NewBtDefaultMotionState__SWIG_0(a[0].(BtTransform), a[1].(BtTransform)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDefaultMotionState) GetWorldTransform(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDefaultMotionState_getWorldTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultMotionState) SetWorldTransform(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDefaultMotionState_setWorldTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBtDefaultMotionState(arg1 BtDefaultMotionState) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDefaultMotionState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtDefaultMotionState) SwigIsBtMotionState() { +} + +func (p SwigcptrBtDefaultMotionState) SwigGetBtMotionState() BtMotionState { + return SwigcptrBtMotionState(getSwigcptr(p)) +} + +type BtDefaultMotionState interface { + Swigcptr() uintptr + SwigIsBtDefaultMotionState() + SetM_graphicsWorldTrans(arg2 BtTransform) + GetM_graphicsWorldTrans() (_swig_ret BtTransform) + SetM_centerOfMassOffset(arg2 BtTransform) + GetM_centerOfMassOffset() (_swig_ret BtTransform) + SetM_startWorldTrans(arg2 BtTransform) + GetM_startWorldTrans() (_swig_ret BtTransform) + SetM_userPointer(arg2 uintptr) + GetM_userPointer() (_swig_ret uintptr) + GetWorldTransform(arg2 BtTransform) + SetWorldTransform(arg2 BtTransform) + SwigIsBtMotionState() + SwigGetBtMotionState() BtMotionState +} + +type BroadphaseNativeTypes int + +func _swig_getBOX_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_BOX_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var BOX_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getBOX_SHAPE_PROXYTYPE() + +func _swig_getTRIANGLE_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_TRIANGLE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var TRIANGLE_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getTRIANGLE_SHAPE_PROXYTYPE() + +func _swig_getTETRAHEDRAL_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_TETRAHEDRAL_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var TETRAHEDRAL_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getTETRAHEDRAL_SHAPE_PROXYTYPE() + +func _swig_getCONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getCONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE() + +func _swig_getCONVEX_HULL_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CONVEX_HULL_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CONVEX_HULL_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getCONVEX_HULL_SHAPE_PROXYTYPE() + +func _swig_getCONVEX_POINT_CLOUD_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getCONVEX_POINT_CLOUD_SHAPE_PROXYTYPE() + +func _swig_getCUSTOM_POLYHEDRAL_SHAPE_TYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CUSTOM_POLYHEDRAL_SHAPE_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CUSTOM_POLYHEDRAL_SHAPE_TYPE BroadphaseNativeTypes = _swig_getCUSTOM_POLYHEDRAL_SHAPE_TYPE() + +func _swig_getIMPLICIT_CONVEX_SHAPES_START_HERE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_IMPLICIT_CONVEX_SHAPES_START_HERE_mbt_e879218550ba2e2b()) + return swig_r +} + +var IMPLICIT_CONVEX_SHAPES_START_HERE BroadphaseNativeTypes = _swig_getIMPLICIT_CONVEX_SHAPES_START_HERE() + +func _swig_getSPHERE_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_SPHERE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var SPHERE_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getSPHERE_SHAPE_PROXYTYPE() + +func _swig_getMULTI_SPHERE_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_MULTI_SPHERE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var MULTI_SPHERE_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getMULTI_SPHERE_SHAPE_PROXYTYPE() + +func _swig_getCAPSULE_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CAPSULE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CAPSULE_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getCAPSULE_SHAPE_PROXYTYPE() + +func _swig_getCONE_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CONE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CONE_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getCONE_SHAPE_PROXYTYPE() + +func _swig_getCONVEX_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CONVEX_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CONVEX_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getCONVEX_SHAPE_PROXYTYPE() + +func _swig_getCYLINDER_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CYLINDER_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CYLINDER_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getCYLINDER_SHAPE_PROXYTYPE() + +func _swig_getUNIFORM_SCALING_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_UNIFORM_SCALING_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var UNIFORM_SCALING_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getUNIFORM_SCALING_SHAPE_PROXYTYPE() + +func _swig_getMINKOWSKI_SUM_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_MINKOWSKI_SUM_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var MINKOWSKI_SUM_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getMINKOWSKI_SUM_SHAPE_PROXYTYPE() + +func _swig_getMINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getMINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE() + +func _swig_getBOX_2D_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_BOX_2D_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var BOX_2D_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getBOX_2D_SHAPE_PROXYTYPE() + +func _swig_getCONVEX_2D_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CONVEX_2D_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CONVEX_2D_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getCONVEX_2D_SHAPE_PROXYTYPE() + +func _swig_getCUSTOM_CONVEX_SHAPE_TYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CUSTOM_CONVEX_SHAPE_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CUSTOM_CONVEX_SHAPE_TYPE BroadphaseNativeTypes = _swig_getCUSTOM_CONVEX_SHAPE_TYPE() + +func _swig_getCONCAVE_SHAPES_START_HERE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CONCAVE_SHAPES_START_HERE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CONCAVE_SHAPES_START_HERE BroadphaseNativeTypes = _swig_getCONCAVE_SHAPES_START_HERE() + +func _swig_getTRIANGLE_MESH_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_TRIANGLE_MESH_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var TRIANGLE_MESH_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getTRIANGLE_MESH_SHAPE_PROXYTYPE() + +func _swig_getSCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getSCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE() + +func _swig_getFAST_CONCAVE_MESH_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_FAST_CONCAVE_MESH_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var FAST_CONCAVE_MESH_PROXYTYPE BroadphaseNativeTypes = _swig_getFAST_CONCAVE_MESH_PROXYTYPE() + +func _swig_getTERRAIN_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_TERRAIN_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var TERRAIN_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getTERRAIN_SHAPE_PROXYTYPE() + +func _swig_getGIMPACT_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_GIMPACT_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var GIMPACT_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getGIMPACT_SHAPE_PROXYTYPE() + +func _swig_getMULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE BroadphaseNativeTypes = _swig_getMULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE() + +func _swig_getEMPTY_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_EMPTY_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var EMPTY_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getEMPTY_SHAPE_PROXYTYPE() + +func _swig_getSTATIC_PLANE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_STATIC_PLANE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var STATIC_PLANE_PROXYTYPE BroadphaseNativeTypes = _swig_getSTATIC_PLANE_PROXYTYPE() + +func _swig_getCUSTOM_CONCAVE_SHAPE_TYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CUSTOM_CONCAVE_SHAPE_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CUSTOM_CONCAVE_SHAPE_TYPE BroadphaseNativeTypes = _swig_getCUSTOM_CONCAVE_SHAPE_TYPE() + +func _swig_getSDF_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_SDF_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var SDF_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getSDF_SHAPE_PROXYTYPE() + +func _swig_getCONCAVE_SHAPES_END_HERE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_CONCAVE_SHAPES_END_HERE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CONCAVE_SHAPES_END_HERE BroadphaseNativeTypes = _swig_getCONCAVE_SHAPES_END_HERE() + +func _swig_getCOMPOUND_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_COMPOUND_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var COMPOUND_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getCOMPOUND_SHAPE_PROXYTYPE() + +func _swig_getSOFTBODY_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_SOFTBODY_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOFTBODY_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getSOFTBODY_SHAPE_PROXYTYPE() + +func _swig_getHFFLUID_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_HFFLUID_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var HFFLUID_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getHFFLUID_SHAPE_PROXYTYPE() + +func _swig_getHFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getHFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE() + +func _swig_getINVALID_SHAPE_PROXYTYPE() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_INVALID_SHAPE_PROXYTYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var INVALID_SHAPE_PROXYTYPE BroadphaseNativeTypes = _swig_getINVALID_SHAPE_PROXYTYPE() + +func _swig_getMAX_BROADPHASE_COLLISION_TYPES() (_swig_ret BroadphaseNativeTypes) { + var swig_r BroadphaseNativeTypes + swig_r = (BroadphaseNativeTypes)(C._wrap_MAX_BROADPHASE_COLLISION_TYPES_mbt_e879218550ba2e2b()) + return swig_r +} + +var MAX_BROADPHASE_COLLISION_TYPES BroadphaseNativeTypes = _swig_getMAX_BROADPHASE_COLLISION_TYPES() + +type SwigcptrBtBroadphaseProxy uintptr + +func (p SwigcptrBtBroadphaseProxy) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBroadphaseProxy) SwigIsBtBroadphaseProxy() { +} + +type BtBroadphaseProxyCollisionFilterGroups int + +func _swig_getbtBroadphaseProxy_DefaultFilter_btBroadphaseProxy() (_swig_ret BtBroadphaseProxyCollisionFilterGroups) { + var swig_r BtBroadphaseProxyCollisionFilterGroups + swig_r = (BtBroadphaseProxyCollisionFilterGroups)(C._wrap_DefaultFilter_btBroadphaseProxy_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtBroadphaseProxyDefaultFilter BtBroadphaseProxyCollisionFilterGroups = _swig_getbtBroadphaseProxy_DefaultFilter_btBroadphaseProxy() + +func _swig_getbtBroadphaseProxy_StaticFilter_btBroadphaseProxy() (_swig_ret BtBroadphaseProxyCollisionFilterGroups) { + var swig_r BtBroadphaseProxyCollisionFilterGroups + swig_r = (BtBroadphaseProxyCollisionFilterGroups)(C._wrap_StaticFilter_btBroadphaseProxy_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtBroadphaseProxyStaticFilter BtBroadphaseProxyCollisionFilterGroups = _swig_getbtBroadphaseProxy_StaticFilter_btBroadphaseProxy() + +func _swig_getbtBroadphaseProxy_KinematicFilter_btBroadphaseProxy() (_swig_ret BtBroadphaseProxyCollisionFilterGroups) { + var swig_r BtBroadphaseProxyCollisionFilterGroups + swig_r = (BtBroadphaseProxyCollisionFilterGroups)(C._wrap_KinematicFilter_btBroadphaseProxy_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtBroadphaseProxyKinematicFilter BtBroadphaseProxyCollisionFilterGroups = _swig_getbtBroadphaseProxy_KinematicFilter_btBroadphaseProxy() + +func _swig_getbtBroadphaseProxy_DebrisFilter_btBroadphaseProxy() (_swig_ret BtBroadphaseProxyCollisionFilterGroups) { + var swig_r BtBroadphaseProxyCollisionFilterGroups + swig_r = (BtBroadphaseProxyCollisionFilterGroups)(C._wrap_DebrisFilter_btBroadphaseProxy_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtBroadphaseProxyDebrisFilter BtBroadphaseProxyCollisionFilterGroups = _swig_getbtBroadphaseProxy_DebrisFilter_btBroadphaseProxy() + +func _swig_getbtBroadphaseProxy_SensorTrigger_btBroadphaseProxy() (_swig_ret BtBroadphaseProxyCollisionFilterGroups) { + var swig_r BtBroadphaseProxyCollisionFilterGroups + swig_r = (BtBroadphaseProxyCollisionFilterGroups)(C._wrap_SensorTrigger_btBroadphaseProxy_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtBroadphaseProxySensorTrigger BtBroadphaseProxyCollisionFilterGroups = _swig_getbtBroadphaseProxy_SensorTrigger_btBroadphaseProxy() + +func _swig_getbtBroadphaseProxy_CharacterFilter_btBroadphaseProxy() (_swig_ret BtBroadphaseProxyCollisionFilterGroups) { + var swig_r BtBroadphaseProxyCollisionFilterGroups + swig_r = (BtBroadphaseProxyCollisionFilterGroups)(C._wrap_CharacterFilter_btBroadphaseProxy_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtBroadphaseProxyCharacterFilter BtBroadphaseProxyCollisionFilterGroups = _swig_getbtBroadphaseProxy_CharacterFilter_btBroadphaseProxy() + +func _swig_getbtBroadphaseProxy_AllFilter_btBroadphaseProxy() (_swig_ret BtBroadphaseProxyCollisionFilterGroups) { + var swig_r BtBroadphaseProxyCollisionFilterGroups + swig_r = (BtBroadphaseProxyCollisionFilterGroups)(C._wrap_AllFilter_btBroadphaseProxy_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtBroadphaseProxyAllFilter BtBroadphaseProxyCollisionFilterGroups = _swig_getbtBroadphaseProxy_AllFilter_btBroadphaseProxy() + +func (arg1 SwigcptrBtBroadphaseProxy) SetM_clientObject(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBroadphaseProxy_m_clientObject_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseProxy) GetM_clientObject() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btBroadphaseProxy_m_clientObject_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphaseProxy) SetM_collisionFilterGroup(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBroadphaseProxy_m_collisionFilterGroup_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseProxy) GetM_collisionFilterGroup() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBroadphaseProxy_m_collisionFilterGroup_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphaseProxy) SetM_collisionFilterMask(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBroadphaseProxy_m_collisionFilterMask_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseProxy) GetM_collisionFilterMask() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBroadphaseProxy_m_collisionFilterMask_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphaseProxy) SetM_uniqueId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBroadphaseProxy_m_uniqueId_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseProxy) GetM_uniqueId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBroadphaseProxy_m_uniqueId_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphaseProxy) SetM_aabbMin(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBroadphaseProxy_m_aabbMin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseProxy) GetM_aabbMin() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBroadphaseProxy_m_aabbMin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphaseProxy) SetM_aabbMax(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBroadphaseProxy_m_aabbMax_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseProxy) GetM_aabbMax() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBroadphaseProxy_m_aabbMax_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphaseProxy) GetUid() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBroadphaseProxy_getUid_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtBroadphaseProxy__SWIG_0() (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_new_btBroadphaseProxy__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtBroadphaseProxy__SWIG_1(arg1 BtVector3, arg2 BtVector3, arg3 uintptr, arg4 int, arg5 int) (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_new_btBroadphaseProxy__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3), C.swig_intgo(_swig_i_4)))) + return swig_r +} + +func NewBtBroadphaseProxy(a ...interface{}) BtBroadphaseProxy { + argc := len(a) + if argc == 0 { + return NewBtBroadphaseProxy__SWIG_0() + } + if argc == 5 { + return NewBtBroadphaseProxy__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(uintptr), a[3].(int), a[4].(int)) + } + panic("No match for overloaded function call") +} + +func BtBroadphaseProxyIsPolyhedral(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBroadphaseProxy_isPolyhedral_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtBroadphaseProxyIsConvex(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBroadphaseProxy_isConvex_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtBroadphaseProxyIsNonMoving(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBroadphaseProxy_isNonMoving_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtBroadphaseProxyIsConcave(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBroadphaseProxy_isConcave_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtBroadphaseProxyIsCompound(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBroadphaseProxy_isCompound_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtBroadphaseProxyIsSoftBody(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBroadphaseProxy_isSoftBody_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtBroadphaseProxyIsInfinite(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBroadphaseProxy_isInfinite_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtBroadphaseProxyIsConvex2d(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBroadphaseProxy_isConvex2d_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func DeleteBtBroadphaseProxy(arg1 BtBroadphaseProxy) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBroadphaseProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtBroadphaseProxy interface { + Swigcptr() uintptr + SwigIsBtBroadphaseProxy() + SetM_clientObject(arg2 uintptr) + GetM_clientObject() (_swig_ret uintptr) + SetM_collisionFilterGroup(arg2 int) + GetM_collisionFilterGroup() (_swig_ret int) + SetM_collisionFilterMask(arg2 int) + GetM_collisionFilterMask() (_swig_ret int) + SetM_uniqueId(arg2 int) + GetM_uniqueId() (_swig_ret int) + SetM_aabbMin(arg2 BtVector3) + GetM_aabbMin() (_swig_ret BtVector3) + SetM_aabbMax(arg2 BtVector3) + GetM_aabbMax() (_swig_ret BtVector3) + GetUid() (_swig_ret int) +} + +type SwigcptrBtBroadphasePair uintptr + +func (p SwigcptrBtBroadphasePair) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBroadphasePair) SwigIsBtBroadphasePair() { +} + +func NewBtBroadphasePair__SWIG_0() (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_new_btBroadphasePair__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtBroadphasePair__SWIG_1(arg1 BtBroadphaseProxy, arg2 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_new_btBroadphasePair__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func NewBtBroadphasePair(a ...interface{}) BtBroadphasePair { + argc := len(a) + if argc == 0 { + return NewBtBroadphasePair__SWIG_0() + } + if argc == 2 { + return NewBtBroadphasePair__SWIG_1(a[0].(BtBroadphaseProxy), a[1].(BtBroadphaseProxy)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtBroadphasePair) SetM_pProxy0(arg2 BtBroadphaseProxy) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBroadphasePair_m_pProxy0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphasePair) GetM_pProxy0() (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + _swig_i_0 := arg1 + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_btBroadphasePair_m_pProxy0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphasePair) SetM_pProxy1(arg2 BtBroadphaseProxy) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBroadphasePair_m_pProxy1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphasePair) GetM_pProxy1() (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + _swig_i_0 := arg1 + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_btBroadphasePair_m_pProxy1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphasePair) SetM_algorithm(arg2 BtCollisionAlgorithm) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBroadphasePair_m_algorithm_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphasePair) GetM_algorithm() (_swig_ret BtCollisionAlgorithm) { + var swig_r BtCollisionAlgorithm + _swig_i_0 := arg1 + swig_r = (BtCollisionAlgorithm)(SwigcptrBtCollisionAlgorithm(C._wrap_btBroadphasePair_m_algorithm_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func DeleteBtBroadphasePair(arg1 BtBroadphasePair) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBroadphasePair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtBroadphasePair interface { + Swigcptr() uintptr + SwigIsBtBroadphasePair() + SetM_pProxy0(arg2 BtBroadphaseProxy) + GetM_pProxy0() (_swig_ret BtBroadphaseProxy) + SetM_pProxy1(arg2 BtBroadphaseProxy) + GetM_pProxy1() (_swig_ret BtBroadphaseProxy) + SetM_algorithm(arg2 BtCollisionAlgorithm) + GetM_algorithm() (_swig_ret BtCollisionAlgorithm) +} + +type SwigcptrBtBroadphasePairSortPredicate uintptr + +func (p SwigcptrBtBroadphasePairSortPredicate) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBroadphasePairSortPredicate) SwigIsBtBroadphasePairSortPredicate() { +} + +func NewBtBroadphasePairSortPredicate() (_swig_ret BtBroadphasePairSortPredicate) { + var swig_r BtBroadphasePairSortPredicate + swig_r = (BtBroadphasePairSortPredicate)(SwigcptrBtBroadphasePairSortPredicate(C._wrap_new_btBroadphasePairSortPredicate_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtBroadphasePairSortPredicate(arg1 BtBroadphasePairSortPredicate) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBroadphasePairSortPredicate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtBroadphasePairSortPredicate interface { + Swigcptr() uintptr + SwigIsBtBroadphasePairSortPredicate() +} + +type SwigcptrBtCollisionShape uintptr + +func (p SwigcptrBtCollisionShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionShape) SwigIsBtCollisionShape() { +} + +func DeleteBtCollisionShape(arg1 BtCollisionShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btCollisionShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtCollisionShape) GetBoundingSphere(arg2 BtVector3, arg3 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btCollisionShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2)) +} + +func (arg1 SwigcptrBtCollisionShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) GetContactBreakingThreshold(arg2 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btCollisionShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) CalculateTemporalAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 BtVector3, arg7 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + C._wrap_btCollisionShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6)) +} + +func (arg1 SwigcptrBtCollisionShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) IsConvex() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) IsConcave() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) IsCompound() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCollisionShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) CalculateLocalInertia(arg2 float32, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCollisionShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtCollisionShape) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btCollisionShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtCollisionShape) GetShapeType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCollisionShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) SetMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) SetUserPointer(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btCollisionShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) SetUserIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionShape) GetUserIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) SetUserIndex2(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShape) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btCollisionShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtCollisionShape) SerializeSingleShape(arg2 BtSerializer) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +type BtCollisionShape interface { + Swigcptr() uintptr + SwigIsBtCollisionShape() + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + GetBoundingSphere(arg2 BtVector3, arg3 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg2 float32) (_swig_ret float32) + CalculateTemporalAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 BtVector3, arg7 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + SetLocalScaling(arg2 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + CalculateLocalInertia(arg2 float32, arg3 BtVector3) + GetName() (_swig_ret string) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetMargin(arg2 float32) + GetMargin() (_swig_ret float32) + SetUserPointer(arg2 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg2 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg2 int) + GetUserIndex2() (_swig_ret int) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + SerializeSingleShape(arg2 BtSerializer) +} + +type SwigcptrBtCollisionShapeData uintptr + +func (p SwigcptrBtCollisionShapeData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionShapeData) SwigIsBtCollisionShapeData() { +} + +func (arg1 SwigcptrBtCollisionShapeData) SetM_name(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionShapeData_m_name_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_26)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtCollisionShapeData) GetM_name() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btCollisionShapeData_m_name_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtCollisionShapeData) SetM_shapeType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionShapeData_m_shapeType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionShapeData) GetM_shapeType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionShapeData_m_shapeType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionShapeData) SetM_padding(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionShapeData_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_28)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtCollisionShapeData) GetM_padding() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btCollisionShapeData_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtCollisionShapeData() (_swig_ret BtCollisionShapeData) { + var swig_r BtCollisionShapeData + swig_r = (BtCollisionShapeData)(SwigcptrBtCollisionShapeData(C._wrap_new_btCollisionShapeData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtCollisionShapeData(arg1 BtCollisionShapeData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionShapeData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtCollisionShapeData interface { + Swigcptr() uintptr + SwigIsBtCollisionShapeData() + SetM_name(arg2 string) + GetM_name() (_swig_ret string) + SetM_shapeType(arg2 int) + GetM_shapeType() (_swig_ret int) + SetM_padding(arg2 string) + GetM_padding() (_swig_ret string) +} + +func BtBulletCollisionProbe() { + C._wrap_btBulletCollisionProbe_mbt_e879218550ba2e2b() +} + +const MAX_PREFERRED_PENETRATION_DIRECTIONS int = 10 + +type SwigcptrBtConvexShape uintptr + +func (p SwigcptrBtConvexShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexShape) SwigIsBtConvexShape() { +} + +func DeleteBtConvexShape(arg1 BtConvexShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexShape) LocalGetSupportingVertex(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexShape_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexShape) LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexShape) LocalGetSupportVertexWithoutMarginNonVirtual(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexShape) LocalGetSupportVertexNonVirtual(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexShape) GetMarginNonVirtual() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConvexShape_getMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexShape) GetAabbNonVirtual(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btConvexShape_getAabbNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtConvexShape) Project(arg2 BtTransform, arg3 BtVector3, arg4 *float32, arg5 *float32, arg6 BtVector3, arg7 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + C._wrap_btConvexShape_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_voidp(_swig_i_3), C.swig_voidp(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6)) +} + +func (arg1 SwigcptrBtConvexShape) BatchedUnitVectorGetSupportingVertexWithoutMargin(arg2 BtVector3, arg3 BtVector3, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btConvexShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtConvexShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btConvexShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtConvexShape) GetAabbSlow(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btConvexShape_getAabbSlow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtConvexShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexShape) SetMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConvexShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConvexShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexShape) GetNumPreferredPenetrationDirections() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btConvexShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexShape) GetPreferredPenetrationDirection(arg2 int, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btConvexShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtConvexShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btConvexShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConvexShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConvexShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConvexShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btConvexShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtConvexShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) CalculateLocalInertia(arg1 float32, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConvexShape) GetName() (_swig_ret string) { + var swig_r string + swig_r_p := C._wrap_btConvexShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtConvexShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btConvexShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btConvexShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConvexShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConvexShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexShape) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btConvexShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtConvexShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btConvexShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtConvexShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtConvexShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtConvexShape interface { + Swigcptr() uintptr + SwigIsBtConvexShape() + LocalGetSupportingVertex(arg2 BtVector3) (_swig_ret BtVector3) + LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexWithoutMarginNonVirtual(arg2 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexNonVirtual(arg2 BtVector3) (_swig_ret BtVector3) + GetMarginNonVirtual() (_swig_ret float32) + GetAabbNonVirtual(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + Project(arg2 BtTransform, arg3 BtVector3, arg4 *float32, arg5 *float32, arg6 BtVector3, arg7 BtVector3) + BatchedUnitVectorGetSupportingVertexWithoutMargin(arg2 BtVector3, arg3 BtVector3, arg4 int) + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + GetAabbSlow(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + SetLocalScaling(arg2 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + SetMargin(arg2 float32) + GetMargin() (_swig_ret float32) + GetNumPreferredPenetrationDirections() (_swig_ret int) + GetPreferredPenetrationDirection(arg2 int, arg3 BtVector3) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + CalculateLocalInertia(arg1 float32, arg2 BtVector3) + GetName() (_swig_ret string) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +func ConvexHullSupport(arg1 BtVector3, arg2 BtVector3, arg3 int, arg4 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_convexHullSupport_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func AabbExpand(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_AabbExpand_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func TestPointAgainstAabb2(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_TestPointAgainstAabb2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func TestAabbAgainstAabb2(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (bool)(C._wrap_TestAabbAgainstAabb2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +func TestTriangleAgainstAabb2(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_TestTriangleAgainstAabb2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func BtOutcode(arg1 BtVector3, arg2 BtVector3) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (int)(C._wrap_btOutcode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtRayAabb2(arg1 BtVector3, arg2 BtVector3, arg3 *uint, arg4 BtVector3, arg5 *float32, arg6 float32, arg7 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + swig_r = (bool)(C._wrap_btRayAabb2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_voidp(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6))) + return swig_r +} + +func BtRayAabb(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 *float32, arg6 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_btRayAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_voidp(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func BtTransformAabb__SWIG_0(arg1 BtVector3, arg2 float32, arg3 BtTransform, arg4 BtVector3, arg5 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btTransformAabb__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func BtTransformAabb__SWIG_1(arg1 BtVector3, arg2 BtVector3, arg3 float32, arg4 BtTransform, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btTransformAabb__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func BtTransformAabb(a ...interface{}) { + argc := len(a) + if argc == 5 { + BtTransformAabb__SWIG_0(a[0].(BtVector3), a[1].(float32), a[2].(BtTransform), a[3].(BtVector3), a[4].(BtVector3)) + return + } + if argc == 6 { + BtTransformAabb__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(float32), a[3].(BtTransform), a[4].(BtVector3), a[5].(BtVector3)) + return + } + panic("No match for overloaded function call") +} + +const USE_BANCHLESS int = 1 + +func TestQuantizedAabbAgainstQuantizedAabb(arg1 *uint16, arg2 *uint16, arg3 *uint16, arg4 *uint16) (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (uint)(C._wrap_testQuantizedAabbAgainstQuantizedAabb_mbt_e879218550ba2e2b(C.swig_voidp(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3))) + return swig_r +} + +type SwigcptrBtConvexInternalShape uintptr + +func (p SwigcptrBtConvexInternalShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexInternalShape) SwigIsBtConvexInternalShape() { +} + +func DeleteBtConvexInternalShape(arg1 BtConvexInternalShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexInternalShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexInternalShape) LocalGetSupportingVertex(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalShape_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShape) GetImplicitShapeDimensions() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShape) SetImplicitShapeDimensions(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexInternalShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexInternalShape) SetSafeMargin__SWIG_0(arg2 float32, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btConvexInternalShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtConvexInternalShape) SetSafeMargin__SWIG_1(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConvexInternalShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexInternalShape) SetSafeMargin__SWIG_2(arg2 BtVector3, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btConvexInternalShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtConvexInternalShape) SetSafeMargin__SWIG_3(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexInternalShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtConvexInternalShape) SetSafeMargin(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + p.SetSafeMargin__SWIG_3(a[0].(BtVector3)) + return + } +check_1: + if argc == 1 { + p.SetSafeMargin__SWIG_1(a[0].(float32)) + return + } + if argc == 2 { + if _, ok := a[0].(BtVector3); !ok { + goto check_3 + } + p.SetSafeMargin__SWIG_2(a[0].(BtVector3), a[1].(float32)) + return + } +check_3: + if argc == 2 { + p.SetSafeMargin__SWIG_0(a[0].(float32), a[1].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtConvexInternalShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btConvexInternalShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtConvexInternalShape) GetAabbSlow(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btConvexInternalShape_getAabbSlow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtConvexInternalShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexInternalShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexInternalShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShape) GetLocalScalingNV() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalShape_getLocalScalingNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShape) SetMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConvexInternalShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexInternalShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConvexInternalShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShape) GetMarginNV() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConvexInternalShape_getMarginNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShape) GetNumPreferredPenetrationDirections() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btConvexInternalShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShape) GetPreferredPenetrationDirection(arg2 int, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btConvexInternalShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtConvexInternalShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btConvexInternalShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShape) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btConvexInternalShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtConvexInternalShape) LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetMarginNonVirtual() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConvexInternalShape_getMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btConvexInternalShape_getAabbNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtConvexInternalShape) Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btConvexInternalShape_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtConvexInternalShape) BatchedUnitVectorGetSupportingVertexWithoutMargin(arg1 BtVector3, arg2 BtVector3, arg3 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btConvexInternalShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btConvexInternalShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConvexInternalShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConvexInternalShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btConvexInternalShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtConvexInternalShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) CalculateLocalInertia(arg1 float32, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexInternalShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetName() (_swig_ret string) { + var swig_r string + swig_r_p := C._wrap_btConvexInternalShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexInternalShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btConvexInternalShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btConvexInternalShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConvexInternalShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexInternalShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConvexInternalShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexInternalShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexInternalShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btConvexInternalShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtConvexInternalShape) SwigIsBtConvexShape() { +} + +func (p SwigcptrBtConvexInternalShape) SwigGetBtConvexShape() BtConvexShape { + return SwigcptrBtConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtConvexInternalShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtConvexInternalShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtConvexInternalShape interface { + Swigcptr() uintptr + SwigIsBtConvexInternalShape() + LocalGetSupportingVertex(arg2 BtVector3) (_swig_ret BtVector3) + GetImplicitShapeDimensions() (_swig_ret BtVector3) + SetImplicitShapeDimensions(arg2 BtVector3) + SetSafeMargin(a ...interface{}) + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + GetAabbSlow(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + SetLocalScaling(arg2 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetLocalScalingNV() (_swig_ret BtVector3) + SetMargin(arg2 float32) + GetMargin() (_swig_ret float32) + GetMarginNV() (_swig_ret float32) + GetNumPreferredPenetrationDirections() (_swig_ret int) + GetPreferredPenetrationDirection(arg2 int, arg3 BtVector3) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + GetMarginNonVirtual() (_swig_ret float32) + GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) + BatchedUnitVectorGetSupportingVertexWithoutMargin(arg1 BtVector3, arg2 BtVector3, arg3 int) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + CalculateLocalInertia(arg1 float32, arg2 BtVector3) + GetName() (_swig_ret string) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtConvexShape() + SwigGetBtConvexShape() BtConvexShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtConvexInternalShapeData uintptr + +func (p SwigcptrBtConvexInternalShapeData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexInternalShapeData) SwigIsBtConvexInternalShapeData() { +} + +func (arg1 SwigcptrBtConvexInternalShapeData) SetM_collisionShapeData(arg2 BtCollisionShapeData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexInternalShapeData_m_collisionShapeData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexInternalShapeData) GetM_collisionShapeData() (_swig_ret BtCollisionShapeData) { + var swig_r BtCollisionShapeData + _swig_i_0 := arg1 + swig_r = (BtCollisionShapeData)(SwigcptrBtCollisionShapeData(C._wrap_btConvexInternalShapeData_m_collisionShapeData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShapeData) SetM_localScaling(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexInternalShapeData_m_localScaling_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexInternalShapeData) GetM_localScaling() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btConvexInternalShapeData_m_localScaling_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShapeData) SetM_implicitShapeDimensions(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexInternalShapeData_m_implicitShapeDimensions_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexInternalShapeData) GetM_implicitShapeDimensions() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btConvexInternalShapeData_m_implicitShapeDimensions_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShapeData) SetM_collisionMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConvexInternalShapeData_m_collisionMargin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexInternalShapeData) GetM_collisionMargin() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConvexInternalShapeData_m_collisionMargin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexInternalShapeData) SetM_padding(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConvexInternalShapeData_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexInternalShapeData) GetM_padding() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btConvexInternalShapeData_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtConvexInternalShapeData() (_swig_ret BtConvexInternalShapeData) { + var swig_r BtConvexInternalShapeData + swig_r = (BtConvexInternalShapeData)(SwigcptrBtConvexInternalShapeData(C._wrap_new_btConvexInternalShapeData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtConvexInternalShapeData(arg1 BtConvexInternalShapeData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexInternalShapeData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtConvexInternalShapeData interface { + Swigcptr() uintptr + SwigIsBtConvexInternalShapeData() + SetM_collisionShapeData(arg2 BtCollisionShapeData) + GetM_collisionShapeData() (_swig_ret BtCollisionShapeData) + SetM_localScaling(arg2 BtVector3FloatData) + GetM_localScaling() (_swig_ret BtVector3FloatData) + SetM_implicitShapeDimensions(arg2 BtVector3FloatData) + GetM_implicitShapeDimensions() (_swig_ret BtVector3FloatData) + SetM_collisionMargin(arg2 float32) + GetM_collisionMargin() (_swig_ret float32) + SetM_padding(arg2 int) + GetM_padding() (_swig_ret int) +} + +type SwigcptrBtConvexInternalAabbCachingShape uintptr + +func (p SwigcptrBtConvexInternalAabbCachingShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexInternalAabbCachingShape) SwigIsBtConvexInternalAabbCachingShape() { +} + +func (arg1 SwigcptrBtConvexInternalAabbCachingShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexInternalAabbCachingShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexInternalAabbCachingShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btConvexInternalAabbCachingShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtConvexInternalAabbCachingShape) RecalcLocalAabb() { + _swig_i_0 := arg1 + C._wrap_btConvexInternalAabbCachingShape_recalcLocalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func DeleteBtConvexInternalAabbCachingShape(arg1 BtConvexInternalAabbCachingShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexInternalAabbCachingShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalAabbCachingShape_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetImplicitShapeDimensions() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalAabbCachingShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) SetImplicitShapeDimensions(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btConvexInternalAabbCachingShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) SetSafeMargin__SWIG_0(arg1 float32, arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) SetSafeMargin__SWIG_1(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) SetSafeMargin__SWIG_2(arg1 BtVector3, arg2 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) SetSafeMargin__SWIG_3(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btConvexInternalAabbCachingShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtConvexInternalAabbCachingShape) SetSafeMargin(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + p.SetSafeMargin__SWIG_3(a[0].(BtVector3)) + return + } +check_1: + if argc == 1 { + p.SetSafeMargin__SWIG_1(a[0].(float32)) + return + } + if argc == 2 { + if _, ok := a[0].(BtVector3); !ok { + goto check_3 + } + p.SetSafeMargin__SWIG_2(a[0].(BtVector3), a[1].(float32)) + return + } +check_3: + if argc == 2 { + p.SetSafeMargin__SWIG_0(a[0].(float32), a[1].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btConvexInternalAabbCachingShape_getAabbSlow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalAabbCachingShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetLocalScalingNV() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalAabbCachingShape_getLocalScalingNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) SetMargin(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btConvexInternalAabbCachingShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConvexInternalAabbCachingShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetMarginNV() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConvexInternalAabbCachingShape_getMarginNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetNumPreferredPenetrationDirections() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexInternalAabbCachingShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexInternalAabbCachingShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexInternalAabbCachingShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btConvexInternalAabbCachingShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalAabbCachingShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalAabbCachingShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalAabbCachingShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetMarginNonVirtual() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConvexInternalAabbCachingShape_getMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btConvexInternalAabbCachingShape_getAabbNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btConvexInternalAabbCachingShape_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) BatchedUnitVectorGetSupportingVertexWithoutMargin(arg1 BtVector3, arg2 BtVector3, arg3 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btConvexInternalAabbCachingShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btConvexInternalAabbCachingShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConvexInternalAabbCachingShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConvexInternalAabbCachingShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btConvexInternalAabbCachingShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalAabbCachingShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalAabbCachingShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalAabbCachingShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalAabbCachingShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalAabbCachingShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalAabbCachingShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalAabbCachingShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConvexInternalAabbCachingShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) CalculateLocalInertia(arg1 float32, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexInternalAabbCachingShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetName() (_swig_ret string) { + var swig_r string + swig_r_p := C._wrap_btConvexInternalAabbCachingShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexInternalAabbCachingShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexInternalAabbCachingShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btConvexInternalAabbCachingShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btConvexInternalAabbCachingShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConvexInternalAabbCachingShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexInternalAabbCachingShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConvexInternalAabbCachingShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConvexInternalAabbCachingShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConvexInternalAabbCachingShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btConvexInternalAabbCachingShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtConvexInternalAabbCachingShape) SwigIsBtConvexInternalShape() { +} + +func (p SwigcptrBtConvexInternalAabbCachingShape) SwigGetBtConvexInternalShape() BtConvexInternalShape { + return SwigcptrBtConvexInternalShape(getSwigcptr(p)) +} + +func (p SwigcptrBtConvexInternalAabbCachingShape) SwigIsBtConvexShape() { +} + +func (p SwigcptrBtConvexInternalAabbCachingShape) SwigGetBtConvexShape() BtConvexShape { + return SwigcptrBtConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtConvexInternalAabbCachingShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtConvexInternalAabbCachingShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtConvexInternalAabbCachingShape interface { + Swigcptr() uintptr + SwigIsBtConvexInternalAabbCachingShape() + SetLocalScaling(arg2 BtVector3) + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + RecalcLocalAabb() + LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) + GetImplicitShapeDimensions() (_swig_ret BtVector3) + SetImplicitShapeDimensions(arg1 BtVector3) + SetSafeMargin(a ...interface{}) + GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetLocalScalingNV() (_swig_ret BtVector3) + SetMargin(arg1 float32) + GetMargin() (_swig_ret float32) + GetMarginNV() (_swig_ret float32) + GetNumPreferredPenetrationDirections() (_swig_ret int) + GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + GetMarginNonVirtual() (_swig_ret float32) + GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) + BatchedUnitVectorGetSupportingVertexWithoutMargin(arg1 BtVector3, arg2 BtVector3, arg3 int) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + CalculateLocalInertia(arg1 float32, arg2 BtVector3) + GetName() (_swig_ret string) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtConvexInternalShape() + SwigGetBtConvexInternalShape() BtConvexInternalShape + SwigIsBtConvexShape() + SwigGetBtConvexShape() BtConvexShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtSphereShape uintptr + +func (p SwigcptrBtSphereShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSphereShape) SwigIsBtSphereShape() { +} + +func NewBtSphereShape(arg1 float32) (_swig_ret BtSphereShape) { + var swig_r BtSphereShape + _swig_i_0 := arg1 + swig_r = (BtSphereShape)(SwigcptrBtSphereShape(C._wrap_new_btSphereShape_mbt_e879218550ba2e2b(C.float(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSphereShape) LocalGetSupportingVertex(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSphereShape_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtSphereShape) LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSphereShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtSphereShape) BatchedUnitVectorGetSupportingVertexWithoutMargin(arg2 BtVector3, arg3 BtVector3, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btSphereShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtSphereShape) CalculateLocalInertia(arg2 float32, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSphereShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSphereShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btSphereShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtSphereShape) GetRadius() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSphereShape_getRadius_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSphereShape) SetUnscaledRadius(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSphereShape_setUnscaledRadius_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSphereShape) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btSphereShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtSphereShape) SetMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSphereShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSphereShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSphereShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtSphereShape(arg1 BtSphereShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSphereShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSphereShape) GetImplicitShapeDimensions() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSphereShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) SetImplicitShapeDimensions(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btSphereShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSphereShape) SetSafeMargin__SWIG_0(arg1 float32, arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSphereShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtSphereShape) SetSafeMargin__SWIG_1(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btSphereShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSphereShape) SetSafeMargin__SWIG_2(arg1 BtVector3, arg2 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btSphereShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtSphereShape) SetSafeMargin__SWIG_3(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btSphereShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtSphereShape) SetSafeMargin(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + p.SetSafeMargin__SWIG_3(a[0].(BtVector3)) + return + } +check_1: + if argc == 1 { + p.SetSafeMargin__SWIG_1(a[0].(float32)) + return + } + if argc == 2 { + if _, ok := a[0].(BtVector3); !ok { + goto check_3 + } + p.SetSafeMargin__SWIG_2(a[0].(BtVector3), a[1].(float32)) + return + } +check_3: + if argc == 2 { + p.SetSafeMargin__SWIG_0(a[0].(float32), a[1].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtSphereShape) GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSphereShape_getAabbSlow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtSphereShape) SetLocalScaling(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btSphereShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSphereShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSphereShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) GetLocalScalingNV() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSphereShape_getLocalScalingNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) GetMarginNV() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btSphereShape_getMarginNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) GetNumPreferredPenetrationDirections() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btSphereShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSphereShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtSphereShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btSphereShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btSphereShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtSphereShape) LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSphereShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSphereShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) GetMarginNonVirtual() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btSphereShape_getMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSphereShape_getAabbNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtSphereShape) Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btSphereShape_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtSphereShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btSphereShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtSphereShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btSphereShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSphereShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btSphereShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtSphereShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSphereShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSphereShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSphereShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSphereShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSphereShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSphereShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSphereShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSphereShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btSphereShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSphereShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btSphereShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSphereShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btSphereShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btSphereShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSphereShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btSphereShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btSphereShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSphereShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btSphereShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSphereShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btSphereShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtSphereShape) SwigIsBtConvexInternalShape() { +} + +func (p SwigcptrBtSphereShape) SwigGetBtConvexInternalShape() BtConvexInternalShape { + return SwigcptrBtConvexInternalShape(getSwigcptr(p)) +} + +func (p SwigcptrBtSphereShape) SwigIsBtConvexShape() { +} + +func (p SwigcptrBtSphereShape) SwigGetBtConvexShape() BtConvexShape { + return SwigcptrBtConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtSphereShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtSphereShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtSphereShape interface { + Swigcptr() uintptr + SwigIsBtSphereShape() + LocalGetSupportingVertex(arg2 BtVector3) (_swig_ret BtVector3) + LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) + BatchedUnitVectorGetSupportingVertexWithoutMargin(arg2 BtVector3, arg3 BtVector3, arg4 int) + CalculateLocalInertia(arg2 float32, arg3 BtVector3) + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + GetRadius() (_swig_ret float32) + SetUnscaledRadius(arg2 float32) + GetName() (_swig_ret string) + SetMargin(arg2 float32) + GetMargin() (_swig_ret float32) + GetImplicitShapeDimensions() (_swig_ret BtVector3) + SetImplicitShapeDimensions(arg1 BtVector3) + SetSafeMargin(a ...interface{}) + GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + SetLocalScaling(arg1 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetLocalScalingNV() (_swig_ret BtVector3) + GetMarginNV() (_swig_ret float32) + GetNumPreferredPenetrationDirections() (_swig_ret int) + GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + GetMarginNonVirtual() (_swig_ret float32) + GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtConvexInternalShape() + SwigGetBtConvexInternalShape() BtConvexInternalShape + SwigIsBtConvexShape() + SwigGetBtConvexShape() BtConvexShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtPolyhedralConvexShape uintptr + +func (p SwigcptrBtPolyhedralConvexShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtPolyhedralConvexShape) SwigIsBtPolyhedralConvexShape() { +} + +func DeleteBtPolyhedralConvexShape(arg1 BtPolyhedralConvexShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btPolyhedralConvexShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) InitializePolyhedralFeatures__SWIG_0(arg2 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_initializePolyhedralFeatures__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) InitializePolyhedralFeatures__SWIG_1() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_initializePolyhedralFeatures__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (p SwigcptrBtPolyhedralConvexShape) InitializePolyhedralFeatures(a ...interface{}) bool { + argc := len(a) + if argc == 0 { + return p.InitializePolyhedralFeatures__SWIG_1() + } + if argc == 1 { + return p.InitializePolyhedralFeatures__SWIG_0(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) SetPolyhedralFeatures(arg2 BtConvexPolyhedron) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPolyhedralConvexShape_setPolyhedralFeatures_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) GetConvexPolyhedron() (_swig_ret BtConvexPolyhedron) { + var swig_r BtConvexPolyhedron + _swig_i_0 := arg1 + swig_r = (BtConvexPolyhedron)(SwigcptrBtConvexPolyhedron(C._wrap_btPolyhedralConvexShape_getConvexPolyhedron_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) BatchedUnitVectorGetSupportingVertexWithoutMargin(arg2 BtVector3, arg3 BtVector3, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btPolyhedralConvexShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) CalculateLocalInertia(arg2 float32, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btPolyhedralConvexShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) GetNumVertices() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPolyhedralConvexShape_getNumVertices_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) GetNumEdges() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPolyhedralConvexShape_getNumEdges_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) GetEdge(arg2 int, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btPolyhedralConvexShape_getEdge_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) GetVertex(arg2 int, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btPolyhedralConvexShape_getVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) GetNumPlanes() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPolyhedralConvexShape_getNumPlanes_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) GetPlane(arg2 BtVector3, arg3 BtVector3, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btPolyhedralConvexShape_getPlane_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtPolyhedralConvexShape) IsInside(arg2 BtVector3, arg3 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_isInside_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexShape_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetImplicitShapeDimensions() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SetImplicitShapeDimensions(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btPolyhedralConvexShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SetSafeMargin__SWIG_0(arg1 float32, arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SetSafeMargin__SWIG_1(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SetSafeMargin__SWIG_2(arg1 BtVector3, arg2 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SetSafeMargin__SWIG_3(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btPolyhedralConvexShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtPolyhedralConvexShape) SetSafeMargin(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + p.SetSafeMargin__SWIG_3(a[0].(BtVector3)) + return + } +check_1: + if argc == 1 { + p.SetSafeMargin__SWIG_1(a[0].(float32)) + return + } + if argc == 2 { + if _, ok := a[0].(BtVector3); !ok { + goto check_3 + } + p.SetSafeMargin__SWIG_2(a[0].(BtVector3), a[1].(float32)) + return + } +check_3: + if argc == 2 { + p.SetSafeMargin__SWIG_0(a[0].(float32), a[1].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btPolyhedralConvexShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btPolyhedralConvexShape_getAabbSlow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SetLocalScaling(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btPolyhedralConvexShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetLocalScalingNV() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexShape_getLocalScalingNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SetMargin(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btPolyhedralConvexShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetMarginNV() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btPolyhedralConvexShape_getMarginNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetNumPreferredPenetrationDirections() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPolyhedralConvexShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btPolyhedralConvexShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetMarginNonVirtual() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btPolyhedralConvexShape_getMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btPolyhedralConvexShape_getAabbNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btPolyhedralConvexShape_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btPolyhedralConvexShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btPolyhedralConvexShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btPolyhedralConvexShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btPolyhedralConvexShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetName() (_swig_ret string) { + var swig_r string + swig_r_p := C._wrap_btPolyhedralConvexShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btPolyhedralConvexShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btPolyhedralConvexShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtPolyhedralConvexShape) SwigIsBtConvexInternalShape() { +} + +func (p SwigcptrBtPolyhedralConvexShape) SwigGetBtConvexInternalShape() BtConvexInternalShape { + return SwigcptrBtConvexInternalShape(getSwigcptr(p)) +} + +func (p SwigcptrBtPolyhedralConvexShape) SwigIsBtConvexShape() { +} + +func (p SwigcptrBtPolyhedralConvexShape) SwigGetBtConvexShape() BtConvexShape { + return SwigcptrBtConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtPolyhedralConvexShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtPolyhedralConvexShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtPolyhedralConvexShape interface { + Swigcptr() uintptr + SwigIsBtPolyhedralConvexShape() + InitializePolyhedralFeatures(a ...interface{}) bool + SetPolyhedralFeatures(arg2 BtConvexPolyhedron) + GetConvexPolyhedron() (_swig_ret BtConvexPolyhedron) + LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) + BatchedUnitVectorGetSupportingVertexWithoutMargin(arg2 BtVector3, arg3 BtVector3, arg4 int) + CalculateLocalInertia(arg2 float32, arg3 BtVector3) + GetNumVertices() (_swig_ret int) + GetNumEdges() (_swig_ret int) + GetEdge(arg2 int, arg3 BtVector3, arg4 BtVector3) + GetVertex(arg2 int, arg3 BtVector3) + GetNumPlanes() (_swig_ret int) + GetPlane(arg2 BtVector3, arg3 BtVector3, arg4 int) + IsInside(arg2 BtVector3, arg3 float32) (_swig_ret bool) + LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) + GetImplicitShapeDimensions() (_swig_ret BtVector3) + SetImplicitShapeDimensions(arg1 BtVector3) + SetSafeMargin(a ...interface{}) + GetAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + SetLocalScaling(arg1 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetLocalScalingNV() (_swig_ret BtVector3) + SetMargin(arg1 float32) + GetMargin() (_swig_ret float32) + GetMarginNV() (_swig_ret float32) + GetNumPreferredPenetrationDirections() (_swig_ret int) + GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + GetMarginNonVirtual() (_swig_ret float32) + GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetName() (_swig_ret string) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtConvexInternalShape() + SwigGetBtConvexInternalShape() BtConvexInternalShape + SwigIsBtConvexShape() + SwigGetBtConvexShape() BtConvexShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtPolyhedralConvexAabbCachingShape uintptr + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) SwigIsBtPolyhedralConvexAabbCachingShape() { +} + +func (arg1 SwigcptrBtPolyhedralConvexAabbCachingShape) GetNonvirtualAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3, arg5 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + C._wrap_btPolyhedralConvexAabbCachingShape_getNonvirtualAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4)) +} + +func (arg1 SwigcptrBtPolyhedralConvexAabbCachingShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPolyhedralConvexAabbCachingShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPolyhedralConvexAabbCachingShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btPolyhedralConvexAabbCachingShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtPolyhedralConvexAabbCachingShape) RecalcLocalAabb() { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexAabbCachingShape_recalcLocalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func DeleteBtPolyhedralConvexAabbCachingShape(arg1 BtPolyhedralConvexAabbCachingShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btPolyhedralConvexAabbCachingShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) InitializePolyhedralFeatures__SWIG_0(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_initializePolyhedralFeatures__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) InitializePolyhedralFeatures__SWIG_1() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_initializePolyhedralFeatures__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) InitializePolyhedralFeatures(a ...interface{}) bool { + argc := len(a) + if argc == 0 { + return p.InitializePolyhedralFeatures__SWIG_1() + } + if argc == 1 { + return p.InitializePolyhedralFeatures__SWIG_0(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SetPolyhedralFeatures(arg1 BtConvexPolyhedron) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btPolyhedralConvexAabbCachingShape_setPolyhedralFeatures_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetConvexPolyhedron() (_swig_ret BtConvexPolyhedron) { + var swig_r BtConvexPolyhedron + swig_r = (BtConvexPolyhedron)(SwigcptrBtConvexPolyhedron(C._wrap_btPolyhedralConvexAabbCachingShape_getConvexPolyhedron_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexAabbCachingShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) BatchedUnitVectorGetSupportingVertexWithoutMargin(arg1 BtVector3, arg2 BtVector3, arg3 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btPolyhedralConvexAabbCachingShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) CalculateLocalInertia(arg1 float32, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPolyhedralConvexAabbCachingShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetNumVertices() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexAabbCachingShape_getNumVertices_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetNumEdges() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexAabbCachingShape_getNumEdges_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetEdge(arg1 int, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btPolyhedralConvexAabbCachingShape_getEdge_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetVertex(arg1 int, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPolyhedralConvexAabbCachingShape_getVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetNumPlanes() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexAabbCachingShape_getNumPlanes_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetPlane(arg1 BtVector3, arg2 BtVector3, arg3 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btPolyhedralConvexAabbCachingShape_getPlane_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) IsInside(arg1 BtVector3, arg2 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_isInside_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexAabbCachingShape_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetImplicitShapeDimensions() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexAabbCachingShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SetImplicitShapeDimensions(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btPolyhedralConvexAabbCachingShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SetSafeMargin__SWIG_0(arg1 float32, arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SetSafeMargin__SWIG_1(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SetSafeMargin__SWIG_2(arg1 BtVector3, arg2 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SetSafeMargin__SWIG_3(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btPolyhedralConvexAabbCachingShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) SetSafeMargin(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + p.SetSafeMargin__SWIG_3(a[0].(BtVector3)) + return + } +check_1: + if argc == 1 { + p.SetSafeMargin__SWIG_1(a[0].(float32)) + return + } + if argc == 2 { + if _, ok := a[0].(BtVector3); !ok { + goto check_3 + } + p.SetSafeMargin__SWIG_2(a[0].(BtVector3), a[1].(float32)) + return + } +check_3: + if argc == 2 { + p.SetSafeMargin__SWIG_0(a[0].(float32), a[1].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btPolyhedralConvexAabbCachingShape_getAabbSlow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexAabbCachingShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetLocalScalingNV() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexAabbCachingShape_getLocalScalingNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SetMargin(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexAabbCachingShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btPolyhedralConvexAabbCachingShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetMarginNV() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btPolyhedralConvexAabbCachingShape_getMarginNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetNumPreferredPenetrationDirections() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexAabbCachingShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPolyhedralConvexAabbCachingShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexAabbCachingShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btPolyhedralConvexAabbCachingShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexAabbCachingShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexAabbCachingShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetMarginNonVirtual() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btPolyhedralConvexAabbCachingShape_getMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btPolyhedralConvexAabbCachingShape_getAabbNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btPolyhedralConvexAabbCachingShape_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btPolyhedralConvexAabbCachingShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btPolyhedralConvexAabbCachingShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btPolyhedralConvexAabbCachingShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btPolyhedralConvexAabbCachingShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btPolyhedralConvexAabbCachingShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetName() (_swig_ret string) { + var swig_r string + swig_r_p := C._wrap_btPolyhedralConvexAabbCachingShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexAabbCachingShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btPolyhedralConvexAabbCachingShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexAabbCachingShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btPolyhedralConvexAabbCachingShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexAabbCachingShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexAabbCachingShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btPolyhedralConvexAabbCachingShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPolyhedralConvexAabbCachingShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPolyhedralConvexAabbCachingShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btPolyhedralConvexAabbCachingShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) SwigIsBtPolyhedralConvexShape() { +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) SwigGetBtPolyhedralConvexShape() BtPolyhedralConvexShape { + return SwigcptrBtPolyhedralConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) SwigIsBtConvexInternalShape() { +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) SwigGetBtConvexInternalShape() BtConvexInternalShape { + return SwigcptrBtConvexInternalShape(getSwigcptr(p)) +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) SwigIsBtConvexShape() { +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) SwigGetBtConvexShape() BtConvexShape { + return SwigcptrBtConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtPolyhedralConvexAabbCachingShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtPolyhedralConvexAabbCachingShape interface { + Swigcptr() uintptr + SwigIsBtPolyhedralConvexAabbCachingShape() + GetNonvirtualAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3, arg5 float32) + SetLocalScaling(arg2 BtVector3) + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + RecalcLocalAabb() + InitializePolyhedralFeatures(a ...interface{}) bool + SetPolyhedralFeatures(arg1 BtConvexPolyhedron) + GetConvexPolyhedron() (_swig_ret BtConvexPolyhedron) + LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) + BatchedUnitVectorGetSupportingVertexWithoutMargin(arg1 BtVector3, arg2 BtVector3, arg3 int) + CalculateLocalInertia(arg1 float32, arg2 BtVector3) + GetNumVertices() (_swig_ret int) + GetNumEdges() (_swig_ret int) + GetEdge(arg1 int, arg2 BtVector3, arg3 BtVector3) + GetVertex(arg1 int, arg2 BtVector3) + GetNumPlanes() (_swig_ret int) + GetPlane(arg1 BtVector3, arg2 BtVector3, arg3 int) + IsInside(arg1 BtVector3, arg2 float32) (_swig_ret bool) + LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) + GetImplicitShapeDimensions() (_swig_ret BtVector3) + SetImplicitShapeDimensions(arg1 BtVector3) + SetSafeMargin(a ...interface{}) + GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetLocalScalingNV() (_swig_ret BtVector3) + SetMargin(arg1 float32) + GetMargin() (_swig_ret float32) + GetMarginNV() (_swig_ret float32) + GetNumPreferredPenetrationDirections() (_swig_ret int) + GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + GetMarginNonVirtual() (_swig_ret float32) + GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetName() (_swig_ret string) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtPolyhedralConvexShape() + SwigGetBtPolyhedralConvexShape() BtPolyhedralConvexShape + SwigIsBtConvexInternalShape() + SwigGetBtConvexInternalShape() BtConvexInternalShape + SwigIsBtConvexShape() + SwigGetBtConvexShape() BtConvexShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +const BT_USE_PLACEMENT_NEW int = 1 +const TEST_INTERNAL_OBJECTS int = 1 + +type SwigcptrBtFace uintptr + +func (p SwigcptrBtFace) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtFace) SwigIsBtFace() { +} + +func (arg1 SwigcptrBtFace) SetM_indices(arg2 BtAlignedObjectArray_Sl_int_Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btFace_m_indices_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtFace) GetM_indices() (_swig_ret BtAlignedObjectArray_Sl_int_Sg_) { + var swig_r BtAlignedObjectArray_Sl_int_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_int_Sg_)(SwigcptrBtAlignedObjectArray_Sl_int_Sg_(C._wrap_btFace_m_indices_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtFace) SetM_plane(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btFace_m_plane_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtFace) GetM_plane() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btFace_m_plane_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtFace() (_swig_ret BtFace) { + var swig_r BtFace + swig_r = (BtFace)(SwigcptrBtFace(C._wrap_new_btFace_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtFace(arg1 BtFace) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btFace_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtFace interface { + Swigcptr() uintptr + SwigIsBtFace() + SetM_indices(arg2 BtAlignedObjectArray_Sl_int_Sg_) + GetM_indices() (_swig_ret BtAlignedObjectArray_Sl_int_Sg_) + SetM_plane(arg2 *float32) + GetM_plane() (_swig_ret *float32) +} + +type SwigcptrBtConvexPolyhedron uintptr + +func (p SwigcptrBtConvexPolyhedron) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexPolyhedron) SwigIsBtConvexPolyhedron() { +} + +func NewBtConvexPolyhedron() (_swig_ret BtConvexPolyhedron) { + var swig_r BtConvexPolyhedron + swig_r = (BtConvexPolyhedron)(SwigcptrBtConvexPolyhedron(C._wrap_new_btConvexPolyhedron_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtConvexPolyhedron(arg1 BtConvexPolyhedron) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexPolyhedron_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) SetM_vertices(arg2 BtAlignedObjectArray_Sl_btVector3_Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexPolyhedron_m_vertices_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) GetM_vertices() (_swig_ret BtAlignedObjectArray_Sl_btVector3_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btVector3_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btVector3_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btVector3_Sg_(C._wrap_btConvexPolyhedron_m_vertices_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexPolyhedron) SetM_faces(arg2 BtAlignedObjectArray_Sl_btFace_Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexPolyhedron_m_faces_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) GetM_faces() (_swig_ret BtAlignedObjectArray_Sl_btFace_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btFace_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btFace_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btFace_Sg_(C._wrap_btConvexPolyhedron_m_faces_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexPolyhedron) SetM_uniqueEdges(arg2 BtAlignedObjectArray_Sl_btVector3_Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexPolyhedron_m_uniqueEdges_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) GetM_uniqueEdges() (_swig_ret BtAlignedObjectArray_Sl_btVector3_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btVector3_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btVector3_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btVector3_Sg_(C._wrap_btConvexPolyhedron_m_uniqueEdges_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexPolyhedron) SetM_localCenter(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexPolyhedron_m_localCenter_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) GetM_localCenter() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexPolyhedron_m_localCenter_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexPolyhedron) SetM_extents(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexPolyhedron_m_extents_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) GetM_extents() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexPolyhedron_m_extents_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexPolyhedron) SetM_radius(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConvexPolyhedron_m_radius_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) GetM_radius() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConvexPolyhedron_m_radius_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexPolyhedron) SetMC(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexPolyhedron_mC_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) GetMC() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexPolyhedron_mC_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexPolyhedron) SetME(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexPolyhedron_mE_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) GetME() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexPolyhedron_mE_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexPolyhedron) Initialize() { + _swig_i_0 := arg1 + C._wrap_btConvexPolyhedron_initialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) Initialize2() { + _swig_i_0 := arg1 + C._wrap_btConvexPolyhedron_initialize2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexPolyhedron) TestContainment() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btConvexPolyhedron_testContainment_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexPolyhedron) Project(arg2 BtTransform, arg3 BtVector3, arg4 *float32, arg5 *float32, arg6 BtVector3, arg7 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + C._wrap_btConvexPolyhedron_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_voidp(_swig_i_3), C.swig_voidp(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6)) +} + +type BtConvexPolyhedron interface { + Swigcptr() uintptr + SwigIsBtConvexPolyhedron() + SetM_vertices(arg2 BtAlignedObjectArray_Sl_btVector3_Sg_) + GetM_vertices() (_swig_ret BtAlignedObjectArray_Sl_btVector3_Sg_) + SetM_faces(arg2 BtAlignedObjectArray_Sl_btFace_Sg_) + GetM_faces() (_swig_ret BtAlignedObjectArray_Sl_btFace_Sg_) + SetM_uniqueEdges(arg2 BtAlignedObjectArray_Sl_btVector3_Sg_) + GetM_uniqueEdges() (_swig_ret BtAlignedObjectArray_Sl_btVector3_Sg_) + SetM_localCenter(arg2 BtVector3) + GetM_localCenter() (_swig_ret BtVector3) + SetM_extents(arg2 BtVector3) + GetM_extents() (_swig_ret BtVector3) + SetM_radius(arg2 float32) + GetM_radius() (_swig_ret float32) + SetMC(arg2 BtVector3) + GetMC() (_swig_ret BtVector3) + SetME(arg2 BtVector3) + GetME() (_swig_ret BtVector3) + Initialize() + Initialize2() + TestContainment() (_swig_ret bool) + Project(arg2 BtTransform, arg3 BtVector3, arg4 *float32, arg5 *float32, arg6 BtVector3, arg7 BtVector3) +} + +func IsAlmostZero1(arg1 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + swig_r = (bool)(C._wrap_IsAlmostZero1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +type SwigcptrBtInternalVertexPair uintptr + +func (p SwigcptrBtInternalVertexPair) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtInternalVertexPair) SwigIsBtInternalVertexPair() { +} + +func NewBtInternalVertexPair(arg1 int16, arg2 int16) (_swig_ret BtInternalVertexPair) { + var swig_r BtInternalVertexPair + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtInternalVertexPair)(SwigcptrBtInternalVertexPair(C._wrap_new_btInternalVertexPair_mbt_e879218550ba2e2b(C.short(_swig_i_0), C.short(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtInternalVertexPair) SetM_v0(arg2 int16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btInternalVertexPair_m_v0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtInternalVertexPair) GetM_v0() (_swig_ret int16) { + var swig_r int16 + _swig_i_0 := arg1 + swig_r = (int16)(C._wrap_btInternalVertexPair_m_v0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtInternalVertexPair) SetM_v1(arg2 int16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btInternalVertexPair_m_v1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtInternalVertexPair) GetM_v1() (_swig_ret int16) { + var swig_r int16 + _swig_i_0 := arg1 + swig_r = (int16)(C._wrap_btInternalVertexPair_m_v1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtInternalVertexPair) GetHash() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btInternalVertexPair_getHash_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtInternalVertexPair) Equals(arg2 BtInternalVertexPair) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btInternalVertexPair_equals_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func DeleteBtInternalVertexPair(arg1 BtInternalVertexPair) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btInternalVertexPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtInternalVertexPair interface { + Swigcptr() uintptr + SwigIsBtInternalVertexPair() + SetM_v0(arg2 int16) + GetM_v0() (_swig_ret int16) + SetM_v1(arg2 int16) + GetM_v1() (_swig_ret int16) + GetHash() (_swig_ret int) + Equals(arg2 BtInternalVertexPair) (_swig_ret bool) +} + +type SwigcptrBtInternalEdge uintptr + +func (p SwigcptrBtInternalEdge) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtInternalEdge) SwigIsBtInternalEdge() { +} + +func NewBtInternalEdge() (_swig_ret BtInternalEdge) { + var swig_r BtInternalEdge + swig_r = (BtInternalEdge)(SwigcptrBtInternalEdge(C._wrap_new_btInternalEdge_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtInternalEdge) SetM_face0(arg2 int16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btInternalEdge_m_face0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtInternalEdge) GetM_face0() (_swig_ret int16) { + var swig_r int16 + _swig_i_0 := arg1 + swig_r = (int16)(C._wrap_btInternalEdge_m_face0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtInternalEdge) SetM_face1(arg2 int16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btInternalEdge_m_face1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtInternalEdge) GetM_face1() (_swig_ret int16) { + var swig_r int16 + _swig_i_0 := arg1 + swig_r = (int16)(C._wrap_btInternalEdge_m_face1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtInternalEdge(arg1 BtInternalEdge) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btInternalEdge_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtInternalEdge interface { + Swigcptr() uintptr + SwigIsBtInternalEdge() + SetM_face0(arg2 int16) + GetM_face0() (_swig_ret int16) + SetM_face1(arg2 int16) + GetM_face1() (_swig_ret int16) +} + +type SwigcptrBtConvexHullComputer uintptr + +func (p SwigcptrBtConvexHullComputer) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexHullComputer) SwigIsBtConvexHullComputer() { +} + +func (arg1 SwigcptrBtConvexHullComputer) SetVertices(arg2 BtAlignedObjectArray_Sl_btVector3_Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexHullComputer_vertices_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexHullComputer) GetVertices() (_swig_ret BtAlignedObjectArray_Sl_btVector3_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btVector3_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btVector3_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btVector3_Sg_(C._wrap_btConvexHullComputer_vertices_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexHullComputer) SetOriginal_vertex_index(arg2 BtAlignedObjectArray_Sl_int_Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexHullComputer_original_vertex_index_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexHullComputer) GetOriginal_vertex_index() (_swig_ret BtAlignedObjectArray_Sl_int_Sg_) { + var swig_r BtAlignedObjectArray_Sl_int_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_int_Sg_)(SwigcptrBtAlignedObjectArray_Sl_int_Sg_(C._wrap_btConvexHullComputer_original_vertex_index_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexHullComputer) SetEdges(arg2 BtAlignedObjectArray_Sl_btConvexHullComputer_Edge_Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexHullComputer_edges_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexHullComputer) GetEdges() (_swig_ret BtAlignedObjectArray_Sl_btConvexHullComputer_Edge_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btConvexHullComputer_Edge_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btConvexHullComputer_Edge_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btConvexHullComputer_Edge_Sg_(C._wrap_btConvexHullComputer_edges_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexHullComputer) SetFaces(arg2 BtAlignedObjectArray_Sl_int_Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexHullComputer_faces_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexHullComputer) GetFaces() (_swig_ret BtAlignedObjectArray_Sl_int_Sg_) { + var swig_r BtAlignedObjectArray_Sl_int_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_int_Sg_)(SwigcptrBtAlignedObjectArray_Sl_int_Sg_(C._wrap_btConvexHullComputer_faces_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexHullComputer) Compute__SWIG_0(arg2 *float32, arg3 int, arg4 int, arg5 float32, arg6 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + swig_r = (float32)(C._wrap_btConvexHullComputer_compute__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5))) + return swig_r +} + +func (arg1 SwigcptrBtConvexHullComputer) Compute__SWIG_1(arg2 *float64, arg3 int, arg4 int, arg5 float32, arg6 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + swig_r = (float32)(C._wrap_btConvexHullComputer_compute__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5))) + return swig_r +} + +func (p SwigcptrBtConvexHullComputer) Compute(a ...interface{}) float32 { + argc := len(a) + if argc == 5 { + if _, ok := a[0].(*float32); !ok { + goto check_1 + } + return p.Compute__SWIG_0(a[0].(*float32), a[1].(int), a[2].(int), a[3].(float32), a[4].(float32)) + } +check_1: + if argc == 5 { + return p.Compute__SWIG_1(a[0].(*float64), a[1].(int), a[2].(int), a[3].(float32), a[4].(float32)) + } + panic("No match for overloaded function call") +} + +func NewBtConvexHullComputer() (_swig_ret BtConvexHullComputer) { + var swig_r BtConvexHullComputer + swig_r = (BtConvexHullComputer)(SwigcptrBtConvexHullComputer(C._wrap_new_btConvexHullComputer_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtConvexHullComputer(arg1 BtConvexHullComputer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexHullComputer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtConvexHullComputer interface { + Swigcptr() uintptr + SwigIsBtConvexHullComputer() + SetVertices(arg2 BtAlignedObjectArray_Sl_btVector3_Sg_) + GetVertices() (_swig_ret BtAlignedObjectArray_Sl_btVector3_Sg_) + SetOriginal_vertex_index(arg2 BtAlignedObjectArray_Sl_int_Sg_) + GetOriginal_vertex_index() (_swig_ret BtAlignedObjectArray_Sl_int_Sg_) + SetEdges(arg2 BtAlignedObjectArray_Sl_btConvexHullComputer_Edge_Sg_) + GetEdges() (_swig_ret BtAlignedObjectArray_Sl_btConvexHullComputer_Edge_Sg_) + SetFaces(arg2 BtAlignedObjectArray_Sl_int_Sg_) + GetFaces() (_swig_ret BtAlignedObjectArray_Sl_int_Sg_) + Compute(a ...interface{}) float32 +} + +type SwigcptrBtConvexHullInternal uintptr + +func (p SwigcptrBtConvexHullInternal) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexHullInternal) SwigIsBtConvexHullInternal() { +} + +func (arg1 SwigcptrBtConvexHullInternal) SetVertexList(arg2 BtConvexHullInternal_Vertex) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexHullInternal_vertexList_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexHullInternal) GetVertexList() (_swig_ret BtConvexHullInternal_Vertex) { + var swig_r BtConvexHullInternal_Vertex + _swig_i_0 := arg1 + swig_r = (BtConvexHullInternal_Vertex)(SwigcptrBtConvexHullInternal_Vertex(C._wrap_btConvexHullInternal_vertexList_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexHullInternal) Compute(arg2 uintptr, arg3 bool, arg4 int, arg5 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btConvexHullInternal_compute_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C._Bool(_swig_i_2), C.swig_intgo(_swig_i_3), C.swig_intgo(_swig_i_4)) +} + +func (arg1 SwigcptrBtConvexHullInternal) GetCoordinates(arg2 BtConvexHullInternal_Vertex) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexHullInternal_getCoordinates_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexHullInternal) Shrink(arg2 float32, arg3 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btConvexHullInternal_shrink_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2))) + return swig_r +} + +func NewBtConvexHullInternal() (_swig_ret BtConvexHullInternal) { + var swig_r BtConvexHullInternal + swig_r = (BtConvexHullInternal)(SwigcptrBtConvexHullInternal(C._wrap_new_btConvexHullInternal_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtConvexHullInternal(arg1 BtConvexHullInternal) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexHullInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtConvexHullInternal interface { + Swigcptr() uintptr + SwigIsBtConvexHullInternal() + SetVertexList(arg2 BtConvexHullInternal_Vertex) + GetVertexList() (_swig_ret BtConvexHullInternal_Vertex) + Compute(arg2 uintptr, arg3 bool, arg4 int, arg5 int) + GetCoordinates(arg2 BtConvexHullInternal_Vertex) (_swig_ret BtVector3) + Shrink(arg2 float32, arg3 float32) (_swig_ret float32) +} + +type SwigcptrPointCmp uintptr + +func (p SwigcptrPointCmp) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrPointCmp) SwigIsPointCmp() { +} + +func NewPointCmp() (_swig_ret PointCmp) { + var swig_r PointCmp + swig_r = (PointCmp)(SwigcptrPointCmp(C._wrap_new_pointCmp_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeletePointCmp(arg1 PointCmp) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_pointCmp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type PointCmp interface { + Swigcptr() uintptr + SwigIsPointCmp() +} + +func GetVertexCopy(arg1 BtConvexHullInternal_Vertex, arg2 BtAlignedObjectArray_Sl_btConvexHullInternal_Vertex_Sm__Sg_) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (int)(C._wrap_getVertexCopy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +type SwigcptrBtGeometryUtil uintptr + +func (p SwigcptrBtGeometryUtil) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGeometryUtil) SwigIsBtGeometryUtil() { +} + +func BtGeometryUtilGetPlaneEquationsFromVertices(arg1 BtAlignedObjectArray_Sl_btVector3_Sg_, arg2 BtAlignedObjectArray_Sl_btVector3_Sg_) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeometryUtil_getPlaneEquationsFromVertices_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func BtGeometryUtilGetVerticesFromPlaneEquations(arg1 BtAlignedObjectArray_Sl_btVector3_Sg_, arg2 BtAlignedObjectArray_Sl_btVector3_Sg_) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeometryUtil_getVerticesFromPlaneEquations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func BtGeometryUtilIsPointInsidePlanes(arg1 BtAlignedObjectArray_Sl_btVector3_Sg_, arg2 BtVector3, arg3 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (bool)(C._wrap_btGeometryUtil_isPointInsidePlanes_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2))) + return swig_r +} + +func BtGeometryUtilAreVerticesBehindPlane(arg1 BtVector3, arg2 BtAlignedObjectArray_Sl_btVector3_Sg_, arg3 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (bool)(C._wrap_btGeometryUtil_areVerticesBehindPlane_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2))) + return swig_r +} + +func NewBtGeometryUtil() (_swig_ret BtGeometryUtil) { + var swig_r BtGeometryUtil + swig_r = (BtGeometryUtil)(SwigcptrBtGeometryUtil(C._wrap_new_btGeometryUtil_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtGeometryUtil(arg1 BtGeometryUtil) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGeometryUtil_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtGeometryUtil interface { + Swigcptr() uintptr + SwigIsBtGeometryUtil() +} + +func BtBulletMathProbe() { + C._wrap_btBulletMathProbe_mbt_e879218550ba2e2b() +} + +func NotExist(arg1 BtVector3, arg2 BtAlignedObjectArray_Sl_btVector3_Sg_) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_notExist_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +type SwigcptrGrahamVector3 uintptr + +func (p SwigcptrGrahamVector3) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrGrahamVector3) SwigIsGrahamVector3() { +} + +func NewGrahamVector3(arg1 BtVector3, arg2 int) (_swig_ret GrahamVector3) { + var swig_r GrahamVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (GrahamVector3)(SwigcptrGrahamVector3(C._wrap_new_GrahamVector3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrGrahamVector3) SetM_angle(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_GrahamVector3_m_angle_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrGrahamVector3) GetM_angle() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_GrahamVector3_m_angle_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrGrahamVector3) SetM_orgIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_GrahamVector3_m_orgIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrGrahamVector3) GetM_orgIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_GrahamVector3_m_orgIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteGrahamVector3(arg1 GrahamVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_GrahamVector3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) SetM_floats(arg1 *float32) { + _swig_i_0 := arg1 + C._wrap_SetGrahamVector3_M_floats_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_voidp(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) GetM_floats() (_swig_ret *float32) { + var swig_r *float32 + swig_r = (*float32)(C._wrap_GetGrahamVector3_M_floats_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrGrahamVector3) Operator_Sm__Se_(a ...interface{}) { + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrGrahamVector3) Dot(arg1 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float32)(C._wrap_GrahamVector3_dot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Length2() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_length2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Length() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_length_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Norm() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_norm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) SafeNorm() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_safeNorm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Distance2(arg1 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float32)(C._wrap_GrahamVector3_distance2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Distance(arg1 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float32)(C._wrap_GrahamVector3_distance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) SafeNormalize() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GrahamVector3_safeNormalize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Normalize() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GrahamVector3_normalize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Normalized() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GrahamVector3_normalized_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Rotate(arg1 BtVector3, arg2 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GrahamVector3_rotate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Angle(arg1 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float32)(C._wrap_GrahamVector3_angle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Absolute() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GrahamVector3_absolute_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Cross(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GrahamVector3_cross_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Triple(arg1 BtVector3, arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_GrahamVector3_triple_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) MinAxis() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GrahamVector3_minAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) MaxAxis() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GrahamVector3_maxAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) FurthestAxis() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GrahamVector3_furthestAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) ClosestAxis() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GrahamVector3_closestAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) SetInterpolate3(arg1 BtVector3, arg2 BtVector3, arg3 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_GrahamVector3_setInterpolate3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)) +} + +func (_swig_base SwigcptrGrahamVector3) Lerp(arg1 BtVector3, arg2 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GrahamVector3_lerp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) GetX() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_getX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) GetY() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_getY_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) GetZ() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_getZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) SetX(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_GrahamVector3_setX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) SetY(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_GrahamVector3_setY_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) SetZ(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_GrahamVector3_setZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) SetW(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_GrahamVector3_setW_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) X() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_x_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Y() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_y_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Z() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_z_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) W() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GrahamVector3_w_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) SetMax(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_GrahamVector3_setMax_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) SetMin(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_GrahamVector3_setMin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) SetValue(arg1 float32, arg2 float32, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_GrahamVector3_setValue_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)) +} + +func (_swig_base SwigcptrGrahamVector3) GetSkewSymmetricMatrix(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_GrahamVector3_getSkewSymmetricMatrix_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrGrahamVector3) SetZero() { + C._wrap_GrahamVector3_setZero_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrGrahamVector3) IsZero() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_GrahamVector3_isZero_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) FuzzyZero() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_GrahamVector3_fuzzyZero_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Serialize(arg1 BtVector3FloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_GrahamVector3_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) DeSerialize__SWIG_0(arg1 BtVector3DoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_GrahamVector3_deSerialize__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) DeSerialize__SWIG_1(arg1 BtVector3FloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_GrahamVector3_deSerialize__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrGrahamVector3) DeSerialize(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3DoubleData); !ok { + goto check_1 + } + p.DeSerialize__SWIG_0(a[0].(BtVector3DoubleData)) + return + } +check_1: + if argc == 1 { + p.DeSerialize__SWIG_1(a[0].(BtVector3FloatData)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrGrahamVector3) SerializeFloat(arg1 BtVector3FloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_GrahamVector3_serializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) DeSerializeFloat(arg1 BtVector3FloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_GrahamVector3_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) SerializeDouble(arg1 BtVector3DoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_GrahamVector3_serializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) DeSerializeDouble(arg1 BtVector3DoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_GrahamVector3_deSerializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrGrahamVector3) MaxDot(arg1 BtVector3, arg2 int64, arg3 *float32) (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (int64)(C._wrap_GrahamVector3_maxDot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_type_21(_swig_i_1), C.swig_voidp(_swig_i_2))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) MinDot(arg1 BtVector3, arg2 int64, arg3 *float32) (_swig_ret int64) { + var swig_r int64 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (int64)(C._wrap_GrahamVector3_minDot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_type_23(_swig_i_1), C.swig_voidp(_swig_i_2))) + return swig_r +} + +func (_swig_base SwigcptrGrahamVector3) Dot3(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GrahamVector3_dot3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (p SwigcptrGrahamVector3) SwigIsBtVector3() { +} + +func (p SwigcptrGrahamVector3) SwigGetBtVector3() BtVector3 { + return SwigcptrBtVector3(getSwigcptr(p)) +} + +type GrahamVector3 interface { + Swigcptr() uintptr + SwigIsGrahamVector3() + SetM_angle(arg2 float32) + GetM_angle() (_swig_ret float32) + SetM_orgIndex(arg2 int) + GetM_orgIndex() (_swig_ret int) + SetM_floats(arg1 *float32) + GetM_floats() (_swig_ret *float32) + Operator_Sm__Se_(a ...interface{}) + Dot(arg1 BtVector3) (_swig_ret float32) + Length2() (_swig_ret float32) + Length() (_swig_ret float32) + Norm() (_swig_ret float32) + SafeNorm() (_swig_ret float32) + Distance2(arg1 BtVector3) (_swig_ret float32) + Distance(arg1 BtVector3) (_swig_ret float32) + SafeNormalize() (_swig_ret BtVector3) + Normalize() (_swig_ret BtVector3) + Normalized() (_swig_ret BtVector3) + Rotate(arg1 BtVector3, arg2 float32) (_swig_ret BtVector3) + Angle(arg1 BtVector3) (_swig_ret float32) + Absolute() (_swig_ret BtVector3) + Cross(arg1 BtVector3) (_swig_ret BtVector3) + Triple(arg1 BtVector3, arg2 BtVector3) (_swig_ret float32) + MinAxis() (_swig_ret int) + MaxAxis() (_swig_ret int) + FurthestAxis() (_swig_ret int) + ClosestAxis() (_swig_ret int) + SetInterpolate3(arg1 BtVector3, arg2 BtVector3, arg3 float32) + Lerp(arg1 BtVector3, arg2 float32) (_swig_ret BtVector3) + GetX() (_swig_ret float32) + GetY() (_swig_ret float32) + GetZ() (_swig_ret float32) + SetX(arg1 float32) + SetY(arg1 float32) + SetZ(arg1 float32) + SetW(arg1 float32) + X() (_swig_ret float32) + Y() (_swig_ret float32) + Z() (_swig_ret float32) + W() (_swig_ret float32) + SetMax(arg1 BtVector3) + SetMin(arg1 BtVector3) + SetValue(arg1 float32, arg2 float32, arg3 float32) + GetSkewSymmetricMatrix(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) + SetZero() + IsZero() (_swig_ret bool) + FuzzyZero() (_swig_ret bool) + Serialize(arg1 BtVector3FloatData) + DeSerialize(a ...interface{}) + SerializeFloat(arg1 BtVector3FloatData) + DeSerializeFloat(arg1 BtVector3FloatData) + SerializeDouble(arg1 BtVector3DoubleData) + DeSerializeDouble(arg1 BtVector3DoubleData) + MaxDot(arg1 BtVector3, arg2 int64, arg3 *float32) (_swig_ret int64) + MinDot(arg1 BtVector3, arg2 int64, arg3 *float32) (_swig_ret int64) + Dot3(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) (_swig_ret BtVector3) + SwigIsBtVector3() + SwigGetBtVector3() BtVector3 +} + +type SwigcptrBtAngleCompareFunc uintptr + +func (p SwigcptrBtAngleCompareFunc) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtAngleCompareFunc) SwigIsBtAngleCompareFunc() { +} + +func (arg1 SwigcptrBtAngleCompareFunc) SetM_anchor(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btAngleCompareFunc_m_anchor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtAngleCompareFunc) GetM_anchor() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btAngleCompareFunc_m_anchor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtAngleCompareFunc(arg1 BtVector3) (_swig_ret BtAngleCompareFunc) { + var swig_r BtAngleCompareFunc + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtAngleCompareFunc)(SwigcptrBtAngleCompareFunc(C._wrap_new_btAngleCompareFunc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func DeleteBtAngleCompareFunc(arg1 BtAngleCompareFunc) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btAngleCompareFunc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtAngleCompareFunc interface { + Swigcptr() uintptr + SwigIsBtAngleCompareFunc() + SetM_anchor(arg2 BtVector3) + GetM_anchor() (_swig_ret BtVector3) +} + +func GrahamScanConvexHull2D(arg1 BtAlignedObjectArray_Sl_GrahamVector3_Sg_, arg2 BtAlignedObjectArray_Sl_GrahamVector3_Sg_, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_GrahamScanConvexHull2D_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +type SwigcptrBtBoxShape uintptr + +func (p SwigcptrBtBoxShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBoxShape) SwigIsBtBoxShape() { +} + +func (arg1 SwigcptrBtBoxShape) GetHalfExtentsWithMargin() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBoxShape_getHalfExtentsWithMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBoxShape) GetHalfExtentsWithoutMargin() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBoxShape_getHalfExtentsWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBoxShape) LocalGetSupportingVertex(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBoxShape_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtBoxShape) LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBoxShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtBoxShape) BatchedUnitVectorGetSupportingVertexWithoutMargin(arg2 BtVector3, arg3 BtVector3, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btBoxShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func NewBtBoxShape(arg1 BtVector3) (_swig_ret BtBoxShape) { + var swig_r BtBoxShape + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtBoxShape)(SwigcptrBtBoxShape(C._wrap_new_btBoxShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBoxShape) SetMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBoxShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtBoxShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBoxShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBoxShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btBoxShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtBoxShape) CalculateLocalInertia(arg2 float32, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBoxShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtBoxShape) GetPlane(arg2 BtVector3, arg3 BtVector3, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btBoxShape_getPlane_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtBoxShape) GetNumPlanes() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBoxShape_getNumPlanes_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBoxShape) GetNumVertices() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBoxShape_getNumVertices_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBoxShape) GetNumEdges() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBoxShape_getNumEdges_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBoxShape) GetVertex(arg2 int, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBoxShape_getVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtBoxShape) GetPlaneEquation(arg2 BtVector4, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btBoxShape_getPlaneEquation_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtBoxShape) GetEdge(arg2 int, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btBoxShape_getEdge_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtBoxShape) IsInside(arg2 BtVector3, arg3 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (bool)(C._wrap_btBoxShape_isInside_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtBoxShape) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btBoxShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtBoxShape) GetNumPreferredPenetrationDirections() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBoxShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBoxShape) GetPreferredPenetrationDirection(arg2 int, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBoxShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func DeleteBtBoxShape(arg1 BtBoxShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBoxShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBoxShape) InitializePolyhedralFeatures__SWIG_0(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBoxShape_initializePolyhedralFeatures__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) InitializePolyhedralFeatures__SWIG_1() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBoxShape_initializePolyhedralFeatures__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtBoxShape) InitializePolyhedralFeatures(a ...interface{}) bool { + argc := len(a) + if argc == 0 { + return p.InitializePolyhedralFeatures__SWIG_1() + } + if argc == 1 { + return p.InitializePolyhedralFeatures__SWIG_0(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtBoxShape) SetPolyhedralFeatures(arg1 BtConvexPolyhedron) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btBoxShape_setPolyhedralFeatures_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBoxShape) GetConvexPolyhedron() (_swig_ret BtConvexPolyhedron) { + var swig_r BtConvexPolyhedron + swig_r = (BtConvexPolyhedron)(SwigcptrBtConvexPolyhedron(C._wrap_btBoxShape_getConvexPolyhedron_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) GetImplicitShapeDimensions() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBoxShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) SetImplicitShapeDimensions(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btBoxShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBoxShape) SetSafeMargin__SWIG_0(arg1 float32, arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBoxShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtBoxShape) SetSafeMargin__SWIG_1(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btBoxShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBoxShape) SetSafeMargin__SWIG_2(arg1 BtVector3, arg2 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btBoxShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtBoxShape) SetSafeMargin__SWIG_3(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btBoxShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtBoxShape) SetSafeMargin(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + p.SetSafeMargin__SWIG_3(a[0].(BtVector3)) + return + } +check_1: + if argc == 1 { + p.SetSafeMargin__SWIG_1(a[0].(float32)) + return + } + if argc == 2 { + if _, ok := a[0].(BtVector3); !ok { + goto check_3 + } + p.SetSafeMargin__SWIG_2(a[0].(BtVector3), a[1].(float32)) + return + } +check_3: + if argc == 2 { + p.SetSafeMargin__SWIG_0(a[0].(float32), a[1].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtBoxShape) GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBoxShape_getAabbSlow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtBoxShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBoxShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) GetLocalScalingNV() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBoxShape_getLocalScalingNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btBoxShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) GetMarginNV() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btBoxShape_getMarginNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btBoxShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btBoxShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtBoxShape) LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBoxShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBoxShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) GetMarginNonVirtual() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btBoxShape_getMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBoxShape_getAabbNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtBoxShape) Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btBoxShape_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtBoxShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btBoxShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtBoxShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btBoxShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btBoxShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btBoxShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtBoxShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBoxShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBoxShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBoxShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBoxShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBoxShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBoxShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBoxShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBoxShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btBoxShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBoxShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btBoxShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBoxShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btBoxShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btBoxShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBoxShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btBoxShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btBoxShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBoxShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btBoxShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBoxShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btBoxShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtBoxShape) SwigIsBtPolyhedralConvexShape() { +} + +func (p SwigcptrBtBoxShape) SwigGetBtPolyhedralConvexShape() BtPolyhedralConvexShape { + return SwigcptrBtPolyhedralConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtBoxShape) SwigIsBtConvexInternalShape() { +} + +func (p SwigcptrBtBoxShape) SwigGetBtConvexInternalShape() BtConvexInternalShape { + return SwigcptrBtConvexInternalShape(getSwigcptr(p)) +} + +func (p SwigcptrBtBoxShape) SwigIsBtConvexShape() { +} + +func (p SwigcptrBtBoxShape) SwigGetBtConvexShape() BtConvexShape { + return SwigcptrBtConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtBoxShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtBoxShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtBoxShape interface { + Swigcptr() uintptr + SwigIsBtBoxShape() + GetHalfExtentsWithMargin() (_swig_ret BtVector3) + GetHalfExtentsWithoutMargin() (_swig_ret BtVector3) + LocalGetSupportingVertex(arg2 BtVector3) (_swig_ret BtVector3) + LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) + BatchedUnitVectorGetSupportingVertexWithoutMargin(arg2 BtVector3, arg3 BtVector3, arg4 int) + SetMargin(arg2 float32) + SetLocalScaling(arg2 BtVector3) + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + CalculateLocalInertia(arg2 float32, arg3 BtVector3) + GetPlane(arg2 BtVector3, arg3 BtVector3, arg4 int) + GetNumPlanes() (_swig_ret int) + GetNumVertices() (_swig_ret int) + GetNumEdges() (_swig_ret int) + GetVertex(arg2 int, arg3 BtVector3) + GetPlaneEquation(arg2 BtVector4, arg3 int) + GetEdge(arg2 int, arg3 BtVector3, arg4 BtVector3) + IsInside(arg2 BtVector3, arg3 float32) (_swig_ret bool) + GetName() (_swig_ret string) + GetNumPreferredPenetrationDirections() (_swig_ret int) + GetPreferredPenetrationDirection(arg2 int, arg3 BtVector3) + InitializePolyhedralFeatures(a ...interface{}) bool + SetPolyhedralFeatures(arg1 BtConvexPolyhedron) + GetConvexPolyhedron() (_swig_ret BtConvexPolyhedron) + GetImplicitShapeDimensions() (_swig_ret BtVector3) + SetImplicitShapeDimensions(arg1 BtVector3) + SetSafeMargin(a ...interface{}) + GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetLocalScalingNV() (_swig_ret BtVector3) + GetMargin() (_swig_ret float32) + GetMarginNV() (_swig_ret float32) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + GetMarginNonVirtual() (_swig_ret float32) + GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtPolyhedralConvexShape() + SwigGetBtPolyhedralConvexShape() BtPolyhedralConvexShape + SwigIsBtConvexInternalShape() + SwigGetBtConvexInternalShape() BtConvexInternalShape + SwigIsBtConvexShape() + SwigGetBtConvexShape() BtConvexShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtCapsuleShape uintptr + +func (p SwigcptrBtCapsuleShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCapsuleShape) SwigIsBtCapsuleShape() { +} + +func NewBtCapsuleShape__SWIG_1(arg1 float32, arg2 float32) (_swig_ret BtCapsuleShape) { + var swig_r BtCapsuleShape + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtCapsuleShape)(SwigcptrBtCapsuleShape(C._wrap_new_btCapsuleShape__SWIG_1_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func NewBtCapsuleShape(a ...interface{}) BtCapsuleShape { + argc := len(a) + if argc == 2 { + return NewBtCapsuleShape__SWIG_1(a[0].(float32), a[1].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCapsuleShape) CalculateLocalInertia(arg2 float32, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCapsuleShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtCapsuleShape) LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtCapsuleShape) BatchedUnitVectorGetSupportingVertexWithoutMargin(arg2 BtVector3, arg3 BtVector3, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btCapsuleShape_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtCapsuleShape) SetMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCapsuleShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCapsuleShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btCapsuleShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtCapsuleShape) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btCapsuleShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtCapsuleShape) GetUpAxis() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCapsuleShape_getUpAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCapsuleShape) GetRadius() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCapsuleShape_getRadius_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCapsuleShape) GetHalfHeight() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCapsuleShape_getHalfHeight_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCapsuleShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCapsuleShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCapsuleShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCapsuleShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCapsuleShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCapsuleShape) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btCapsuleShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtCapsuleShape) DeSerializeFloat(arg2 BtCapsuleShapeData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCapsuleShape_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBtCapsuleShape(arg1 BtCapsuleShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCapsuleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShape) LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShape_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) GetImplicitShapeDimensions() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShape_getImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) SetImplicitShapeDimensions(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShape_setImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShape) SetSafeMargin__SWIG_0(arg1 float32, arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCapsuleShape_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShape) SetSafeMargin__SWIG_1(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShape_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShape) SetSafeMargin__SWIG_2(arg1 BtVector3, arg2 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btCapsuleShape_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShape) SetSafeMargin__SWIG_3(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShape_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtCapsuleShape) SetSafeMargin(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + p.SetSafeMargin__SWIG_3(a[0].(BtVector3)) + return + } +check_1: + if argc == 1 { + p.SetSafeMargin__SWIG_1(a[0].(float32)) + return + } + if argc == 2 { + if _, ok := a[0].(BtVector3); !ok { + goto check_3 + } + p.SetSafeMargin__SWIG_2(a[0].(BtVector3), a[1].(float32)) + return + } +check_3: + if argc == 2 { + p.SetSafeMargin__SWIG_0(a[0].(float32), a[1].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtCapsuleShape) GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCapsuleShape_getAabbSlow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtCapsuleShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) GetLocalScalingNV() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShape_getLocalScalingNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) GetMarginNV() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShape_getMarginNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) GetNumPreferredPenetrationDirections() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShape_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCapsuleShape_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShape) LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShape_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShape_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) GetMarginNonVirtual() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShape_getMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCapsuleShape_getAabbNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtCapsuleShape) Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btCapsuleShape_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtCapsuleShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btCapsuleShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCapsuleShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btCapsuleShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtCapsuleShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btCapsuleShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtCapsuleShape) SwigIsBtConvexInternalShape() { +} + +func (p SwigcptrBtCapsuleShape) SwigGetBtConvexInternalShape() BtConvexInternalShape { + return SwigcptrBtConvexInternalShape(getSwigcptr(p)) +} + +func (p SwigcptrBtCapsuleShape) SwigIsBtConvexShape() { +} + +func (p SwigcptrBtCapsuleShape) SwigGetBtConvexShape() BtConvexShape { + return SwigcptrBtConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtCapsuleShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtCapsuleShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtCapsuleShape interface { + Swigcptr() uintptr + SwigIsBtCapsuleShape() + CalculateLocalInertia(arg2 float32, arg3 BtVector3) + LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) + BatchedUnitVectorGetSupportingVertexWithoutMargin(arg2 BtVector3, arg3 BtVector3, arg4 int) + SetMargin(arg2 float32) + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + GetName() (_swig_ret string) + GetUpAxis() (_swig_ret int) + GetRadius() (_swig_ret float32) + GetHalfHeight() (_swig_ret float32) + SetLocalScaling(arg2 BtVector3) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + DeSerializeFloat(arg2 BtCapsuleShapeData) + LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) + GetImplicitShapeDimensions() (_swig_ret BtVector3) + SetImplicitShapeDimensions(arg1 BtVector3) + SetSafeMargin(a ...interface{}) + GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetLocalScalingNV() (_swig_ret BtVector3) + GetMargin() (_swig_ret float32) + GetMarginNV() (_swig_ret float32) + GetNumPreferredPenetrationDirections() (_swig_ret int) + GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) + LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + GetMarginNonVirtual() (_swig_ret float32) + GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetShapeType() (_swig_ret int) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtConvexInternalShape() + SwigGetBtConvexInternalShape() BtConvexInternalShape + SwigIsBtConvexShape() + SwigGetBtConvexShape() BtConvexShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtCapsuleShapeX uintptr + +func (p SwigcptrBtCapsuleShapeX) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCapsuleShapeX) SwigIsBtCapsuleShapeX() { +} + +func NewBtCapsuleShapeX(arg1 float32, arg2 float32) (_swig_ret BtCapsuleShapeX) { + var swig_r BtCapsuleShapeX + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtCapsuleShapeX)(SwigcptrBtCapsuleShapeX(C._wrap_new_btCapsuleShapeX_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtCapsuleShapeX) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btCapsuleShapeX_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func DeleteBtCapsuleShapeX(arg1 BtCapsuleShapeX) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCapsuleShapeX_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) CalculateLocalInertia(arg1 float32, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCapsuleShapeX_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeX_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) BatchedUnitVectorGetSupportingVertexWithoutMargin(arg1 BtVector3, arg2 BtVector3, arg3 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btCapsuleShapeX_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SetMargin(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShapeX_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCapsuleShapeX_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetUpAxis() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeX_getUpAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetRadius() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeX_getRadius_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetHalfHeight() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeX_getHalfHeight_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SetLocalScaling(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShapeX_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeX_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeX_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btCapsuleShapeX_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtCapsuleShapeX) DeSerializeFloat(arg1 BtCapsuleShapeData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShapeX_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeX_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetImplicitShapeDimensions() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeX_getImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SetImplicitShapeDimensions(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShapeX_setImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SetSafeMargin__SWIG_0(arg1 float32, arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCapsuleShapeX_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SetSafeMargin__SWIG_1(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShapeX_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SetSafeMargin__SWIG_2(arg1 BtVector3, arg2 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btCapsuleShapeX_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SetSafeMargin__SWIG_3(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShapeX_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtCapsuleShapeX) SetSafeMargin(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + p.SetSafeMargin__SWIG_3(a[0].(BtVector3)) + return + } +check_1: + if argc == 1 { + p.SetSafeMargin__SWIG_1(a[0].(float32)) + return + } + if argc == 2 { + if _, ok := a[0].(BtVector3); !ok { + goto check_3 + } + p.SetSafeMargin__SWIG_2(a[0].(BtVector3), a[1].(float32)) + return + } +check_3: + if argc == 2 { + p.SetSafeMargin__SWIG_0(a[0].(float32), a[1].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCapsuleShapeX_getAabbSlow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeX_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetLocalScalingNV() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeX_getLocalScalingNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeX_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetMarginNV() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeX_getMarginNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetNumPreferredPenetrationDirections() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeX_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCapsuleShapeX_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeX_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeX_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetMarginNonVirtual() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeX_getMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCapsuleShapeX_getAabbNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btCapsuleShapeX_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btCapsuleShapeX_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeX_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCapsuleShapeX_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btCapsuleShapeX_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeX_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeX_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeX_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeX_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeX_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeX_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeX_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeX_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeX_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShapeX_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btCapsuleShapeX_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShapeX_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeX_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShapeX_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeX) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeX_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeX) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShapeX_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtCapsuleShapeX) SwigIsBtCapsuleShape() { +} + +func (p SwigcptrBtCapsuleShapeX) SwigGetBtCapsuleShape() BtCapsuleShape { + return SwigcptrBtCapsuleShape(getSwigcptr(p)) +} + +func (p SwigcptrBtCapsuleShapeX) SwigIsBtConvexInternalShape() { +} + +func (p SwigcptrBtCapsuleShapeX) SwigGetBtConvexInternalShape() BtConvexInternalShape { + return SwigcptrBtConvexInternalShape(getSwigcptr(p)) +} + +func (p SwigcptrBtCapsuleShapeX) SwigIsBtConvexShape() { +} + +func (p SwigcptrBtCapsuleShapeX) SwigGetBtConvexShape() BtConvexShape { + return SwigcptrBtConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtCapsuleShapeX) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtCapsuleShapeX) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtCapsuleShapeX interface { + Swigcptr() uintptr + SwigIsBtCapsuleShapeX() + GetName() (_swig_ret string) + CalculateLocalInertia(arg1 float32, arg2 BtVector3) + LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) + BatchedUnitVectorGetSupportingVertexWithoutMargin(arg1 BtVector3, arg2 BtVector3, arg3 int) + SetMargin(arg1 float32) + GetAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + GetUpAxis() (_swig_ret int) + GetRadius() (_swig_ret float32) + GetHalfHeight() (_swig_ret float32) + SetLocalScaling(arg1 BtVector3) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + DeSerializeFloat(arg1 BtCapsuleShapeData) + LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) + GetImplicitShapeDimensions() (_swig_ret BtVector3) + SetImplicitShapeDimensions(arg1 BtVector3) + SetSafeMargin(a ...interface{}) + GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetLocalScalingNV() (_swig_ret BtVector3) + GetMargin() (_swig_ret float32) + GetMarginNV() (_swig_ret float32) + GetNumPreferredPenetrationDirections() (_swig_ret int) + GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) + LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + GetMarginNonVirtual() (_swig_ret float32) + GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetShapeType() (_swig_ret int) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtCapsuleShape() + SwigGetBtCapsuleShape() BtCapsuleShape + SwigIsBtConvexInternalShape() + SwigGetBtConvexInternalShape() BtConvexInternalShape + SwigIsBtConvexShape() + SwigGetBtConvexShape() BtConvexShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtCapsuleShapeZ uintptr + +func (p SwigcptrBtCapsuleShapeZ) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCapsuleShapeZ) SwigIsBtCapsuleShapeZ() { +} + +func NewBtCapsuleShapeZ(arg1 float32, arg2 float32) (_swig_ret BtCapsuleShapeZ) { + var swig_r BtCapsuleShapeZ + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtCapsuleShapeZ)(SwigcptrBtCapsuleShapeZ(C._wrap_new_btCapsuleShapeZ_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtCapsuleShapeZ) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btCapsuleShapeZ_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func DeleteBtCapsuleShapeZ(arg1 BtCapsuleShapeZ) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCapsuleShapeZ_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) CalculateLocalInertia(arg1 float32, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCapsuleShapeZ_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeZ_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) BatchedUnitVectorGetSupportingVertexWithoutMargin(arg1 BtVector3, arg2 BtVector3, arg3 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btCapsuleShapeZ_batchedUnitVectorGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SetMargin(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShapeZ_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCapsuleShapeZ_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetUpAxis() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeZ_getUpAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetRadius() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeZ_getRadius_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetHalfHeight() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeZ_getHalfHeight_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SetLocalScaling(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShapeZ_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeZ_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeZ_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btCapsuleShapeZ_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) DeSerializeFloat(arg1 BtCapsuleShapeData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShapeZ_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeZ_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetImplicitShapeDimensions() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeZ_getImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SetImplicitShapeDimensions(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShapeZ_setImplicitShapeDimensions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SetSafeMargin__SWIG_0(arg1 float32, arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCapsuleShapeZ_setSafeMargin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SetSafeMargin__SWIG_1(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShapeZ_setSafeMargin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SetSafeMargin__SWIG_2(arg1 BtVector3, arg2 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btCapsuleShapeZ_setSafeMargin__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SetSafeMargin__SWIG_3(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShapeZ_setSafeMargin__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtCapsuleShapeZ) SetSafeMargin(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + p.SetSafeMargin__SWIG_3(a[0].(BtVector3)) + return + } +check_1: + if argc == 1 { + p.SetSafeMargin__SWIG_1(a[0].(float32)) + return + } + if argc == 2 { + if _, ok := a[0].(BtVector3); !ok { + goto check_3 + } + p.SetSafeMargin__SWIG_2(a[0].(BtVector3), a[1].(float32)) + return + } +check_3: + if argc == 2 { + p.SetSafeMargin__SWIG_0(a[0].(float32), a[1].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCapsuleShapeZ_getAabbSlow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeZ_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetLocalScalingNV() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeZ_getLocalScalingNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeZ_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetMarginNV() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeZ_getMarginNV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetNumPreferredPenetrationDirections() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeZ_getNumPreferredPenetrationDirections_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCapsuleShapeZ_getPreferredPenetrationDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeZ_localGetSupportVertexWithoutMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCapsuleShapeZ_localGetSupportVertexNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetMarginNonVirtual() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeZ_getMarginNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCapsuleShapeZ_getAabbNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btCapsuleShapeZ_project_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btCapsuleShapeZ_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btCapsuleShapeZ_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCapsuleShapeZ_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btCapsuleShapeZ_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeZ_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeZ_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeZ_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeZ_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeZ_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeZ_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeZ_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btCapsuleShapeZ_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeZ_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShapeZ_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btCapsuleShapeZ_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShapeZ_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeZ_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btCapsuleShapeZ_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btCapsuleShapeZ_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtCapsuleShapeZ) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btCapsuleShapeZ_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtCapsuleShapeZ) SwigIsBtCapsuleShape() { +} + +func (p SwigcptrBtCapsuleShapeZ) SwigGetBtCapsuleShape() BtCapsuleShape { + return SwigcptrBtCapsuleShape(getSwigcptr(p)) +} + +func (p SwigcptrBtCapsuleShapeZ) SwigIsBtConvexInternalShape() { +} + +func (p SwigcptrBtCapsuleShapeZ) SwigGetBtConvexInternalShape() BtConvexInternalShape { + return SwigcptrBtConvexInternalShape(getSwigcptr(p)) +} + +func (p SwigcptrBtCapsuleShapeZ) SwigIsBtConvexShape() { +} + +func (p SwigcptrBtCapsuleShapeZ) SwigGetBtConvexShape() BtConvexShape { + return SwigcptrBtConvexShape(getSwigcptr(p)) +} + +func (p SwigcptrBtCapsuleShapeZ) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtCapsuleShapeZ) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtCapsuleShapeZ interface { + Swigcptr() uintptr + SwigIsBtCapsuleShapeZ() + GetName() (_swig_ret string) + CalculateLocalInertia(arg1 float32, arg2 BtVector3) + LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) + BatchedUnitVectorGetSupportingVertexWithoutMargin(arg1 BtVector3, arg2 BtVector3, arg3 int) + SetMargin(arg1 float32) + GetAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + GetUpAxis() (_swig_ret int) + GetRadius() (_swig_ret float32) + GetHalfHeight() (_swig_ret float32) + SetLocalScaling(arg1 BtVector3) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + DeSerializeFloat(arg1 BtCapsuleShapeData) + LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) + GetImplicitShapeDimensions() (_swig_ret BtVector3) + SetImplicitShapeDimensions(arg1 BtVector3) + SetSafeMargin(a ...interface{}) + GetAabbSlow(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetLocalScalingNV() (_swig_ret BtVector3) + GetMargin() (_swig_ret float32) + GetMarginNV() (_swig_ret float32) + GetNumPreferredPenetrationDirections() (_swig_ret int) + GetPreferredPenetrationDirection(arg1 int, arg2 BtVector3) + LocalGetSupportVertexWithoutMarginNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportVertexNonVirtual(arg1 BtVector3) (_swig_ret BtVector3) + GetMarginNonVirtual() (_swig_ret float32) + GetAabbNonVirtual(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + Project(arg1 BtTransform, arg2 BtVector3, arg3 *float32, arg4 *float32, arg5 BtVector3, arg6 BtVector3) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetShapeType() (_swig_ret int) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtCapsuleShape() + SwigGetBtCapsuleShape() BtCapsuleShape + SwigIsBtConvexInternalShape() + SwigGetBtConvexInternalShape() BtConvexInternalShape + SwigIsBtConvexShape() + SwigGetBtConvexShape() BtConvexShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtCapsuleShapeData uintptr + +func (p SwigcptrBtCapsuleShapeData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCapsuleShapeData) SwigIsBtCapsuleShapeData() { +} + +func (arg1 SwigcptrBtCapsuleShapeData) SetM_convexInternalShapeData(arg2 BtConvexInternalShapeData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCapsuleShapeData_m_convexInternalShapeData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCapsuleShapeData) GetM_convexInternalShapeData() (_swig_ret BtConvexInternalShapeData) { + var swig_r BtConvexInternalShapeData + _swig_i_0 := arg1 + swig_r = (BtConvexInternalShapeData)(SwigcptrBtConvexInternalShapeData(C._wrap_btCapsuleShapeData_m_convexInternalShapeData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCapsuleShapeData) SetM_upAxis(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCapsuleShapeData_m_upAxis_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCapsuleShapeData) GetM_upAxis() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCapsuleShapeData_m_upAxis_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCapsuleShapeData) SetM_padding(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCapsuleShapeData_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_52)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtCapsuleShapeData) GetM_padding() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btCapsuleShapeData_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtCapsuleShapeData() (_swig_ret BtCapsuleShapeData) { + var swig_r BtCapsuleShapeData + swig_r = (BtCapsuleShapeData)(SwigcptrBtCapsuleShapeData(C._wrap_new_btCapsuleShapeData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtCapsuleShapeData(arg1 BtCapsuleShapeData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCapsuleShapeData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtCapsuleShapeData interface { + Swigcptr() uintptr + SwigIsBtCapsuleShapeData() + SetM_convexInternalShapeData(arg2 BtConvexInternalShapeData) + GetM_convexInternalShapeData() (_swig_ret BtConvexInternalShapeData) + SetM_upAxis(arg2 int) + GetM_upAxis() (_swig_ret int) + SetM_padding(arg2 string) + GetM_padding() (_swig_ret string) +} + +const ACTIVE_TAG int = 1 +const ISLAND_SLEEPING int = 2 +const WANTS_DEACTIVATION int = 3 +const DISABLE_DEACTIVATION int = 4 +const DISABLE_SIMULATION int = 5 +const FIXED_BASE_MULTI_BODY int = 6 +const BtCollisionObjectDataName string = "btCollisionObjectFloatData" + +type SwigcptrBtCollisionObject uintptr + +func (p SwigcptrBtCollisionObject) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionObject) SwigIsBtCollisionObject() { +} + +type BtCollisionObjectCollisionFlags int + +func _swig_getbtCollisionObject_CF_DYNAMIC_OBJECT_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_DYNAMIC_OBJECT_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_DYNAMIC_OBJECT BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_DYNAMIC_OBJECT_btCollisionObject() + +func _swig_getbtCollisionObject_CF_STATIC_OBJECT_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_STATIC_OBJECT_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_STATIC_OBJECT BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_STATIC_OBJECT_btCollisionObject() + +func _swig_getbtCollisionObject_CF_KINEMATIC_OBJECT_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_KINEMATIC_OBJECT_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_KINEMATIC_OBJECT BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_KINEMATIC_OBJECT_btCollisionObject() + +func _swig_getbtCollisionObject_CF_NO_CONTACT_RESPONSE_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_NO_CONTACT_RESPONSE_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_NO_CONTACT_RESPONSE BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_NO_CONTACT_RESPONSE_btCollisionObject() + +func _swig_getbtCollisionObject_CF_CUSTOM_MATERIAL_CALLBACK_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_CUSTOM_MATERIAL_CALLBACK_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_CUSTOM_MATERIAL_CALLBACK BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_CUSTOM_MATERIAL_CALLBACK_btCollisionObject() + +func _swig_getbtCollisionObject_CF_CHARACTER_OBJECT_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_CHARACTER_OBJECT_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_CHARACTER_OBJECT BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_CHARACTER_OBJECT_btCollisionObject() + +func _swig_getbtCollisionObject_CF_DISABLE_VISUALIZE_OBJECT_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_DISABLE_VISUALIZE_OBJECT_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_DISABLE_VISUALIZE_OBJECT BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_DISABLE_VISUALIZE_OBJECT_btCollisionObject() + +func _swig_getbtCollisionObject_CF_DISABLE_SPU_COLLISION_PROCESSING_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_DISABLE_SPU_COLLISION_PROCESSING_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_DISABLE_SPU_COLLISION_PROCESSING BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_DISABLE_SPU_COLLISION_PROCESSING_btCollisionObject() + +func _swig_getbtCollisionObject_CF_HAS_CONTACT_STIFFNESS_DAMPING_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_HAS_CONTACT_STIFFNESS_DAMPING_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_HAS_CONTACT_STIFFNESS_DAMPING BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_HAS_CONTACT_STIFFNESS_DAMPING_btCollisionObject() + +func _swig_getbtCollisionObject_CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_HAS_CUSTOM_DEBUG_RENDERING_COLOR BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR_btCollisionObject() + +func _swig_getbtCollisionObject_CF_HAS_FRICTION_ANCHOR_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_HAS_FRICTION_ANCHOR_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_HAS_FRICTION_ANCHOR BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_HAS_FRICTION_ANCHOR_btCollisionObject() + +func _swig_getbtCollisionObject_CF_HAS_COLLISION_SOUND_TRIGGER_btCollisionObject() (_swig_ret BtCollisionObjectCollisionFlags) { + var swig_r BtCollisionObjectCollisionFlags + swig_r = (BtCollisionObjectCollisionFlags)(C._wrap_CF_HAS_COLLISION_SOUND_TRIGGER_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_HAS_COLLISION_SOUND_TRIGGER BtCollisionObjectCollisionFlags = _swig_getbtCollisionObject_CF_HAS_COLLISION_SOUND_TRIGGER_btCollisionObject() + +type BtCollisionObjectCollisionObjectTypes int + +func _swig_getbtCollisionObject_CO_COLLISION_OBJECT_btCollisionObject() (_swig_ret BtCollisionObjectCollisionObjectTypes) { + var swig_r BtCollisionObjectCollisionObjectTypes + swig_r = (BtCollisionObjectCollisionObjectTypes)(C._wrap_CO_COLLISION_OBJECT_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCO_COLLISION_OBJECT BtCollisionObjectCollisionObjectTypes = _swig_getbtCollisionObject_CO_COLLISION_OBJECT_btCollisionObject() + +func _swig_getbtCollisionObject_CO_RIGID_BODY_btCollisionObject() (_swig_ret BtCollisionObjectCollisionObjectTypes) { + var swig_r BtCollisionObjectCollisionObjectTypes + swig_r = (BtCollisionObjectCollisionObjectTypes)(C._wrap_CO_RIGID_BODY_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCO_RIGID_BODY BtCollisionObjectCollisionObjectTypes = _swig_getbtCollisionObject_CO_RIGID_BODY_btCollisionObject() + +func _swig_getbtCollisionObject_CO_GHOST_OBJECT_btCollisionObject() (_swig_ret BtCollisionObjectCollisionObjectTypes) { + var swig_r BtCollisionObjectCollisionObjectTypes + swig_r = (BtCollisionObjectCollisionObjectTypes)(C._wrap_CO_GHOST_OBJECT_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCO_GHOST_OBJECT BtCollisionObjectCollisionObjectTypes = _swig_getbtCollisionObject_CO_GHOST_OBJECT_btCollisionObject() + +func _swig_getbtCollisionObject_CO_SOFT_BODY_btCollisionObject() (_swig_ret BtCollisionObjectCollisionObjectTypes) { + var swig_r BtCollisionObjectCollisionObjectTypes + swig_r = (BtCollisionObjectCollisionObjectTypes)(C._wrap_CO_SOFT_BODY_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCO_SOFT_BODY BtCollisionObjectCollisionObjectTypes = _swig_getbtCollisionObject_CO_SOFT_BODY_btCollisionObject() + +func _swig_getbtCollisionObject_CO_HF_FLUID_btCollisionObject() (_swig_ret BtCollisionObjectCollisionObjectTypes) { + var swig_r BtCollisionObjectCollisionObjectTypes + swig_r = (BtCollisionObjectCollisionObjectTypes)(C._wrap_CO_HF_FLUID_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCO_HF_FLUID BtCollisionObjectCollisionObjectTypes = _swig_getbtCollisionObject_CO_HF_FLUID_btCollisionObject() + +func _swig_getbtCollisionObject_CO_USER_TYPE_btCollisionObject() (_swig_ret BtCollisionObjectCollisionObjectTypes) { + var swig_r BtCollisionObjectCollisionObjectTypes + swig_r = (BtCollisionObjectCollisionObjectTypes)(C._wrap_CO_USER_TYPE_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCO_USER_TYPE BtCollisionObjectCollisionObjectTypes = _swig_getbtCollisionObject_CO_USER_TYPE_btCollisionObject() + +func _swig_getbtCollisionObject_CO_FEATHERSTONE_LINK_btCollisionObject() (_swig_ret BtCollisionObjectCollisionObjectTypes) { + var swig_r BtCollisionObjectCollisionObjectTypes + swig_r = (BtCollisionObjectCollisionObjectTypes)(C._wrap_CO_FEATHERSTONE_LINK_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCO_FEATHERSTONE_LINK BtCollisionObjectCollisionObjectTypes = _swig_getbtCollisionObject_CO_FEATHERSTONE_LINK_btCollisionObject() + +type BtCollisionObjectAnisotropicFrictionFlags int + +func _swig_getbtCollisionObject_CF_ANISOTROPIC_FRICTION_DISABLED_btCollisionObject() (_swig_ret BtCollisionObjectAnisotropicFrictionFlags) { + var swig_r BtCollisionObjectAnisotropicFrictionFlags + swig_r = (BtCollisionObjectAnisotropicFrictionFlags)(C._wrap_CF_ANISOTROPIC_FRICTION_DISABLED_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_ANISOTROPIC_FRICTION_DISABLED BtCollisionObjectAnisotropicFrictionFlags = _swig_getbtCollisionObject_CF_ANISOTROPIC_FRICTION_DISABLED_btCollisionObject() + +func _swig_getbtCollisionObject_CF_ANISOTROPIC_FRICTION_btCollisionObject() (_swig_ret BtCollisionObjectAnisotropicFrictionFlags) { + var swig_r BtCollisionObjectAnisotropicFrictionFlags + swig_r = (BtCollisionObjectAnisotropicFrictionFlags)(C._wrap_CF_ANISOTROPIC_FRICTION_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_ANISOTROPIC_FRICTION BtCollisionObjectAnisotropicFrictionFlags = _swig_getbtCollisionObject_CF_ANISOTROPIC_FRICTION_btCollisionObject() + +func _swig_getbtCollisionObject_CF_ANISOTROPIC_ROLLING_FRICTION_btCollisionObject() (_swig_ret BtCollisionObjectAnisotropicFrictionFlags) { + var swig_r BtCollisionObjectAnisotropicFrictionFlags + swig_r = (BtCollisionObjectAnisotropicFrictionFlags)(C._wrap_CF_ANISOTROPIC_ROLLING_FRICTION_btCollisionObject_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionObjectCF_ANISOTROPIC_ROLLING_FRICTION BtCollisionObjectAnisotropicFrictionFlags = _swig_getbtCollisionObject_CF_ANISOTROPIC_ROLLING_FRICTION_btCollisionObject() + +func (arg1 SwigcptrBtCollisionObject) MergesSimulationIslands() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionObject_mergesSimulationIslands_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetAnisotropicFriction() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCollisionObject_getAnisotropicFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetAnisotropicFriction__SWIG_0(arg2 BtVector3, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btCollisionObject_setAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtCollisionObject) SetAnisotropicFriction__SWIG_1(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObject_setAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtCollisionObject) SetAnisotropicFriction(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.SetAnisotropicFriction__SWIG_1(a[0].(BtVector3)) + return + } + if argc == 2 { + p.SetAnisotropicFriction__SWIG_0(a[0].(BtVector3), a[1].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionObject) HasAnisotropicFriction__SWIG_0(arg2 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btCollisionObject_hasAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) HasAnisotropicFriction__SWIG_1() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionObject_hasAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (p SwigcptrBtCollisionObject) HasAnisotropicFriction(a ...interface{}) bool { + argc := len(a) + if argc == 0 { + return p.HasAnisotropicFriction__SWIG_1() + } + if argc == 1 { + return p.HasAnisotropicFriction__SWIG_0(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionObject) SetContactProcessingThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setContactProcessingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetContactProcessingThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getContactProcessingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) IsStaticObject() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionObject_isStaticObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) IsKinematicObject() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionObject_isKinematicObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) IsStaticOrKinematicObject() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionObject_isStaticOrKinematicObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) HasContactResponse() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionObject_hasContactResponse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtCollisionObject() (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_new_btCollisionObject_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtCollisionObject(arg1 BtCollisionObject) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionObject) SetCollisionShape(arg2 BtCollisionShape) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObject_setCollisionShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetCollisionShape__SWIG_0() (_swig_ret BtCollisionShape) { + var swig_r BtCollisionShape + _swig_i_0 := arg1 + swig_r = (BtCollisionShape)(SwigcptrBtCollisionShape(C._wrap_btCollisionObject_getCollisionShape__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetCollisionShape__SWIG_1() (_swig_ret BtCollisionShape) { + var swig_r BtCollisionShape + _swig_i_0 := arg1 + swig_r = (BtCollisionShape)(SwigcptrBtCollisionShape(C._wrap_btCollisionObject_getCollisionShape__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCollisionObject) GetCollisionShape(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetCollisionShape__SWIG_0() + } + if argc == 0 { + return p.GetCollisionShape__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionObject) SetIgnoreCollisionCheck(arg2 BtCollisionObject, arg3 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btCollisionObject_setIgnoreCollisionCheck_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C._Bool(_swig_i_2)) +} + +func (arg1 SwigcptrBtCollisionObject) GetNumObjectsWithoutCollision() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getNumObjectsWithoutCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetObjectWithoutCollision(arg2 int) (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_btCollisionObject_getObjectWithoutCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) CheckCollideWithOverride(arg2 BtCollisionObject) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btCollisionObject_checkCollideWithOverride_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) InternalGetExtensionPointer() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btCollisionObject_internalGetExtensionPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) InternalSetExtensionPointer(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_internalSetExtensionPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetActivationState() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getActivationState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetActivationState(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setActivationState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) SetDeactivationTime(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setDeactivationTime_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetDeactivationTime() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getDeactivationTime_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) ForceActivationState(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_forceActivationState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) Activate__SWIG_0(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_activate__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) Activate__SWIG_1() { + _swig_i_0 := arg1 + C._wrap_btCollisionObject_activate__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtCollisionObject) Activate(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.Activate__SWIG_1() + return + } + if argc == 1 { + p.Activate__SWIG_0(a[0].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionObject) IsActive() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionObject_isActive_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetRestitution(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setRestitution_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetRestitution() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getRestitution_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetFriction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetFriction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetRollingFriction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setRollingFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetRollingFriction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getRollingFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetSpinningFriction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setSpinningFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetSpinningFriction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getSpinningFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetContactStiffnessAndDamping(arg2 float32, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btCollisionObject_setContactStiffnessAndDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtCollisionObject) GetContactStiffness() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getContactStiffness_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetContactDamping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getContactDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetInternalType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getInternalType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetWorldTransform__SWIG_0() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btCollisionObject_getWorldTransform__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetWorldTransform__SWIG_1() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btCollisionObject_getWorldTransform__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCollisionObject) GetWorldTransform(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetWorldTransform__SWIG_0() + } + if argc == 0 { + return p.GetWorldTransform__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionObject) SetWorldTransform(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObject_setWorldTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetBroadphaseHandle__SWIG_0() (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + _swig_i_0 := arg1 + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_btCollisionObject_getBroadphaseHandle__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetBroadphaseHandle__SWIG_1() (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + _swig_i_0 := arg1 + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_btCollisionObject_getBroadphaseHandle__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCollisionObject) GetBroadphaseHandle(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetBroadphaseHandle__SWIG_0() + } + if argc == 0 { + return p.GetBroadphaseHandle__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionObject) SetBroadphaseHandle(arg2 BtBroadphaseProxy) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObject_setBroadphaseHandle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetInterpolationWorldTransform__SWIG_0() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btCollisionObject_getInterpolationWorldTransform__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetInterpolationWorldTransform__SWIG_1() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btCollisionObject_getInterpolationWorldTransform__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCollisionObject) GetInterpolationWorldTransform(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetInterpolationWorldTransform__SWIG_0() + } + if argc == 0 { + return p.GetInterpolationWorldTransform__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionObject) SetInterpolationWorldTransform(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObject_setInterpolationWorldTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) SetInterpolationLinearVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObject_setInterpolationLinearVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) SetInterpolationAngularVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObject_setInterpolationAngularVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetInterpolationLinearVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCollisionObject_getInterpolationLinearVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetInterpolationAngularVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btCollisionObject_getInterpolationAngularVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetIslandTag() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getIslandTag_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetIslandTag(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setIslandTag_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetCompanionId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getCompanionId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetCompanionId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setCompanionId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetWorldArrayIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getWorldArrayIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetWorldArrayIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setWorldArrayIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetHitFraction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getHitFraction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetHitFraction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setHitFraction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetCollisionFlags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getCollisionFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetCollisionFlags(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setCollisionFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetCcdSweptSphereRadius() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getCcdSweptSphereRadius_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetCcdSweptSphereRadius(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setCcdSweptSphereRadius_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetCcdMotionThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getCcdMotionThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetCcdSquareMotionThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObject_getCcdSquareMotionThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetCcdMotionThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setCcdMotionThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btCollisionObject_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetUserIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetUserIndex2() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) GetUserIndex3() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getUserIndex3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetUserPointer(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) SetUserIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) SetUserIndex2(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) SetUserIndex3(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObject_setUserIndex3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) GetUpdateRevisionInternal() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_getUpdateRevisionInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) SetCustomDebugColor(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObject_setCustomDebugColor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObject) RemoveCustomDebugColor() { + _swig_i_0 := arg1 + C._wrap_btCollisionObject_removeCustomDebugColor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionObject) GetCustomDebugColor(arg2 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btCollisionObject_getCustomDebugColor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) CheckCollideWith(arg2 BtCollisionObject) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btCollisionObject_checkCollideWith_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObject_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObject) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btCollisionObject_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtCollisionObject) SerializeSingleObject(arg2 BtSerializer) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObject_serializeSingleObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +type BtCollisionObject interface { + Swigcptr() uintptr + SwigIsBtCollisionObject() + MergesSimulationIslands() (_swig_ret bool) + GetAnisotropicFriction() (_swig_ret BtVector3) + SetAnisotropicFriction(a ...interface{}) + HasAnisotropicFriction(a ...interface{}) bool + SetContactProcessingThreshold(arg2 float32) + GetContactProcessingThreshold() (_swig_ret float32) + IsStaticObject() (_swig_ret bool) + IsKinematicObject() (_swig_ret bool) + IsStaticOrKinematicObject() (_swig_ret bool) + HasContactResponse() (_swig_ret bool) + SetCollisionShape(arg2 BtCollisionShape) + GetCollisionShape(a ...interface{}) interface{} + SetIgnoreCollisionCheck(arg2 BtCollisionObject, arg3 bool) + GetNumObjectsWithoutCollision() (_swig_ret int) + GetObjectWithoutCollision(arg2 int) (_swig_ret BtCollisionObject) + CheckCollideWithOverride(arg2 BtCollisionObject) (_swig_ret bool) + InternalGetExtensionPointer() (_swig_ret uintptr) + InternalSetExtensionPointer(arg2 uintptr) + GetActivationState() (_swig_ret int) + SetActivationState(arg2 int) + SetDeactivationTime(arg2 float32) + GetDeactivationTime() (_swig_ret float32) + ForceActivationState(arg2 int) + Activate(a ...interface{}) + IsActive() (_swig_ret bool) + SetRestitution(arg2 float32) + GetRestitution() (_swig_ret float32) + SetFriction(arg2 float32) + GetFriction() (_swig_ret float32) + SetRollingFriction(arg2 float32) + GetRollingFriction() (_swig_ret float32) + SetSpinningFriction(arg2 float32) + GetSpinningFriction() (_swig_ret float32) + SetContactStiffnessAndDamping(arg2 float32, arg3 float32) + GetContactStiffness() (_swig_ret float32) + GetContactDamping() (_swig_ret float32) + GetInternalType() (_swig_ret int) + GetWorldTransform(a ...interface{}) interface{} + SetWorldTransform(arg2 BtTransform) + GetBroadphaseHandle(a ...interface{}) interface{} + SetBroadphaseHandle(arg2 BtBroadphaseProxy) + GetInterpolationWorldTransform(a ...interface{}) interface{} + SetInterpolationWorldTransform(arg2 BtTransform) + SetInterpolationLinearVelocity(arg2 BtVector3) + SetInterpolationAngularVelocity(arg2 BtVector3) + GetInterpolationLinearVelocity() (_swig_ret BtVector3) + GetInterpolationAngularVelocity() (_swig_ret BtVector3) + GetIslandTag() (_swig_ret int) + SetIslandTag(arg2 int) + GetCompanionId() (_swig_ret int) + SetCompanionId(arg2 int) + GetWorldArrayIndex() (_swig_ret int) + SetWorldArrayIndex(arg2 int) + GetHitFraction() (_swig_ret float32) + SetHitFraction(arg2 float32) + GetCollisionFlags() (_swig_ret int) + SetCollisionFlags(arg2 int) + GetCcdSweptSphereRadius() (_swig_ret float32) + SetCcdSweptSphereRadius(arg2 float32) + GetCcdMotionThreshold() (_swig_ret float32) + GetCcdSquareMotionThreshold() (_swig_ret float32) + SetCcdMotionThreshold(arg2 float32) + GetUserPointer() (_swig_ret uintptr) + GetUserIndex() (_swig_ret int) + GetUserIndex2() (_swig_ret int) + GetUserIndex3() (_swig_ret int) + SetUserPointer(arg2 uintptr) + SetUserIndex(arg2 int) + SetUserIndex2(arg2 int) + SetUserIndex3(arg2 int) + GetUpdateRevisionInternal() (_swig_ret int) + SetCustomDebugColor(arg2 BtVector3) + RemoveCustomDebugColor() + GetCustomDebugColor(arg2 BtVector3) (_swig_ret bool) + CheckCollideWith(arg2 BtCollisionObject) (_swig_ret bool) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + SerializeSingleObject(arg2 BtSerializer) +} + +type SwigcptrBtCollisionObjectDoubleData uintptr + +func (p SwigcptrBtCollisionObjectDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionObjectDoubleData) SwigIsBtCollisionObjectDoubleData() { +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_broadphaseHandle(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_broadphaseHandle_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_broadphaseHandle() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btCollisionObjectDoubleData_m_broadphaseHandle_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_collisionShape(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_collisionShape_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_collisionShape() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btCollisionObjectDoubleData_m_collisionShape_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_rootCollisionShape(arg2 BtCollisionShapeData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectDoubleData_m_rootCollisionShape_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_rootCollisionShape() (_swig_ret BtCollisionShapeData) { + var swig_r BtCollisionShapeData + _swig_i_0 := arg1 + swig_r = (BtCollisionShapeData)(SwigcptrBtCollisionShapeData(C._wrap_btCollisionObjectDoubleData_m_rootCollisionShape_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_name(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_name_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_55)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_name() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btCollisionObjectDoubleData_m_name_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_worldTransform(arg2 BtTransformDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectDoubleData_m_worldTransform_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_worldTransform() (_swig_ret BtTransformDoubleData) { + var swig_r BtTransformDoubleData + _swig_i_0 := arg1 + swig_r = (BtTransformDoubleData)(SwigcptrBtTransformDoubleData(C._wrap_btCollisionObjectDoubleData_m_worldTransform_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_interpolationWorldTransform(arg2 BtTransformDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectDoubleData_m_interpolationWorldTransform_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_interpolationWorldTransform() (_swig_ret BtTransformDoubleData) { + var swig_r BtTransformDoubleData + _swig_i_0 := arg1 + swig_r = (BtTransformDoubleData)(SwigcptrBtTransformDoubleData(C._wrap_btCollisionObjectDoubleData_m_interpolationWorldTransform_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_interpolationLinearVelocity(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectDoubleData_m_interpolationLinearVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_interpolationLinearVelocity() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btCollisionObjectDoubleData_m_interpolationLinearVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_interpolationAngularVelocity(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectDoubleData_m_interpolationAngularVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_interpolationAngularVelocity() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btCollisionObjectDoubleData_m_interpolationAngularVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_anisotropicFriction(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectDoubleData_m_anisotropicFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_anisotropicFriction() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btCollisionObjectDoubleData_m_anisotropicFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_contactProcessingThreshold(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_contactProcessingThreshold() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btCollisionObjectDoubleData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_deactivationTime(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_deactivationTime_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_deactivationTime() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btCollisionObjectDoubleData_m_deactivationTime_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_friction(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_friction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_friction() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btCollisionObjectDoubleData_m_friction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_rollingFriction(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_rollingFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_rollingFriction() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btCollisionObjectDoubleData_m_rollingFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_contactDamping(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_contactDamping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_contactDamping() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btCollisionObjectDoubleData_m_contactDamping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_contactStiffness(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_contactStiffness_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_contactStiffness() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btCollisionObjectDoubleData_m_contactStiffness_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_restitution(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_restitution_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_restitution() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btCollisionObjectDoubleData_m_restitution_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_hitFraction(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_hitFraction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_hitFraction() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btCollisionObjectDoubleData_m_hitFraction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_ccdSweptSphereRadius(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_ccdSweptSphereRadius_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_ccdSweptSphereRadius() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btCollisionObjectDoubleData_m_ccdSweptSphereRadius_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_ccdMotionThreshold(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_ccdMotionThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_ccdMotionThreshold() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btCollisionObjectDoubleData_m_ccdMotionThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_hasAnisotropicFriction(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_hasAnisotropicFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_hasAnisotropicFriction() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectDoubleData_m_hasAnisotropicFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_collisionFlags(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_collisionFlags_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_collisionFlags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectDoubleData_m_collisionFlags_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_islandTag1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_islandTag1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_islandTag1() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectDoubleData_m_islandTag1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_companionId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_companionId_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_companionId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectDoubleData_m_companionId_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_activationState1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_activationState1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_activationState1() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectDoubleData_m_activationState1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_internalType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_internalType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_internalType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectDoubleData_m_internalType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_checkCollideWith(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_checkCollideWith_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_checkCollideWith() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectDoubleData_m_checkCollideWith_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_collisionFilterGroup(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_collisionFilterGroup_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_collisionFilterGroup() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectDoubleData_m_collisionFilterGroup_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_collisionFilterMask(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_collisionFilterMask_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_collisionFilterMask() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectDoubleData_m_collisionFilterMask_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) SetM_uniqueId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectDoubleData_m_uniqueId_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectDoubleData) GetM_uniqueId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectDoubleData_m_uniqueId_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtCollisionObjectDoubleData() (_swig_ret BtCollisionObjectDoubleData) { + var swig_r BtCollisionObjectDoubleData + swig_r = (BtCollisionObjectDoubleData)(SwigcptrBtCollisionObjectDoubleData(C._wrap_new_btCollisionObjectDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtCollisionObjectDoubleData(arg1 BtCollisionObjectDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionObjectDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtCollisionObjectDoubleData interface { + Swigcptr() uintptr + SwigIsBtCollisionObjectDoubleData() + SetM_broadphaseHandle(arg2 uintptr) + GetM_broadphaseHandle() (_swig_ret uintptr) + SetM_collisionShape(arg2 uintptr) + GetM_collisionShape() (_swig_ret uintptr) + SetM_rootCollisionShape(arg2 BtCollisionShapeData) + GetM_rootCollisionShape() (_swig_ret BtCollisionShapeData) + SetM_name(arg2 string) + GetM_name() (_swig_ret string) + SetM_worldTransform(arg2 BtTransformDoubleData) + GetM_worldTransform() (_swig_ret BtTransformDoubleData) + SetM_interpolationWorldTransform(arg2 BtTransformDoubleData) + GetM_interpolationWorldTransform() (_swig_ret BtTransformDoubleData) + SetM_interpolationLinearVelocity(arg2 BtVector3DoubleData) + GetM_interpolationLinearVelocity() (_swig_ret BtVector3DoubleData) + SetM_interpolationAngularVelocity(arg2 BtVector3DoubleData) + GetM_interpolationAngularVelocity() (_swig_ret BtVector3DoubleData) + SetM_anisotropicFriction(arg2 BtVector3DoubleData) + GetM_anisotropicFriction() (_swig_ret BtVector3DoubleData) + SetM_contactProcessingThreshold(arg2 float64) + GetM_contactProcessingThreshold() (_swig_ret float64) + SetM_deactivationTime(arg2 float64) + GetM_deactivationTime() (_swig_ret float64) + SetM_friction(arg2 float64) + GetM_friction() (_swig_ret float64) + SetM_rollingFriction(arg2 float64) + GetM_rollingFriction() (_swig_ret float64) + SetM_contactDamping(arg2 float64) + GetM_contactDamping() (_swig_ret float64) + SetM_contactStiffness(arg2 float64) + GetM_contactStiffness() (_swig_ret float64) + SetM_restitution(arg2 float64) + GetM_restitution() (_swig_ret float64) + SetM_hitFraction(arg2 float64) + GetM_hitFraction() (_swig_ret float64) + SetM_ccdSweptSphereRadius(arg2 float64) + GetM_ccdSweptSphereRadius() (_swig_ret float64) + SetM_ccdMotionThreshold(arg2 float64) + GetM_ccdMotionThreshold() (_swig_ret float64) + SetM_hasAnisotropicFriction(arg2 int) + GetM_hasAnisotropicFriction() (_swig_ret int) + SetM_collisionFlags(arg2 int) + GetM_collisionFlags() (_swig_ret int) + SetM_islandTag1(arg2 int) + GetM_islandTag1() (_swig_ret int) + SetM_companionId(arg2 int) + GetM_companionId() (_swig_ret int) + SetM_activationState1(arg2 int) + GetM_activationState1() (_swig_ret int) + SetM_internalType(arg2 int) + GetM_internalType() (_swig_ret int) + SetM_checkCollideWith(arg2 int) + GetM_checkCollideWith() (_swig_ret int) + SetM_collisionFilterGroup(arg2 int) + GetM_collisionFilterGroup() (_swig_ret int) + SetM_collisionFilterMask(arg2 int) + GetM_collisionFilterMask() (_swig_ret int) + SetM_uniqueId(arg2 int) + GetM_uniqueId() (_swig_ret int) +} + +type SwigcptrBtCollisionObjectFloatData uintptr + +func (p SwigcptrBtCollisionObjectFloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionObjectFloatData) SwigIsBtCollisionObjectFloatData() { +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_broadphaseHandle(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_broadphaseHandle_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_broadphaseHandle() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btCollisionObjectFloatData_m_broadphaseHandle_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_collisionShape(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_collisionShape_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_collisionShape() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btCollisionObjectFloatData_m_collisionShape_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_rootCollisionShape(arg2 BtCollisionShapeData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectFloatData_m_rootCollisionShape_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_rootCollisionShape() (_swig_ret BtCollisionShapeData) { + var swig_r BtCollisionShapeData + _swig_i_0 := arg1 + swig_r = (BtCollisionShapeData)(SwigcptrBtCollisionShapeData(C._wrap_btCollisionObjectFloatData_m_rootCollisionShape_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_name(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_name_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_57)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_name() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btCollisionObjectFloatData_m_name_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_worldTransform(arg2 BtTransformFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectFloatData_m_worldTransform_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_worldTransform() (_swig_ret BtTransformFloatData) { + var swig_r BtTransformFloatData + _swig_i_0 := arg1 + swig_r = (BtTransformFloatData)(SwigcptrBtTransformFloatData(C._wrap_btCollisionObjectFloatData_m_worldTransform_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_interpolationWorldTransform(arg2 BtTransformFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectFloatData_m_interpolationWorldTransform_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_interpolationWorldTransform() (_swig_ret BtTransformFloatData) { + var swig_r BtTransformFloatData + _swig_i_0 := arg1 + swig_r = (BtTransformFloatData)(SwigcptrBtTransformFloatData(C._wrap_btCollisionObjectFloatData_m_interpolationWorldTransform_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_interpolationLinearVelocity(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectFloatData_m_interpolationLinearVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_interpolationLinearVelocity() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btCollisionObjectFloatData_m_interpolationLinearVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_interpolationAngularVelocity(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectFloatData_m_interpolationAngularVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_interpolationAngularVelocity() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btCollisionObjectFloatData_m_interpolationAngularVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_anisotropicFriction(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionObjectFloatData_m_anisotropicFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_anisotropicFriction() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btCollisionObjectFloatData_m_anisotropicFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_contactProcessingThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_contactProcessingThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObjectFloatData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_deactivationTime(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_deactivationTime_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_deactivationTime() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObjectFloatData_m_deactivationTime_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_friction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_friction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_friction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObjectFloatData_m_friction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_rollingFriction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_rollingFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_rollingFriction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObjectFloatData_m_rollingFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_contactDamping(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_contactDamping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_contactDamping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObjectFloatData_m_contactDamping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_contactStiffness(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_contactStiffness_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_contactStiffness() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObjectFloatData_m_contactStiffness_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_restitution(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_restitution_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_restitution() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObjectFloatData_m_restitution_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_hitFraction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_hitFraction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_hitFraction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObjectFloatData_m_hitFraction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_ccdSweptSphereRadius(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_ccdSweptSphereRadius_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_ccdSweptSphereRadius() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObjectFloatData_m_ccdSweptSphereRadius_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_ccdMotionThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_ccdMotionThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_ccdMotionThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btCollisionObjectFloatData_m_ccdMotionThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_hasAnisotropicFriction(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_hasAnisotropicFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_hasAnisotropicFriction() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectFloatData_m_hasAnisotropicFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_collisionFlags(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_collisionFlags_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_collisionFlags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectFloatData_m_collisionFlags_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_islandTag1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_islandTag1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_islandTag1() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectFloatData_m_islandTag1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_companionId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_companionId_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_companionId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectFloatData_m_companionId_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_activationState1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_activationState1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_activationState1() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectFloatData_m_activationState1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_internalType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_internalType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_internalType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectFloatData_m_internalType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_checkCollideWith(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_checkCollideWith_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_checkCollideWith() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectFloatData_m_checkCollideWith_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_collisionFilterGroup(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_collisionFilterGroup_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_collisionFilterGroup() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectFloatData_m_collisionFilterGroup_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_collisionFilterMask(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_collisionFilterMask_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_collisionFilterMask() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectFloatData_m_collisionFilterMask_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) SetM_uniqueId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionObjectFloatData_m_uniqueId_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionObjectFloatData) GetM_uniqueId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionObjectFloatData_m_uniqueId_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtCollisionObjectFloatData() (_swig_ret BtCollisionObjectFloatData) { + var swig_r BtCollisionObjectFloatData + swig_r = (BtCollisionObjectFloatData)(SwigcptrBtCollisionObjectFloatData(C._wrap_new_btCollisionObjectFloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtCollisionObjectFloatData(arg1 BtCollisionObjectFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionObjectFloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtCollisionObjectFloatData interface { + Swigcptr() uintptr + SwigIsBtCollisionObjectFloatData() + SetM_broadphaseHandle(arg2 uintptr) + GetM_broadphaseHandle() (_swig_ret uintptr) + SetM_collisionShape(arg2 uintptr) + GetM_collisionShape() (_swig_ret uintptr) + SetM_rootCollisionShape(arg2 BtCollisionShapeData) + GetM_rootCollisionShape() (_swig_ret BtCollisionShapeData) + SetM_name(arg2 string) + GetM_name() (_swig_ret string) + SetM_worldTransform(arg2 BtTransformFloatData) + GetM_worldTransform() (_swig_ret BtTransformFloatData) + SetM_interpolationWorldTransform(arg2 BtTransformFloatData) + GetM_interpolationWorldTransform() (_swig_ret BtTransformFloatData) + SetM_interpolationLinearVelocity(arg2 BtVector3FloatData) + GetM_interpolationLinearVelocity() (_swig_ret BtVector3FloatData) + SetM_interpolationAngularVelocity(arg2 BtVector3FloatData) + GetM_interpolationAngularVelocity() (_swig_ret BtVector3FloatData) + SetM_anisotropicFriction(arg2 BtVector3FloatData) + GetM_anisotropicFriction() (_swig_ret BtVector3FloatData) + SetM_contactProcessingThreshold(arg2 float32) + GetM_contactProcessingThreshold() (_swig_ret float32) + SetM_deactivationTime(arg2 float32) + GetM_deactivationTime() (_swig_ret float32) + SetM_friction(arg2 float32) + GetM_friction() (_swig_ret float32) + SetM_rollingFriction(arg2 float32) + GetM_rollingFriction() (_swig_ret float32) + SetM_contactDamping(arg2 float32) + GetM_contactDamping() (_swig_ret float32) + SetM_contactStiffness(arg2 float32) + GetM_contactStiffness() (_swig_ret float32) + SetM_restitution(arg2 float32) + GetM_restitution() (_swig_ret float32) + SetM_hitFraction(arg2 float32) + GetM_hitFraction() (_swig_ret float32) + SetM_ccdSweptSphereRadius(arg2 float32) + GetM_ccdSweptSphereRadius() (_swig_ret float32) + SetM_ccdMotionThreshold(arg2 float32) + GetM_ccdMotionThreshold() (_swig_ret float32) + SetM_hasAnisotropicFriction(arg2 int) + GetM_hasAnisotropicFriction() (_swig_ret int) + SetM_collisionFlags(arg2 int) + GetM_collisionFlags() (_swig_ret int) + SetM_islandTag1(arg2 int) + GetM_islandTag1() (_swig_ret int) + SetM_companionId(arg2 int) + GetM_companionId() (_swig_ret int) + SetM_activationState1(arg2 int) + GetM_activationState1() (_swig_ret int) + SetM_internalType(arg2 int) + GetM_internalType() (_swig_ret int) + SetM_checkCollideWith(arg2 int) + GetM_checkCollideWith() (_swig_ret int) + SetM_collisionFilterGroup(arg2 int) + GetM_collisionFilterGroup() (_swig_ret int) + SetM_collisionFilterMask(arg2 int) + GetM_collisionFilterMask() (_swig_ret int) + SetM_uniqueId(arg2 int) + GetM_uniqueId() (_swig_ret int) +} + +func SetGDeactivationTime(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_gDeactivationTime_set_mbt_e879218550ba2e2b(C.float(_swig_i_0)) +} + +func GetGDeactivationTime() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_gDeactivationTime_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetGDisableDeactivation(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_gDisableDeactivation_set_mbt_e879218550ba2e2b(C._Bool(_swig_i_0)) +} + +func GetGDisableDeactivation() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_gDisableDeactivation_get_mbt_e879218550ba2e2b()) + return swig_r +} + +const BtRigidBodyDataName string = "btRigidBodyFloatData" + +type BtRigidBodyFlags int + +func _swig_getBT_DISABLE_WORLD_GRAVITY() (_swig_ret BtRigidBodyFlags) { + var swig_r BtRigidBodyFlags + swig_r = (BtRigidBodyFlags)(C._wrap_BT_DISABLE_WORLD_GRAVITY_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_DISABLE_WORLD_GRAVITY BtRigidBodyFlags = _swig_getBT_DISABLE_WORLD_GRAVITY() + +func _swig_getBT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT() (_swig_ret BtRigidBodyFlags) { + var swig_r BtRigidBodyFlags + swig_r = (BtRigidBodyFlags)(C._wrap_BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT BtRigidBodyFlags = _swig_getBT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT() + +func _swig_getBT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD() (_swig_ret BtRigidBodyFlags) { + var swig_r BtRigidBodyFlags + swig_r = (BtRigidBodyFlags)(C._wrap_BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD BtRigidBodyFlags = _swig_getBT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD() + +func _swig_getBT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY() (_swig_ret BtRigidBodyFlags) { + var swig_r BtRigidBodyFlags + swig_r = (BtRigidBodyFlags)(C._wrap_BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY BtRigidBodyFlags = _swig_getBT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY() + +func _swig_getBT_ENABLE_GYROPSCOPIC_FORCE() (_swig_ret BtRigidBodyFlags) { + var swig_r BtRigidBodyFlags + swig_r = (BtRigidBodyFlags)(C._wrap_BT_ENABLE_GYROPSCOPIC_FORCE_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_ENABLE_GYROPSCOPIC_FORCE BtRigidBodyFlags = _swig_getBT_ENABLE_GYROPSCOPIC_FORCE() + +type SwigcptrBtRigidBody uintptr + +func (p SwigcptrBtRigidBody) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtRigidBody) SwigIsBtRigidBody() { +} + +func NewBtRigidBody__SWIG_0(arg1 BtRigidBody_btRigidBodyConstructionInfo) (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_new_btRigidBody__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtRigidBody__SWIG_1(arg1 float32, arg2 BtMotionState, arg3 BtCollisionShape, arg4 BtVector3) (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_new_btRigidBody__SWIG_1_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func NewBtRigidBody__SWIG_2(arg1 float32, arg2 BtMotionState, arg3 BtCollisionShape) (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_new_btRigidBody__SWIG_2_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func NewBtRigidBody(a ...interface{}) BtRigidBody { + argc := len(a) + if argc == 1 { + return NewBtRigidBody__SWIG_0(a[0].(BtRigidBody_btRigidBodyConstructionInfo)) + } + if argc == 3 { + return NewBtRigidBody__SWIG_2(a[0].(float32), a[1].(BtMotionState), a[2].(BtCollisionShape)) + } + if argc == 4 { + return NewBtRigidBody__SWIG_1(a[0].(float32), a[1].(BtMotionState), a[2].(BtCollisionShape), a[3].(BtVector3)) + } + panic("No match for overloaded function call") +} + +func DeleteBtRigidBody(arg1 BtRigidBody) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btRigidBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtRigidBody) ProceedToTransform(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_proceedToTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func BtRigidBodyUpcast__SWIG_0(arg1 BtCollisionObject) (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btRigidBody_upcast__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func BtRigidBodyUpcast__SWIG_1(arg1 BtCollisionObject) (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btRigidBody_upcast__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func BtRigidBodyUpcast(a ...interface{}) interface{} { + argc := len(a) + if argc == 1 { + return BtRigidBodyUpcast__SWIG_0(a[0].(BtCollisionObject)) + } + if argc == 1 { + return BtRigidBodyUpcast__SWIG_1(a[0].(BtCollisionObject)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtRigidBody) PredictIntegratedTransform(arg2 float32, arg3 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btRigidBody_predictIntegratedTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtRigidBody) SaveKinematicState(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBody_saveKinematicState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) ApplyGravity() { + _swig_i_0 := arg1 + C._wrap_btRigidBody_applyGravity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtRigidBody) ClearGravity() { + _swig_i_0 := arg1 + C._wrap_btRigidBody_clearGravity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtRigidBody) SetGravity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setGravity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetGravity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getGravity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) SetDamping(arg2 float32, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btRigidBody_setDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtRigidBody) GetLinearDamping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBody_getLinearDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetAngularDamping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBody_getAngularDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetLinearSleepingThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBody_getLinearSleepingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetAngularSleepingThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBody_getAngularSleepingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) ApplyDamping(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBody_applyDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetCollisionShape__SWIG_0() (_swig_ret BtCollisionShape) { + var swig_r BtCollisionShape + _swig_i_0 := arg1 + swig_r = (BtCollisionShape)(SwigcptrBtCollisionShape(C._wrap_btRigidBody_getCollisionShape__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetCollisionShape__SWIG_1() (_swig_ret BtCollisionShape) { + var swig_r BtCollisionShape + _swig_i_0 := arg1 + swig_r = (BtCollisionShape)(SwigcptrBtCollisionShape(C._wrap_btRigidBody_getCollisionShape__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtRigidBody) GetCollisionShape(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetCollisionShape__SWIG_0() + } + if argc == 0 { + return p.GetCollisionShape__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtRigidBody) SetMassProps(arg2 float32, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btRigidBody_setMassProps_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtRigidBody) GetLinearFactor() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getLinearFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) SetLinearFactor(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setLinearFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetInvMass() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBody_getInvMass_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetMass() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBody_getMass_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetInvInertiaTensorWorld() (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_btRigidBody_getInvInertiaTensorWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) IntegrateVelocities(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBody_integrateVelocities_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) SetCenterOfMassTransform(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setCenterOfMassTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) ApplyCentralForce(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_applyCentralForce_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetTotalForce() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getTotalForce_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetTotalTorque() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getTotalTorque_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetInvInertiaDiagLocal() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getInvInertiaDiagLocal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) SetInvInertiaDiagLocal(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setInvInertiaDiagLocal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) SetSleepingThresholds(arg2 float32, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btRigidBody_setSleepingThresholds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtRigidBody) ApplyTorque(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_applyTorque_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) ApplyForce(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btRigidBody_applyForce_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtRigidBody) ApplyCentralImpulse(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_applyCentralImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) ApplyTorqueImpulse(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_applyTorqueImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) ApplyImpulse(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btRigidBody_applyImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtRigidBody) ApplyPushImpulse(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btRigidBody_applyPushImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtRigidBody) GetPushVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getPushVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetTurnVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getTurnVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) SetPushVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setPushVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) SetTurnVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setTurnVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) ApplyCentralPushImpulse(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_applyCentralPushImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) ApplyTorqueTurnImpulse(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_applyTorqueTurnImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) ClearForces() { + _swig_i_0 := arg1 + C._wrap_btRigidBody_clearForces_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtRigidBody) UpdateInertiaTensor() { + _swig_i_0 := arg1 + C._wrap_btRigidBody_updateInertiaTensor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtRigidBody) GetCenterOfMassPosition() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getCenterOfMassPosition_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetOrientation() (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btRigidBody_getOrientation_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetCenterOfMassTransform() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btRigidBody_getCenterOfMassTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetLinearVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getLinearVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetAngularVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getAngularVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) SetLinearVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setLinearVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) SetAngularVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setAngularVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetVelocityInLocalPoint(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getVelocityInLocalPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetPushVelocityInLocalPoint(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getPushVelocityInLocalPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) Translate(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_translate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetAabb(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btRigidBody_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtRigidBody) ComputeImpulseDenominator(arg2 BtVector3, arg3 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (float32)(C._wrap_btRigidBody_computeImpulseDenominator_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) ComputeAngularImpulseDenominator(arg2 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btRigidBody_computeAngularImpulseDenominator_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) UpdateDeactivation(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBody_updateDeactivation_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) WantsSleeping() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btRigidBody_wantsSleeping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetConstBroadphaseProxy() (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + _swig_i_0 := arg1 + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_btRigidBody_getConstBroadphaseProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetBroadphaseProxy() (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + _swig_i_0 := arg1 + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_btRigidBody_getBroadphaseProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) SetNewBroadphaseProxy(arg2 BtBroadphaseProxy) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setNewBroadphaseProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetMotionState__SWIG_0() (_swig_ret BtMotionState) { + var swig_r BtMotionState + _swig_i_0 := arg1 + swig_r = (BtMotionState)(SwigcptrBtMotionState(C._wrap_btRigidBody_getMotionState__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetMotionState__SWIG_1() (_swig_ret BtMotionState) { + var swig_r BtMotionState + _swig_i_0 := arg1 + swig_r = (BtMotionState)(SwigcptrBtMotionState(C._wrap_btRigidBody_getMotionState__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtRigidBody) GetMotionState(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetMotionState__SWIG_0() + } + if argc == 0 { + return p.GetMotionState__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtRigidBody) SetMotionState(arg2 BtMotionState) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setMotionState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) SetM_contactSolverType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBody_m_contactSolverType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetM_contactSolverType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btRigidBody_m_contactSolverType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) SetM_frictionSolverType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBody_m_frictionSolverType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetM_frictionSolverType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btRigidBody_m_frictionSolverType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) SetAngularFactor__SWIG_0(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_setAngularFactor__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) SetAngularFactor__SWIG_1(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBody_setAngularFactor__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (p SwigcptrBtRigidBody) SetAngularFactor(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + p.SetAngularFactor__SWIG_0(a[0].(BtVector3)) + return + } +check_1: + if argc == 1 { + p.SetAngularFactor__SWIG_1(a[0].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtRigidBody) GetAngularFactor() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getAngularFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) IsInWorld() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btRigidBody_isInWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) AddConstraintRef(arg2 BtTypedConstraint) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_addConstraintRef_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) RemoveConstraintRef(arg2 BtTypedConstraint) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_removeConstraintRef_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetConstraintRef(arg2 int) (_swig_ret BtTypedConstraint) { + var swig_r BtTypedConstraint + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtTypedConstraint)(SwigcptrBtTypedConstraint(C._wrap_btRigidBody_getConstraintRef_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetNumConstraintRefs() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btRigidBody_getNumConstraintRefs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) SetFlags(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBody_setFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBody) GetFlags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btRigidBody_getFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) ComputeGyroscopicImpulseImplicit_World(arg2 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_computeGyroscopicImpulseImplicit_World_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) ComputeGyroscopicImpulseImplicit_Body(arg2 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_computeGyroscopicImpulseImplicit_Body_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) ComputeGyroscopicForceExplicit(arg2 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_computeGyroscopicForceExplicit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) GetLocalInertia() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btRigidBody_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBody) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btRigidBody_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtRigidBody) SerializeSingleObject(arg2 BtSerializer) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBody_serializeSingleObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtRigidBody) MergesSimulationIslands() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btRigidBody_mergesSimulationIslands_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetAnisotropicFriction() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getAnisotropicFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetAnisotropicFriction__SWIG_0(arg1 BtVector3, arg2 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btRigidBody_setAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (_swig_base SwigcptrBtRigidBody) SetAnisotropicFriction__SWIG_1(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btRigidBody_setAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtRigidBody) SetAnisotropicFriction(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.SetAnisotropicFriction__SWIG_1(a[0].(BtVector3)) + return + } + if argc == 2 { + p.SetAnisotropicFriction__SWIG_0(a[0].(BtVector3), a[1].(int)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtRigidBody) HasAnisotropicFriction__SWIG_0(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btRigidBody_hasAnisotropicFriction__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) HasAnisotropicFriction__SWIG_1() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btRigidBody_hasAnisotropicFriction__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtRigidBody) HasAnisotropicFriction(a ...interface{}) bool { + argc := len(a) + if argc == 0 { + return p.HasAnisotropicFriction__SWIG_1() + } + if argc == 1 { + return p.HasAnisotropicFriction__SWIG_0(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtRigidBody) SetContactProcessingThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setContactProcessingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetContactProcessingThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getContactProcessingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) IsStaticObject() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btRigidBody_isStaticObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) IsKinematicObject() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btRigidBody_isKinematicObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) IsStaticOrKinematicObject() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btRigidBody_isStaticOrKinematicObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) HasContactResponse() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btRigidBody_hasContactResponse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetCollisionShape(arg1 BtCollisionShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btRigidBody_setCollisionShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) SetIgnoreCollisionCheck(arg1 BtCollisionObject, arg2 bool) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btRigidBody_setIgnoreCollisionCheck_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (_swig_base SwigcptrBtRigidBody) GetNumObjectsWithoutCollision() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getNumObjectsWithoutCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetObjectWithoutCollision(arg1 int) (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + _swig_i_0 := arg1 + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_btRigidBody_getObjectWithoutCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) CheckCollideWithOverride(arg1 BtCollisionObject) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + swig_r = (bool)(C._wrap_btRigidBody_checkCollideWithOverride_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) InternalGetExtensionPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btRigidBody_internalGetExtensionPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) InternalSetExtensionPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_internalSetExtensionPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetActivationState() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getActivationState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetActivationState(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setActivationState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) SetDeactivationTime(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setDeactivationTime_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetDeactivationTime() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getDeactivationTime_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) ForceActivationState(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_forceActivationState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) Activate__SWIG_0(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_activate__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) Activate__SWIG_1() { + C._wrap_btRigidBody_activate__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (p SwigcptrBtRigidBody) Activate(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.Activate__SWIG_1() + return + } + if argc == 1 { + p.Activate__SWIG_0(a[0].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtRigidBody) IsActive() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btRigidBody_isActive_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetRestitution(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setRestitution_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetRestitution() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getRestitution_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetFriction(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetFriction() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetRollingFriction(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setRollingFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetRollingFriction() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getRollingFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetSpinningFriction(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setSpinningFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetSpinningFriction() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getSpinningFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetContactStiffnessAndDamping(arg1 float32, arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBody_setContactStiffnessAndDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtRigidBody) GetContactStiffness() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getContactStiffness_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetContactDamping() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getContactDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetInternalType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getInternalType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetWorldTransform__SWIG_0() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btRigidBody_getWorldTransform__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetWorldTransform__SWIG_1() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btRigidBody_getWorldTransform__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtRigidBody) GetWorldTransform(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetWorldTransform__SWIG_0() + } + if argc == 0 { + return p.GetWorldTransform__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtRigidBody) SetWorldTransform(arg1 BtTransform) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btRigidBody_setWorldTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetBroadphaseHandle__SWIG_0() (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_btRigidBody_getBroadphaseHandle__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetBroadphaseHandle__SWIG_1() (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_btRigidBody_getBroadphaseHandle__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtRigidBody) GetBroadphaseHandle(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetBroadphaseHandle__SWIG_0() + } + if argc == 0 { + return p.GetBroadphaseHandle__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtRigidBody) SetBroadphaseHandle(arg1 BtBroadphaseProxy) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btRigidBody_setBroadphaseHandle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetInterpolationWorldTransform__SWIG_0() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btRigidBody_getInterpolationWorldTransform__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetInterpolationWorldTransform__SWIG_1() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btRigidBody_getInterpolationWorldTransform__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtRigidBody) GetInterpolationWorldTransform(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetInterpolationWorldTransform__SWIG_0() + } + if argc == 0 { + return p.GetInterpolationWorldTransform__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtRigidBody) SetInterpolationWorldTransform(arg1 BtTransform) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btRigidBody_setInterpolationWorldTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) SetInterpolationLinearVelocity(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btRigidBody_setInterpolationLinearVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) SetInterpolationAngularVelocity(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btRigidBody_setInterpolationAngularVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetInterpolationLinearVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getInterpolationLinearVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetInterpolationAngularVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btRigidBody_getInterpolationAngularVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetIslandTag() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getIslandTag_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetIslandTag(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setIslandTag_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetCompanionId() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getCompanionId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetCompanionId(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setCompanionId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetWorldArrayIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getWorldArrayIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetWorldArrayIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setWorldArrayIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetHitFraction() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getHitFraction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetHitFraction(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setHitFraction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetCollisionFlags() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getCollisionFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetCollisionFlags(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setCollisionFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetCcdSweptSphereRadius() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getCcdSweptSphereRadius_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetCcdSweptSphereRadius(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setCcdSweptSphereRadius_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetCcdMotionThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getCcdMotionThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetCcdSquareMotionThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btRigidBody_getCcdSquareMotionThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetCcdMotionThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setCcdMotionThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btRigidBody_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) GetUserIndex3() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getUserIndex3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) SetUserIndex3(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btRigidBody_setUserIndex3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) GetUpdateRevisionInternal() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btRigidBody_getUpdateRevisionInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) SetCustomDebugColor(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btRigidBody_setCustomDebugColor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtRigidBody) RemoveCustomDebugColor() { + C._wrap_btRigidBody_removeCustomDebugColor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtRigidBody) GetCustomDebugColor(arg1 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + swig_r = (bool)(C._wrap_btRigidBody_getCustomDebugColor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtRigidBody) CheckCollideWith(arg1 BtCollisionObject) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + swig_r = (bool)(C._wrap_btRigidBody_checkCollideWith_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (p SwigcptrBtRigidBody) SwigIsBtCollisionObject() { +} + +func (p SwigcptrBtRigidBody) SwigGetBtCollisionObject() BtCollisionObject { + return SwigcptrBtCollisionObject(getSwigcptr(p)) +} + +type BtRigidBody interface { + Swigcptr() uintptr + SwigIsBtRigidBody() + ProceedToTransform(arg2 BtTransform) + PredictIntegratedTransform(arg2 float32, arg3 BtTransform) + SaveKinematicState(arg2 float32) + ApplyGravity() + ClearGravity() + SetGravity(arg2 BtVector3) + GetGravity() (_swig_ret BtVector3) + SetDamping(arg2 float32, arg3 float32) + GetLinearDamping() (_swig_ret float32) + GetAngularDamping() (_swig_ret float32) + GetLinearSleepingThreshold() (_swig_ret float32) + GetAngularSleepingThreshold() (_swig_ret float32) + ApplyDamping(arg2 float32) + GetCollisionShape(a ...interface{}) interface{} + SetMassProps(arg2 float32, arg3 BtVector3) + GetLinearFactor() (_swig_ret BtVector3) + SetLinearFactor(arg2 BtVector3) + GetInvMass() (_swig_ret float32) + GetMass() (_swig_ret float32) + GetInvInertiaTensorWorld() (_swig_ret BtMatrix3x3) + IntegrateVelocities(arg2 float32) + SetCenterOfMassTransform(arg2 BtTransform) + ApplyCentralForce(arg2 BtVector3) + GetTotalForce() (_swig_ret BtVector3) + GetTotalTorque() (_swig_ret BtVector3) + GetInvInertiaDiagLocal() (_swig_ret BtVector3) + SetInvInertiaDiagLocal(arg2 BtVector3) + SetSleepingThresholds(arg2 float32, arg3 float32) + ApplyTorque(arg2 BtVector3) + ApplyForce(arg2 BtVector3, arg3 BtVector3) + ApplyCentralImpulse(arg2 BtVector3) + ApplyTorqueImpulse(arg2 BtVector3) + ApplyImpulse(arg2 BtVector3, arg3 BtVector3) + ApplyPushImpulse(arg2 BtVector3, arg3 BtVector3) + GetPushVelocity() (_swig_ret BtVector3) + GetTurnVelocity() (_swig_ret BtVector3) + SetPushVelocity(arg2 BtVector3) + SetTurnVelocity(arg2 BtVector3) + ApplyCentralPushImpulse(arg2 BtVector3) + ApplyTorqueTurnImpulse(arg2 BtVector3) + ClearForces() + UpdateInertiaTensor() + GetCenterOfMassPosition() (_swig_ret BtVector3) + GetOrientation() (_swig_ret BtQuaternion) + GetCenterOfMassTransform() (_swig_ret BtTransform) + GetLinearVelocity() (_swig_ret BtVector3) + GetAngularVelocity() (_swig_ret BtVector3) + SetLinearVelocity(arg2 BtVector3) + SetAngularVelocity(arg2 BtVector3) + GetVelocityInLocalPoint(arg2 BtVector3) (_swig_ret BtVector3) + GetPushVelocityInLocalPoint(arg2 BtVector3) (_swig_ret BtVector3) + Translate(arg2 BtVector3) + GetAabb(arg2 BtVector3, arg3 BtVector3) + ComputeImpulseDenominator(arg2 BtVector3, arg3 BtVector3) (_swig_ret float32) + ComputeAngularImpulseDenominator(arg2 BtVector3) (_swig_ret float32) + UpdateDeactivation(arg2 float32) + WantsSleeping() (_swig_ret bool) + GetConstBroadphaseProxy() (_swig_ret BtBroadphaseProxy) + GetBroadphaseProxy() (_swig_ret BtBroadphaseProxy) + SetNewBroadphaseProxy(arg2 BtBroadphaseProxy) + GetMotionState(a ...interface{}) interface{} + SetMotionState(arg2 BtMotionState) + SetM_contactSolverType(arg2 int) + GetM_contactSolverType() (_swig_ret int) + SetM_frictionSolverType(arg2 int) + GetM_frictionSolverType() (_swig_ret int) + SetAngularFactor(a ...interface{}) + GetAngularFactor() (_swig_ret BtVector3) + IsInWorld() (_swig_ret bool) + AddConstraintRef(arg2 BtTypedConstraint) + RemoveConstraintRef(arg2 BtTypedConstraint) + GetConstraintRef(arg2 int) (_swig_ret BtTypedConstraint) + GetNumConstraintRefs() (_swig_ret int) + SetFlags(arg2 int) + GetFlags() (_swig_ret int) + ComputeGyroscopicImpulseImplicit_World(arg2 float32) (_swig_ret BtVector3) + ComputeGyroscopicImpulseImplicit_Body(arg2 float32) (_swig_ret BtVector3) + ComputeGyroscopicForceExplicit(arg2 float32) (_swig_ret BtVector3) + GetLocalInertia() (_swig_ret BtVector3) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + SerializeSingleObject(arg2 BtSerializer) + MergesSimulationIslands() (_swig_ret bool) + GetAnisotropicFriction() (_swig_ret BtVector3) + SetAnisotropicFriction(a ...interface{}) + HasAnisotropicFriction(a ...interface{}) bool + SetContactProcessingThreshold(arg1 float32) + GetContactProcessingThreshold() (_swig_ret float32) + IsStaticObject() (_swig_ret bool) + IsKinematicObject() (_swig_ret bool) + IsStaticOrKinematicObject() (_swig_ret bool) + HasContactResponse() (_swig_ret bool) + SetCollisionShape(arg1 BtCollisionShape) + SetIgnoreCollisionCheck(arg1 BtCollisionObject, arg2 bool) + GetNumObjectsWithoutCollision() (_swig_ret int) + GetObjectWithoutCollision(arg1 int) (_swig_ret BtCollisionObject) + CheckCollideWithOverride(arg1 BtCollisionObject) (_swig_ret bool) + InternalGetExtensionPointer() (_swig_ret uintptr) + InternalSetExtensionPointer(arg1 uintptr) + GetActivationState() (_swig_ret int) + SetActivationState(arg1 int) + SetDeactivationTime(arg1 float32) + GetDeactivationTime() (_swig_ret float32) + ForceActivationState(arg1 int) + Activate(a ...interface{}) + IsActive() (_swig_ret bool) + SetRestitution(arg1 float32) + GetRestitution() (_swig_ret float32) + SetFriction(arg1 float32) + GetFriction() (_swig_ret float32) + SetRollingFriction(arg1 float32) + GetRollingFriction() (_swig_ret float32) + SetSpinningFriction(arg1 float32) + GetSpinningFriction() (_swig_ret float32) + SetContactStiffnessAndDamping(arg1 float32, arg2 float32) + GetContactStiffness() (_swig_ret float32) + GetContactDamping() (_swig_ret float32) + GetInternalType() (_swig_ret int) + GetWorldTransform(a ...interface{}) interface{} + SetWorldTransform(arg1 BtTransform) + GetBroadphaseHandle(a ...interface{}) interface{} + SetBroadphaseHandle(arg1 BtBroadphaseProxy) + GetInterpolationWorldTransform(a ...interface{}) interface{} + SetInterpolationWorldTransform(arg1 BtTransform) + SetInterpolationLinearVelocity(arg1 BtVector3) + SetInterpolationAngularVelocity(arg1 BtVector3) + GetInterpolationLinearVelocity() (_swig_ret BtVector3) + GetInterpolationAngularVelocity() (_swig_ret BtVector3) + GetIslandTag() (_swig_ret int) + SetIslandTag(arg1 int) + GetCompanionId() (_swig_ret int) + SetCompanionId(arg1 int) + GetWorldArrayIndex() (_swig_ret int) + SetWorldArrayIndex(arg1 int) + GetHitFraction() (_swig_ret float32) + SetHitFraction(arg1 float32) + GetCollisionFlags() (_swig_ret int) + SetCollisionFlags(arg1 int) + GetCcdSweptSphereRadius() (_swig_ret float32) + SetCcdSweptSphereRadius(arg1 float32) + GetCcdMotionThreshold() (_swig_ret float32) + GetCcdSquareMotionThreshold() (_swig_ret float32) + SetCcdMotionThreshold(arg1 float32) + GetUserPointer() (_swig_ret uintptr) + GetUserIndex() (_swig_ret int) + GetUserIndex2() (_swig_ret int) + GetUserIndex3() (_swig_ret int) + SetUserPointer(arg1 uintptr) + SetUserIndex(arg1 int) + SetUserIndex2(arg1 int) + SetUserIndex3(arg1 int) + GetUpdateRevisionInternal() (_swig_ret int) + SetCustomDebugColor(arg1 BtVector3) + RemoveCustomDebugColor() + GetCustomDebugColor(arg1 BtVector3) (_swig_ret bool) + CheckCollideWith(arg1 BtCollisionObject) (_swig_ret bool) + SwigIsBtCollisionObject() + SwigGetBtCollisionObject() BtCollisionObject +} + +type SwigcptrBtRigidBodyFloatData uintptr + +func (p SwigcptrBtRigidBodyFloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtRigidBodyFloatData) SwigIsBtRigidBodyFloatData() { +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_collisionObjectData(arg2 BtCollisionObjectFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_collisionObjectData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_collisionObjectData() (_swig_ret BtCollisionObjectFloatData) { + var swig_r BtCollisionObjectFloatData + _swig_i_0 := arg1 + swig_r = (BtCollisionObjectFloatData)(SwigcptrBtCollisionObjectFloatData(C._wrap_btRigidBodyFloatData_m_collisionObjectData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_invInertiaTensorWorld(arg2 BtMatrix3x3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_invInertiaTensorWorld_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_invInertiaTensorWorld() (_swig_ret BtMatrix3x3FloatData) { + var swig_r BtMatrix3x3FloatData + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3FloatData)(SwigcptrBtMatrix3x3FloatData(C._wrap_btRigidBodyFloatData_m_invInertiaTensorWorld_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_linearVelocity(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_linearVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_linearVelocity() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btRigidBodyFloatData_m_linearVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_angularVelocity(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_angularVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_angularVelocity() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btRigidBodyFloatData_m_angularVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_angularFactor(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_angularFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_angularFactor() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btRigidBodyFloatData_m_angularFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_linearFactor(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_linearFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_linearFactor() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btRigidBodyFloatData_m_linearFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_gravity(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_gravity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_gravity() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btRigidBodyFloatData_m_gravity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_gravity_acceleration(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_gravity_acceleration_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_gravity_acceleration() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btRigidBodyFloatData_m_gravity_acceleration_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_invInertiaLocal(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_invInertiaLocal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_invInertiaLocal() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btRigidBodyFloatData_m_invInertiaLocal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_totalForce(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_totalForce_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_totalForce() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btRigidBodyFloatData_m_totalForce_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_totalTorque(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyFloatData_m_totalTorque_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_totalTorque() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btRigidBodyFloatData_m_totalTorque_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_inverseMass(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyFloatData_m_inverseMass_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_inverseMass() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBodyFloatData_m_inverseMass_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_linearDamping(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyFloatData_m_linearDamping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_linearDamping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBodyFloatData_m_linearDamping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_angularDamping(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyFloatData_m_angularDamping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_angularDamping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBodyFloatData_m_angularDamping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_additionalDampingFactor(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyFloatData_m_additionalDampingFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_additionalDampingFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBodyFloatData_m_additionalDampingFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_additionalLinearDampingThresholdSqr(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_additionalLinearDampingThresholdSqr() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBodyFloatData_m_additionalLinearDampingThresholdSqr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_additionalAngularDampingThresholdSqr(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_additionalAngularDampingThresholdSqr() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBodyFloatData_m_additionalAngularDampingThresholdSqr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_additionalAngularDampingFactor(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyFloatData_m_additionalAngularDampingFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_additionalAngularDampingFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBodyFloatData_m_additionalAngularDampingFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_linearSleepingThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyFloatData_m_linearSleepingThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_linearSleepingThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBodyFloatData_m_linearSleepingThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_angularSleepingThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyFloatData_m_angularSleepingThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_angularSleepingThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRigidBodyFloatData_m_angularSleepingThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyFloatData) SetM_additionalDamping(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyFloatData_m_additionalDamping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyFloatData) GetM_additionalDamping() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btRigidBodyFloatData_m_additionalDamping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtRigidBodyFloatData() (_swig_ret BtRigidBodyFloatData) { + var swig_r BtRigidBodyFloatData + swig_r = (BtRigidBodyFloatData)(SwigcptrBtRigidBodyFloatData(C._wrap_new_btRigidBodyFloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtRigidBodyFloatData(arg1 BtRigidBodyFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btRigidBodyFloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtRigidBodyFloatData interface { + Swigcptr() uintptr + SwigIsBtRigidBodyFloatData() + SetM_collisionObjectData(arg2 BtCollisionObjectFloatData) + GetM_collisionObjectData() (_swig_ret BtCollisionObjectFloatData) + SetM_invInertiaTensorWorld(arg2 BtMatrix3x3FloatData) + GetM_invInertiaTensorWorld() (_swig_ret BtMatrix3x3FloatData) + SetM_linearVelocity(arg2 BtVector3FloatData) + GetM_linearVelocity() (_swig_ret BtVector3FloatData) + SetM_angularVelocity(arg2 BtVector3FloatData) + GetM_angularVelocity() (_swig_ret BtVector3FloatData) + SetM_angularFactor(arg2 BtVector3FloatData) + GetM_angularFactor() (_swig_ret BtVector3FloatData) + SetM_linearFactor(arg2 BtVector3FloatData) + GetM_linearFactor() (_swig_ret BtVector3FloatData) + SetM_gravity(arg2 BtVector3FloatData) + GetM_gravity() (_swig_ret BtVector3FloatData) + SetM_gravity_acceleration(arg2 BtVector3FloatData) + GetM_gravity_acceleration() (_swig_ret BtVector3FloatData) + SetM_invInertiaLocal(arg2 BtVector3FloatData) + GetM_invInertiaLocal() (_swig_ret BtVector3FloatData) + SetM_totalForce(arg2 BtVector3FloatData) + GetM_totalForce() (_swig_ret BtVector3FloatData) + SetM_totalTorque(arg2 BtVector3FloatData) + GetM_totalTorque() (_swig_ret BtVector3FloatData) + SetM_inverseMass(arg2 float32) + GetM_inverseMass() (_swig_ret float32) + SetM_linearDamping(arg2 float32) + GetM_linearDamping() (_swig_ret float32) + SetM_angularDamping(arg2 float32) + GetM_angularDamping() (_swig_ret float32) + SetM_additionalDampingFactor(arg2 float32) + GetM_additionalDampingFactor() (_swig_ret float32) + SetM_additionalLinearDampingThresholdSqr(arg2 float32) + GetM_additionalLinearDampingThresholdSqr() (_swig_ret float32) + SetM_additionalAngularDampingThresholdSqr(arg2 float32) + GetM_additionalAngularDampingThresholdSqr() (_swig_ret float32) + SetM_additionalAngularDampingFactor(arg2 float32) + GetM_additionalAngularDampingFactor() (_swig_ret float32) + SetM_linearSleepingThreshold(arg2 float32) + GetM_linearSleepingThreshold() (_swig_ret float32) + SetM_angularSleepingThreshold(arg2 float32) + GetM_angularSleepingThreshold() (_swig_ret float32) + SetM_additionalDamping(arg2 int) + GetM_additionalDamping() (_swig_ret int) +} + +type SwigcptrBtRigidBodyDoubleData uintptr + +func (p SwigcptrBtRigidBodyDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtRigidBodyDoubleData) SwigIsBtRigidBodyDoubleData() { +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_collisionObjectData(arg2 BtCollisionObjectDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_collisionObjectData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_collisionObjectData() (_swig_ret BtCollisionObjectDoubleData) { + var swig_r BtCollisionObjectDoubleData + _swig_i_0 := arg1 + swig_r = (BtCollisionObjectDoubleData)(SwigcptrBtCollisionObjectDoubleData(C._wrap_btRigidBodyDoubleData_m_collisionObjectData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_invInertiaTensorWorld(arg2 BtMatrix3x3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_invInertiaTensorWorld_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_invInertiaTensorWorld() (_swig_ret BtMatrix3x3DoubleData) { + var swig_r BtMatrix3x3DoubleData + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3DoubleData)(SwigcptrBtMatrix3x3DoubleData(C._wrap_btRigidBodyDoubleData_m_invInertiaTensorWorld_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_linearVelocity(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_linearVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_linearVelocity() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btRigidBodyDoubleData_m_linearVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_angularVelocity(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_angularVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_angularVelocity() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btRigidBodyDoubleData_m_angularVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_angularFactor(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_angularFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_angularFactor() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btRigidBodyDoubleData_m_angularFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_linearFactor(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_linearFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_linearFactor() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btRigidBodyDoubleData_m_linearFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_gravity(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_gravity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_gravity() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btRigidBodyDoubleData_m_gravity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_gravity_acceleration(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_gravity_acceleration_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_gravity_acceleration() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btRigidBodyDoubleData_m_gravity_acceleration_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_invInertiaLocal(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_invInertiaLocal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_invInertiaLocal() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btRigidBodyDoubleData_m_invInertiaLocal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_totalForce(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_totalForce_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_totalForce() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btRigidBodyDoubleData_m_totalForce_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_totalTorque(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btRigidBodyDoubleData_m_totalTorque_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_totalTorque() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btRigidBodyDoubleData_m_totalTorque_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_inverseMass(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_inverseMass_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_inverseMass() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btRigidBodyDoubleData_m_inverseMass_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_linearDamping(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_linearDamping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_linearDamping() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btRigidBodyDoubleData_m_linearDamping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_angularDamping(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_angularDamping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_angularDamping() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btRigidBodyDoubleData_m_angularDamping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_additionalDampingFactor(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_additionalDampingFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_additionalDampingFactor() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btRigidBodyDoubleData_m_additionalDampingFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_additionalLinearDampingThresholdSqr(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_additionalLinearDampingThresholdSqr() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btRigidBodyDoubleData_m_additionalLinearDampingThresholdSqr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_additionalAngularDampingThresholdSqr(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_additionalAngularDampingThresholdSqr() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btRigidBodyDoubleData_m_additionalAngularDampingThresholdSqr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_additionalAngularDampingFactor(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_additionalAngularDampingFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_additionalAngularDampingFactor() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btRigidBodyDoubleData_m_additionalAngularDampingFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_linearSleepingThreshold(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_linearSleepingThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_linearSleepingThreshold() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btRigidBodyDoubleData_m_linearSleepingThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_angularSleepingThreshold(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_angularSleepingThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_angularSleepingThreshold() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btRigidBodyDoubleData_m_angularSleepingThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_additionalDamping(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_additionalDamping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_additionalDamping() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btRigidBodyDoubleData_m_additionalDamping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) SetM_padding(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRigidBodyDoubleData_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_60)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtRigidBodyDoubleData) GetM_padding() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btRigidBodyDoubleData_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtRigidBodyDoubleData() (_swig_ret BtRigidBodyDoubleData) { + var swig_r BtRigidBodyDoubleData + swig_r = (BtRigidBodyDoubleData)(SwigcptrBtRigidBodyDoubleData(C._wrap_new_btRigidBodyDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtRigidBodyDoubleData(arg1 BtRigidBodyDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btRigidBodyDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtRigidBodyDoubleData interface { + Swigcptr() uintptr + SwigIsBtRigidBodyDoubleData() + SetM_collisionObjectData(arg2 BtCollisionObjectDoubleData) + GetM_collisionObjectData() (_swig_ret BtCollisionObjectDoubleData) + SetM_invInertiaTensorWorld(arg2 BtMatrix3x3DoubleData) + GetM_invInertiaTensorWorld() (_swig_ret BtMatrix3x3DoubleData) + SetM_linearVelocity(arg2 BtVector3DoubleData) + GetM_linearVelocity() (_swig_ret BtVector3DoubleData) + SetM_angularVelocity(arg2 BtVector3DoubleData) + GetM_angularVelocity() (_swig_ret BtVector3DoubleData) + SetM_angularFactor(arg2 BtVector3DoubleData) + GetM_angularFactor() (_swig_ret BtVector3DoubleData) + SetM_linearFactor(arg2 BtVector3DoubleData) + GetM_linearFactor() (_swig_ret BtVector3DoubleData) + SetM_gravity(arg2 BtVector3DoubleData) + GetM_gravity() (_swig_ret BtVector3DoubleData) + SetM_gravity_acceleration(arg2 BtVector3DoubleData) + GetM_gravity_acceleration() (_swig_ret BtVector3DoubleData) + SetM_invInertiaLocal(arg2 BtVector3DoubleData) + GetM_invInertiaLocal() (_swig_ret BtVector3DoubleData) + SetM_totalForce(arg2 BtVector3DoubleData) + GetM_totalForce() (_swig_ret BtVector3DoubleData) + SetM_totalTorque(arg2 BtVector3DoubleData) + GetM_totalTorque() (_swig_ret BtVector3DoubleData) + SetM_inverseMass(arg2 float64) + GetM_inverseMass() (_swig_ret float64) + SetM_linearDamping(arg2 float64) + GetM_linearDamping() (_swig_ret float64) + SetM_angularDamping(arg2 float64) + GetM_angularDamping() (_swig_ret float64) + SetM_additionalDampingFactor(arg2 float64) + GetM_additionalDampingFactor() (_swig_ret float64) + SetM_additionalLinearDampingThresholdSqr(arg2 float64) + GetM_additionalLinearDampingThresholdSqr() (_swig_ret float64) + SetM_additionalAngularDampingThresholdSqr(arg2 float64) + GetM_additionalAngularDampingThresholdSqr() (_swig_ret float64) + SetM_additionalAngularDampingFactor(arg2 float64) + GetM_additionalAngularDampingFactor() (_swig_ret float64) + SetM_linearSleepingThreshold(arg2 float64) + GetM_linearSleepingThreshold() (_swig_ret float64) + SetM_angularSleepingThreshold(arg2 float64) + GetM_angularSleepingThreshold() (_swig_ret float64) + SetM_additionalDamping(arg2 int) + GetM_additionalDamping() (_swig_ret int) + SetM_padding(arg2 string) + GetM_padding() (_swig_ret string) +} + +func BtAabbSupport(arg1 BtVector3, arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btAabbSupport_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +type SwigcptrBtTransformUtil uintptr + +func (p SwigcptrBtTransformUtil) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTransformUtil) SwigIsBtTransformUtil() { +} + +func BtTransformUtilIntegrateTransform(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtTransform) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btTransformUtil_integrateTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func BtTransformUtilCalculateVelocityQuaternion(arg1 BtVector3, arg2 BtVector3, arg3 BtQuaternion, arg4 BtQuaternion, arg5 float32, arg6 BtVector3, arg7 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + C._wrap_btTransformUtil_calculateVelocityQuaternion_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6)) +} + +func BtTransformUtilCalculateDiffAxisAngleQuaternion(arg1 BtQuaternion, arg2 BtQuaternion, arg3 BtVector3, arg4 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btTransformUtil_calculateDiffAxisAngleQuaternion_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_voidp(_swig_i_3)) +} + +func BtTransformUtilCalculateVelocity(arg1 BtTransform, arg2 BtTransform, arg3 float32, arg4 BtVector3, arg5 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btTransformUtil_calculateVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func BtTransformUtilCalculateDiffAxisAngle(arg1 BtTransform, arg2 BtTransform, arg3 BtVector3, arg4 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btTransformUtil_calculateDiffAxisAngle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_voidp(_swig_i_3)) +} + +func NewBtTransformUtil() (_swig_ret BtTransformUtil) { + var swig_r BtTransformUtil + swig_r = (BtTransformUtil)(SwigcptrBtTransformUtil(C._wrap_new_btTransformUtil_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtTransformUtil(arg1 BtTransformUtil) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTransformUtil_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTransformUtil interface { + Swigcptr() uintptr + SwigIsBtTransformUtil() +} + +type SwigcptrBtConvexSeparatingDistanceUtil uintptr + +func (p SwigcptrBtConvexSeparatingDistanceUtil) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexSeparatingDistanceUtil) SwigIsBtConvexSeparatingDistanceUtil() { +} + +func NewBtConvexSeparatingDistanceUtil(arg1 float32, arg2 float32) (_swig_ret BtConvexSeparatingDistanceUtil) { + var swig_r BtConvexSeparatingDistanceUtil + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtConvexSeparatingDistanceUtil)(SwigcptrBtConvexSeparatingDistanceUtil(C._wrap_new_btConvexSeparatingDistanceUtil_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexSeparatingDistanceUtil) GetConservativeSeparatingDistance() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConvexSeparatingDistanceUtil_getConservativeSeparatingDistance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexSeparatingDistanceUtil) UpdateSeparatingDistance(arg2 BtTransform, arg3 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btConvexSeparatingDistanceUtil_updateSeparatingDistance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtConvexSeparatingDistanceUtil) InitSeparatingDistance(arg2 BtVector3, arg3 float32, arg4 BtTransform, arg5 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btConvexSeparatingDistanceUtil_initSeparatingDistance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func DeleteBtConvexSeparatingDistanceUtil(arg1 BtConvexSeparatingDistanceUtil) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexSeparatingDistanceUtil_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtConvexSeparatingDistanceUtil interface { + Swigcptr() uintptr + SwigIsBtConvexSeparatingDistanceUtil() + GetConservativeSeparatingDistance() (_swig_ret float32) + UpdateSeparatingDistance(arg2 BtTransform, arg3 BtTransform) + InitSeparatingDistance(arg2 BtVector3, arg3 float32, arg4 BtTransform, arg5 BtTransform) +} + +type SwigcptrBtJacobianEntry uintptr + +func (p SwigcptrBtJacobianEntry) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtJacobianEntry) SwigIsBtJacobianEntry() { +} + +func NewBtJacobianEntry__SWIG_0() (_swig_ret BtJacobianEntry) { + var swig_r BtJacobianEntry + swig_r = (BtJacobianEntry)(SwigcptrBtJacobianEntry(C._wrap_new_btJacobianEntry__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtJacobianEntry__SWIG_1(arg1 BtMatrix3x3, arg2 BtMatrix3x3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3, arg7 float32, arg8 BtVector3, arg9 float32) (_swig_ret BtJacobianEntry) { + var swig_r BtJacobianEntry + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := arg7 + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := arg9 + swig_r = (BtJacobianEntry)(SwigcptrBtJacobianEntry(C._wrap_new_btJacobianEntry__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.float(_swig_i_6), C.uintptr_t(_swig_i_7), C.float(_swig_i_8)))) + return swig_r +} + +func NewBtJacobianEntry__SWIG_2(arg1 BtVector3, arg2 BtMatrix3x3, arg3 BtMatrix3x3, arg4 BtVector3, arg5 BtVector3) (_swig_ret BtJacobianEntry) { + var swig_r BtJacobianEntry + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (BtJacobianEntry)(SwigcptrBtJacobianEntry(C._wrap_new_btJacobianEntry__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)))) + return swig_r +} + +func NewBtJacobianEntry__SWIG_3(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) (_swig_ret BtJacobianEntry) { + var swig_r BtJacobianEntry + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtJacobianEntry)(SwigcptrBtJacobianEntry(C._wrap_new_btJacobianEntry__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func NewBtJacobianEntry__SWIG_4(arg1 BtMatrix3x3, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 float32) (_swig_ret BtJacobianEntry) { + var swig_r BtJacobianEntry + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + swig_r = (BtJacobianEntry)(SwigcptrBtJacobianEntry(C._wrap_new_btJacobianEntry__SWIG_4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.float(_swig_i_5)))) + return swig_r +} + +func NewBtJacobianEntry(a ...interface{}) BtJacobianEntry { + argc := len(a) + if argc == 0 { + return NewBtJacobianEntry__SWIG_0() + } + if argc == 4 { + return NewBtJacobianEntry__SWIG_3(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(BtVector3)) + } + if argc == 5 { + return NewBtJacobianEntry__SWIG_2(a[0].(BtVector3), a[1].(BtMatrix3x3), a[2].(BtMatrix3x3), a[3].(BtVector3), a[4].(BtVector3)) + } + if argc == 6 { + return NewBtJacobianEntry__SWIG_4(a[0].(BtMatrix3x3), a[1].(BtVector3), a[2].(BtVector3), a[3].(BtVector3), a[4].(BtVector3), a[5].(float32)) + } + if argc == 9 { + return NewBtJacobianEntry__SWIG_1(a[0].(BtMatrix3x3), a[1].(BtMatrix3x3), a[2].(BtVector3), a[3].(BtVector3), a[4].(BtVector3), a[5].(BtVector3), a[6].(float32), a[7].(BtVector3), a[8].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtJacobianEntry) GetDiagonal() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btJacobianEntry_getDiagonal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtJacobianEntry) GetNonDiagonal__SWIG_0(arg2 BtJacobianEntry, arg3 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btJacobianEntry_getNonDiagonal__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtJacobianEntry) GetNonDiagonal__SWIG_1(arg2 BtJacobianEntry, arg3 float32, arg4 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (float32)(C._wrap_btJacobianEntry_getNonDiagonal__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3))) + return swig_r +} + +func (p SwigcptrBtJacobianEntry) GetNonDiagonal(a ...interface{}) float32 { + argc := len(a) + if argc == 2 { + return p.GetNonDiagonal__SWIG_0(a[0].(BtJacobianEntry), a[1].(float32)) + } + if argc == 3 { + return p.GetNonDiagonal__SWIG_1(a[0].(BtJacobianEntry), a[1].(float32), a[2].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtJacobianEntry) GetRelativeVelocity(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btJacobianEntry_getRelativeVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtJacobianEntry) SetM_linearJointAxis(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btJacobianEntry_m_linearJointAxis_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtJacobianEntry) GetM_linearJointAxis() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btJacobianEntry_m_linearJointAxis_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtJacobianEntry) SetM_aJ(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btJacobianEntry_m_aJ_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtJacobianEntry) GetM_aJ() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btJacobianEntry_m_aJ_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtJacobianEntry) SetM_bJ(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btJacobianEntry_m_bJ_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtJacobianEntry) GetM_bJ() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btJacobianEntry_m_bJ_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtJacobianEntry) SetM_0MinvJt(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btJacobianEntry_m_0MinvJt_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtJacobianEntry) GetM_0MinvJt() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btJacobianEntry_m_0MinvJt_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtJacobianEntry) SetM_1MinvJt(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btJacobianEntry_m_1MinvJt_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtJacobianEntry) GetM_1MinvJt() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btJacobianEntry_m_1MinvJt_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtJacobianEntry) SetM_Adiag(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btJacobianEntry_m_Adiag_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtJacobianEntry) GetM_Adiag() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btJacobianEntry_m_Adiag_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtJacobianEntry(arg1 BtJacobianEntry) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btJacobianEntry_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtJacobianEntry interface { + Swigcptr() uintptr + SwigIsBtJacobianEntry() + GetDiagonal() (_swig_ret float32) + GetNonDiagonal(a ...interface{}) float32 + GetRelativeVelocity(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3) (_swig_ret float32) + SetM_linearJointAxis(arg2 BtVector3) + GetM_linearJointAxis() (_swig_ret BtVector3) + SetM_aJ(arg2 BtVector3) + GetM_aJ() (_swig_ret BtVector3) + SetM_bJ(arg2 BtVector3) + GetM_bJ() (_swig_ret BtVector3) + SetM_0MinvJt(arg2 BtVector3) + GetM_0MinvJt() (_swig_ret BtVector3) + SetM_1MinvJt(arg2 BtVector3) + GetM_1MinvJt() (_swig_ret BtVector3) + SetM_Adiag(arg2 float32) + GetM_Adiag() (_swig_ret float32) +} + +type SwigcptrBtSolverBody uintptr + +func (p SwigcptrBtSolverBody) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSolverBody) SwigIsBtSolverBody() { +} + +func (arg1 SwigcptrBtSolverBody) SetM_worldTransform(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_worldTransform_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_worldTransform() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btSolverBody_m_worldTransform_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_deltaLinearVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_deltaLinearVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_deltaLinearVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_deltaLinearVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_deltaAngularVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_deltaAngularVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_deltaAngularVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_deltaAngularVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_angularFactor(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_angularFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_angularFactor() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_angularFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_linearFactor(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_linearFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_linearFactor() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_linearFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_invMass(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_invMass_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_invMass() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_invMass_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_pushVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_pushVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_pushVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_pushVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_turnVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_turnVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_turnVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_turnVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_linearVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_linearVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_linearVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_linearVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_angularVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_angularVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_angularVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_angularVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_externalForceImpulse(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_externalForceImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_externalForceImpulse() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_externalForceImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_externalTorqueImpulse(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_externalTorqueImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_externalTorqueImpulse() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_m_externalTorqueImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetM_originalBody(arg2 BtRigidBody) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_m_originalBody_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetM_originalBody() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := arg1 + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btSolverBody_m_originalBody_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) SetWorldTransform(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_setWorldTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) GetWorldTransform() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btSolverBody_getWorldTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) GetVelocityInLocalPointNoDelta(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSolverBody_getVelocityInLocalPointNoDelta_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSolverBody) GetVelocityInLocalPointObsolete(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSolverBody_getVelocityInLocalPointObsolete_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSolverBody) GetAngularVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_getAngularVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) ApplyImpulse(arg2 BtVector3, arg3 BtVector3, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btSolverBody_applyImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtSolverBody) InternalApplyPushImpulse(arg2 BtVector3, arg3 BtVector3, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btSolverBody_internalApplyPushImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtSolverBody) GetDeltaLinearVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_getDeltaLinearVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) GetDeltaAngularVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_getDeltaAngularVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) GetPushVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_getPushVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) GetTurnVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_getTurnVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) InternalGetDeltaLinearVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_internalGetDeltaLinearVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) InternalGetDeltaAngularVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_internalGetDeltaAngularVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) InternalGetAngularFactor() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_internalGetAngularFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) InternalGetInvMass() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_internalGetInvMass_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) InternalSetInvMass(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_internalSetInvMass_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) InternalGetPushVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_internalGetPushVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) InternalGetTurnVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverBody_internalGetTurnVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverBody) InternalGetVelocityInLocalPointObsolete(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSolverBody_internalGetVelocityInLocalPointObsolete_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSolverBody) InternalGetAngularVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverBody_internalGetAngularVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverBody) InternalApplyImpulse(arg2 BtVector3, arg3 BtVector3, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btSolverBody_internalApplyImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtSolverBody) WritebackVelocity() { + _swig_i_0 := arg1 + C._wrap_btSolverBody_writebackVelocity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSolverBody) WritebackVelocityAndTransform(arg2 float32, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btSolverBody_writebackVelocityAndTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)) +} + +func NewBtSolverBody() (_swig_ret BtSolverBody) { + var swig_r BtSolverBody + swig_r = (BtSolverBody)(SwigcptrBtSolverBody(C._wrap_new_btSolverBody_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtSolverBody(arg1 BtSolverBody) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSolverBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtSolverBody interface { + Swigcptr() uintptr + SwigIsBtSolverBody() + SetM_worldTransform(arg2 BtTransform) + GetM_worldTransform() (_swig_ret BtTransform) + SetM_deltaLinearVelocity(arg2 BtVector3) + GetM_deltaLinearVelocity() (_swig_ret BtVector3) + SetM_deltaAngularVelocity(arg2 BtVector3) + GetM_deltaAngularVelocity() (_swig_ret BtVector3) + SetM_angularFactor(arg2 BtVector3) + GetM_angularFactor() (_swig_ret BtVector3) + SetM_linearFactor(arg2 BtVector3) + GetM_linearFactor() (_swig_ret BtVector3) + SetM_invMass(arg2 BtVector3) + GetM_invMass() (_swig_ret BtVector3) + SetM_pushVelocity(arg2 BtVector3) + GetM_pushVelocity() (_swig_ret BtVector3) + SetM_turnVelocity(arg2 BtVector3) + GetM_turnVelocity() (_swig_ret BtVector3) + SetM_linearVelocity(arg2 BtVector3) + GetM_linearVelocity() (_swig_ret BtVector3) + SetM_angularVelocity(arg2 BtVector3) + GetM_angularVelocity() (_swig_ret BtVector3) + SetM_externalForceImpulse(arg2 BtVector3) + GetM_externalForceImpulse() (_swig_ret BtVector3) + SetM_externalTorqueImpulse(arg2 BtVector3) + GetM_externalTorqueImpulse() (_swig_ret BtVector3) + SetM_originalBody(arg2 BtRigidBody) + GetM_originalBody() (_swig_ret BtRigidBody) + SetWorldTransform(arg2 BtTransform) + GetWorldTransform() (_swig_ret BtTransform) + GetVelocityInLocalPointNoDelta(arg2 BtVector3, arg3 BtVector3) + GetVelocityInLocalPointObsolete(arg2 BtVector3, arg3 BtVector3) + GetAngularVelocity(arg2 BtVector3) + ApplyImpulse(arg2 BtVector3, arg3 BtVector3, arg4 float32) + InternalApplyPushImpulse(arg2 BtVector3, arg3 BtVector3, arg4 float32) + GetDeltaLinearVelocity() (_swig_ret BtVector3) + GetDeltaAngularVelocity() (_swig_ret BtVector3) + GetPushVelocity() (_swig_ret BtVector3) + GetTurnVelocity() (_swig_ret BtVector3) + InternalGetDeltaLinearVelocity() (_swig_ret BtVector3) + InternalGetDeltaAngularVelocity() (_swig_ret BtVector3) + InternalGetAngularFactor() (_swig_ret BtVector3) + InternalGetInvMass() (_swig_ret BtVector3) + InternalSetInvMass(arg2 BtVector3) + InternalGetPushVelocity() (_swig_ret BtVector3) + InternalGetTurnVelocity() (_swig_ret BtVector3) + InternalGetVelocityInLocalPointObsolete(arg2 BtVector3, arg3 BtVector3) + InternalGetAngularVelocity(arg2 BtVector3) + InternalApplyImpulse(arg2 BtVector3, arg3 BtVector3, arg4 float32) + WritebackVelocity() + WritebackVelocityAndTransform(arg2 float32, arg3 float32) +} + +type SwigcptrBtSolverConstraint uintptr + +func (p SwigcptrBtSolverConstraint) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSolverConstraint) SwigIsBtSolverConstraint() { +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_relpos1CrossNormal(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverConstraint_m_relpos1CrossNormal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_relpos1CrossNormal() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverConstraint_m_relpos1CrossNormal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_contactNormal1(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverConstraint_m_contactNormal1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_contactNormal1() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverConstraint_m_contactNormal1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_relpos2CrossNormal(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverConstraint_m_relpos2CrossNormal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_relpos2CrossNormal() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverConstraint_m_relpos2CrossNormal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_contactNormal2(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverConstraint_m_contactNormal2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_contactNormal2() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverConstraint_m_contactNormal2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_angularComponentA(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverConstraint_m_angularComponentA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_angularComponentA() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverConstraint_m_angularComponentA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_angularComponentB(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSolverConstraint_m_angularComponentB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_angularComponentB() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSolverConstraint_m_angularComponentB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_appliedPushImpulse(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_appliedPushImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_appliedPushImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSolverConstraint_m_appliedPushImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_appliedImpulse(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_appliedImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_appliedImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSolverConstraint_m_appliedImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_friction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_friction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_friction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSolverConstraint_m_friction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_jacDiagABInv(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_jacDiagABInv_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_jacDiagABInv() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSolverConstraint_m_jacDiagABInv_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_rhs(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_rhs_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_rhs() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSolverConstraint_m_rhs_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_cfm(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_cfm_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_cfm() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSolverConstraint_m_cfm_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_lowerLimit(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_lowerLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_lowerLimit() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSolverConstraint_m_lowerLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_upperLimit(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_upperLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_upperLimit() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSolverConstraint_m_upperLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_rhsPenetration(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_rhsPenetration_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_rhsPenetration() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSolverConstraint_m_rhsPenetration_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_overrideNumSolverIterations(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_overrideNumSolverIterations() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSolverConstraint_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_frictionIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_frictionIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_frictionIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSolverConstraint_m_frictionIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_solverBodyIdA(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_solverBodyIdA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_solverBodyIdA() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSolverConstraint_m_solverBodyIdA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverConstraint) SetM_solverBodyIdB(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverConstraint_m_solverBodyIdB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverConstraint) GetM_solverBodyIdB() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSolverConstraint_m_solverBodyIdB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +type BtSolverConstraintBtSolverConstraintType int + +func _swig_getbtSolverConstraint_BT_SOLVER_CONTACT_1D_btSolverConstraint() (_swig_ret BtSolverConstraintBtSolverConstraintType) { + var swig_r BtSolverConstraintBtSolverConstraintType + swig_r = (BtSolverConstraintBtSolverConstraintType)(C._wrap_BT_SOLVER_CONTACT_1D_btSolverConstraint_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtSolverConstraintBT_SOLVER_CONTACT_1D BtSolverConstraintBtSolverConstraintType = _swig_getbtSolverConstraint_BT_SOLVER_CONTACT_1D_btSolverConstraint() + +func _swig_getbtSolverConstraint_BT_SOLVER_FRICTION_1D_btSolverConstraint() (_swig_ret BtSolverConstraintBtSolverConstraintType) { + var swig_r BtSolverConstraintBtSolverConstraintType + swig_r = (BtSolverConstraintBtSolverConstraintType)(C._wrap_BT_SOLVER_FRICTION_1D_btSolverConstraint_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtSolverConstraintBT_SOLVER_FRICTION_1D BtSolverConstraintBtSolverConstraintType = _swig_getbtSolverConstraint_BT_SOLVER_FRICTION_1D_btSolverConstraint() + +func NewBtSolverConstraint() (_swig_ret BtSolverConstraint) { + var swig_r BtSolverConstraint + swig_r = (BtSolverConstraint)(SwigcptrBtSolverConstraint(C._wrap_new_btSolverConstraint_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtSolverConstraint(arg1 BtSolverConstraint) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSolverConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtSolverConstraint interface { + Swigcptr() uintptr + SwigIsBtSolverConstraint() + SetM_relpos1CrossNormal(arg2 BtVector3) + GetM_relpos1CrossNormal() (_swig_ret BtVector3) + SetM_contactNormal1(arg2 BtVector3) + GetM_contactNormal1() (_swig_ret BtVector3) + SetM_relpos2CrossNormal(arg2 BtVector3) + GetM_relpos2CrossNormal() (_swig_ret BtVector3) + SetM_contactNormal2(arg2 BtVector3) + GetM_contactNormal2() (_swig_ret BtVector3) + SetM_angularComponentA(arg2 BtVector3) + GetM_angularComponentA() (_swig_ret BtVector3) + SetM_angularComponentB(arg2 BtVector3) + GetM_angularComponentB() (_swig_ret BtVector3) + SetM_appliedPushImpulse(arg2 float32) + GetM_appliedPushImpulse() (_swig_ret float32) + SetM_appliedImpulse(arg2 float32) + GetM_appliedImpulse() (_swig_ret float32) + SetM_friction(arg2 float32) + GetM_friction() (_swig_ret float32) + SetM_jacDiagABInv(arg2 float32) + GetM_jacDiagABInv() (_swig_ret float32) + SetM_rhs(arg2 float32) + GetM_rhs() (_swig_ret float32) + SetM_cfm(arg2 float32) + GetM_cfm() (_swig_ret float32) + SetM_lowerLimit(arg2 float32) + GetM_lowerLimit() (_swig_ret float32) + SetM_upperLimit(arg2 float32) + GetM_upperLimit() (_swig_ret float32) + SetM_rhsPenetration(arg2 float32) + GetM_rhsPenetration() (_swig_ret float32) + SetM_overrideNumSolverIterations(arg2 int) + GetM_overrideNumSolverIterations() (_swig_ret int) + SetM_frictionIndex(arg2 int) + GetM_frictionIndex() (_swig_ret int) + SetM_solverBodyIdA(arg2 int) + GetM_solverBodyIdA() (_swig_ret int) + SetM_solverBodyIdB(arg2 int) + GetM_solverBodyIdB() (_swig_ret int) +} + +const BtTypedConstraintDataName string = "btTypedConstraintFloatData" + +type BtTypedConstraintType int + +func _swig_getPOINT2POINT_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_POINT2POINT_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var POINT2POINT_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getPOINT2POINT_CONSTRAINT_TYPE() + +func _swig_getHINGE_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_HINGE_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var HINGE_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getHINGE_CONSTRAINT_TYPE() + +func _swig_getCONETWIST_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_CONETWIST_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CONETWIST_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getCONETWIST_CONSTRAINT_TYPE() + +func _swig_getD6_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_D6_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var D6_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getD6_CONSTRAINT_TYPE() + +func _swig_getSLIDER_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_SLIDER_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var SLIDER_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getSLIDER_CONSTRAINT_TYPE() + +func _swig_getCONTACT_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_CONTACT_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var CONTACT_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getCONTACT_CONSTRAINT_TYPE() + +func _swig_getD6_SPRING_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_D6_SPRING_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var D6_SPRING_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getD6_SPRING_CONSTRAINT_TYPE() + +func _swig_getGEAR_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_GEAR_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var GEAR_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getGEAR_CONSTRAINT_TYPE() + +func _swig_getFIXED_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_FIXED_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var FIXED_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getFIXED_CONSTRAINT_TYPE() + +func _swig_getD6_SPRING_2_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_D6_SPRING_2_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var D6_SPRING_2_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getD6_SPRING_2_CONSTRAINT_TYPE() + +func _swig_getMAX_CONSTRAINT_TYPE() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_MAX_CONSTRAINT_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var MAX_CONSTRAINT_TYPE BtTypedConstraintType = _swig_getMAX_CONSTRAINT_TYPE() + +type BtConstraintParams int + +func _swig_getBT_CONSTRAINT_ERP() (_swig_ret BtConstraintParams) { + var swig_r BtConstraintParams + swig_r = (BtConstraintParams)(C._wrap_BT_CONSTRAINT_ERP_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONSTRAINT_ERP BtConstraintParams = _swig_getBT_CONSTRAINT_ERP() + +func _swig_getBT_CONSTRAINT_STOP_ERP() (_swig_ret BtConstraintParams) { + var swig_r BtConstraintParams + swig_r = (BtConstraintParams)(C._wrap_BT_CONSTRAINT_STOP_ERP_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONSTRAINT_STOP_ERP BtConstraintParams = _swig_getBT_CONSTRAINT_STOP_ERP() + +func _swig_getBT_CONSTRAINT_CFM() (_swig_ret BtConstraintParams) { + var swig_r BtConstraintParams + swig_r = (BtConstraintParams)(C._wrap_BT_CONSTRAINT_CFM_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONSTRAINT_CFM BtConstraintParams = _swig_getBT_CONSTRAINT_CFM() + +func _swig_getBT_CONSTRAINT_STOP_CFM() (_swig_ret BtConstraintParams) { + var swig_r BtConstraintParams + swig_r = (BtConstraintParams)(C._wrap_BT_CONSTRAINT_STOP_CFM_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONSTRAINT_STOP_CFM BtConstraintParams = _swig_getBT_CONSTRAINT_STOP_CFM() + +type SwigcptrBtJointFeedback uintptr + +func (p SwigcptrBtJointFeedback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtJointFeedback) SwigIsBtJointFeedback() { +} + +func (arg1 SwigcptrBtJointFeedback) SetM_appliedForceBodyA(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btJointFeedback_m_appliedForceBodyA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtJointFeedback) GetM_appliedForceBodyA() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btJointFeedback_m_appliedForceBodyA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtJointFeedback) SetM_appliedTorqueBodyA(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btJointFeedback_m_appliedTorqueBodyA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtJointFeedback) GetM_appliedTorqueBodyA() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btJointFeedback_m_appliedTorqueBodyA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtJointFeedback) SetM_appliedForceBodyB(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btJointFeedback_m_appliedForceBodyB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtJointFeedback) GetM_appliedForceBodyB() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btJointFeedback_m_appliedForceBodyB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtJointFeedback) SetM_appliedTorqueBodyB(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btJointFeedback_m_appliedTorqueBodyB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtJointFeedback) GetM_appliedTorqueBodyB() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btJointFeedback_m_appliedTorqueBodyB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtJointFeedback() (_swig_ret BtJointFeedback) { + var swig_r BtJointFeedback + swig_r = (BtJointFeedback)(SwigcptrBtJointFeedback(C._wrap_new_btJointFeedback_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtJointFeedback(arg1 BtJointFeedback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btJointFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtJointFeedback interface { + Swigcptr() uintptr + SwigIsBtJointFeedback() + SetM_appliedForceBodyA(arg2 BtVector3) + GetM_appliedForceBodyA() (_swig_ret BtVector3) + SetM_appliedTorqueBodyA(arg2 BtVector3) + GetM_appliedTorqueBodyA() (_swig_ret BtVector3) + SetM_appliedForceBodyB(arg2 BtVector3) + GetM_appliedForceBodyB() (_swig_ret BtVector3) + SetM_appliedTorqueBodyB(arg2 BtVector3) + GetM_appliedTorqueBodyB() (_swig_ret BtVector3) +} + +type SwigcptrBtTypedConstraint uintptr + +func (p SwigcptrBtTypedConstraint) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTypedConstraint) SwigIsBtTypedConstraint() { +} + +func DeleteBtTypedConstraint(arg1 BtTypedConstraint) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTypedConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func BtTypedConstraintGetFixedBody() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btTypedConstraint_getFixedBody_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) GetOverrideNumSolverIterations() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) SetOverrideNumSolverIterations(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) BuildJacobian() { + _swig_i_0 := arg1 + C._wrap_btTypedConstraint_buildJacobian_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtTypedConstraint) SetupSolverConstraint(arg2 BtAlignedObjectArray_Sl_btSolverConstraint_Sg_, arg3 int, arg4 int, arg5 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btTypedConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.float(_swig_i_4)) +} + +func (arg1 SwigcptrBtTypedConstraint) GetInfo1(arg2 BtTypedConstraint_btConstraintInfo1) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTypedConstraint_getInfo1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) GetInfo2(arg2 BtTypedConstraint_btConstraintInfo2) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTypedConstraint_getInfo2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) InternalSetAppliedImpulse(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) InternalGetAppliedImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTypedConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) GetBreakingImpulseThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTypedConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) SetBreakingImpulseThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) IsEnabled() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btTypedConstraint_isEnabled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) SetEnabled(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraint_setEnabled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) SolveConstraintObsolete(arg2 BtSolverBody, arg3 BtSolverBody, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btTypedConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtTypedConstraint) GetRigidBodyA__SWIG_0() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := arg1 + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btTypedConstraint_getRigidBodyA__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) GetRigidBodyB__SWIG_0() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := arg1 + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btTypedConstraint_getRigidBodyB__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) GetRigidBodyA__SWIG_1() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := arg1 + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btTypedConstraint_getRigidBodyA__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtTypedConstraint) GetRigidBodyA(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetRigidBodyA__SWIG_0() + } + if argc == 0 { + return p.GetRigidBodyA__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtTypedConstraint) GetRigidBodyB__SWIG_1() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := arg1 + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btTypedConstraint_getRigidBodyB__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtTypedConstraint) GetRigidBodyB(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetRigidBodyB__SWIG_0() + } + if argc == 0 { + return p.GetRigidBodyB__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtTypedConstraint) GetUserConstraintType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraint_getUserConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) SetUserConstraintType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraint_setUserConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) SetUserConstraintId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraint_setUserConstraintId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) GetUserConstraintId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraint_getUserConstraintId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) SetUserConstraintPtr(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) GetUserConstraintPtr() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btTypedConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) SetJointFeedback(arg2 BtJointFeedback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTypedConstraint_setJointFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) GetJointFeedback__SWIG_0() (_swig_ret BtJointFeedback) { + var swig_r BtJointFeedback + _swig_i_0 := arg1 + swig_r = (BtJointFeedback)(SwigcptrBtJointFeedback(C._wrap_btTypedConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) GetJointFeedback__SWIG_1() (_swig_ret BtJointFeedback) { + var swig_r BtJointFeedback + _swig_i_0 := arg1 + swig_r = (BtJointFeedback)(SwigcptrBtJointFeedback(C._wrap_btTypedConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtTypedConstraint) GetJointFeedback(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetJointFeedback__SWIG_0() + } + if argc == 0 { + return p.GetJointFeedback__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtTypedConstraint) GetUid() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraint_getUid_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) NeedsFeedback() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btTypedConstraint_needsFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) EnableFeedback(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraint_enableFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) GetAppliedImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTypedConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) GetConstraintType() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + _swig_i_0 := arg1 + swig_r = (BtTypedConstraintType)(C._wrap_btTypedConstraint_getConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) SetDbgDrawSize(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraint) GetDbgDrawSize() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTypedConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) SetParam__SWIG_0(arg2 int, arg3 float32, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btTypedConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtTypedConstraint) SetParam__SWIG_1(arg2 int, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btTypedConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2)) +} + +func (p SwigcptrBtTypedConstraint) SetParam(a ...interface{}) { + argc := len(a) + if argc == 2 { + p.SetParam__SWIG_1(a[0].(int), a[1].(float32)) + return + } + if argc == 3 { + p.SetParam__SWIG_0(a[0].(int), a[1].(float32), a[2].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtTypedConstraint) GetParam__SWIG_0(arg2 int, arg3 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btTypedConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) GetParam__SWIG_1(arg2 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btTypedConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (p SwigcptrBtTypedConstraint) GetParam(a ...interface{}) float32 { + argc := len(a) + if argc == 1 { + return p.GetParam__SWIG_1(a[0].(int)) + } + if argc == 2 { + return p.GetParam__SWIG_0(a[0].(int), a[1].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtTypedConstraint) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraint) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btTypedConstraint_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtTypedConstraint) SetM_objectType(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtTypedConstraint_M_objectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtTypedConstraint) GetM_objectType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtTypedConstraint_M_objectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTypedConstraint) GetObjectType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btTypedConstraint_getObjectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtTypedConstraint) SwigIsBtTypedObject() { +} + +func (p SwigcptrBtTypedConstraint) SwigGetBtTypedObject() BtTypedObject { + return SwigcptrBtTypedObject(getSwigcptr(p)) +} + +type BtTypedConstraint interface { + Swigcptr() uintptr + SwigIsBtTypedConstraint() + GetOverrideNumSolverIterations() (_swig_ret int) + SetOverrideNumSolverIterations(arg2 int) + BuildJacobian() + SetupSolverConstraint(arg2 BtAlignedObjectArray_Sl_btSolverConstraint_Sg_, arg3 int, arg4 int, arg5 float32) + GetInfo1(arg2 BtTypedConstraint_btConstraintInfo1) + GetInfo2(arg2 BtTypedConstraint_btConstraintInfo2) + InternalSetAppliedImpulse(arg2 float32) + InternalGetAppliedImpulse() (_swig_ret float32) + GetBreakingImpulseThreshold() (_swig_ret float32) + SetBreakingImpulseThreshold(arg2 float32) + IsEnabled() (_swig_ret bool) + SetEnabled(arg2 bool) + SolveConstraintObsolete(arg2 BtSolverBody, arg3 BtSolverBody, arg4 float32) + GetRigidBodyA(a ...interface{}) interface{} + GetRigidBodyB(a ...interface{}) interface{} + GetUserConstraintType() (_swig_ret int) + SetUserConstraintType(arg2 int) + SetUserConstraintId(arg2 int) + GetUserConstraintId() (_swig_ret int) + SetUserConstraintPtr(arg2 uintptr) + GetUserConstraintPtr() (_swig_ret uintptr) + SetJointFeedback(arg2 BtJointFeedback) + GetJointFeedback(a ...interface{}) interface{} + GetUid() (_swig_ret int) + NeedsFeedback() (_swig_ret bool) + EnableFeedback(arg2 bool) + GetAppliedImpulse() (_swig_ret float32) + GetConstraintType() (_swig_ret BtTypedConstraintType) + SetDbgDrawSize(arg2 float32) + GetDbgDrawSize() (_swig_ret float32) + SetParam(a ...interface{}) + GetParam(a ...interface{}) float32 + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + SetM_objectType(arg1 int) + GetM_objectType() (_swig_ret int) + GetObjectType() (_swig_ret int) + SwigIsBtTypedObject() + SwigGetBtTypedObject() BtTypedObject +} + +func BtAdjustAngleToLimits(arg1 float32, arg2 float32, arg3 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btAdjustAngleToLimits_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2))) + return swig_r +} + +type SwigcptrBtTypedConstraintFloatData uintptr + +func (p SwigcptrBtTypedConstraintFloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTypedConstraintFloatData) SwigIsBtTypedConstraintFloatData() { +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_rbA(arg2 BtRigidBodyFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTypedConstraintFloatData_m_rbA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_rbA() (_swig_ret BtRigidBodyFloatData) { + var swig_r BtRigidBodyFloatData + _swig_i_0 := arg1 + swig_r = (BtRigidBodyFloatData)(SwigcptrBtRigidBodyFloatData(C._wrap_btTypedConstraintFloatData_m_rbA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_rbB(arg2 BtRigidBodyFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTypedConstraintFloatData_m_rbB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_rbB() (_swig_ret BtRigidBodyFloatData) { + var swig_r BtRigidBodyFloatData + _swig_i_0 := arg1 + swig_r = (BtRigidBodyFloatData)(SwigcptrBtRigidBodyFloatData(C._wrap_btTypedConstraintFloatData_m_rbB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_name(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_name_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_63)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_name() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btTypedConstraintFloatData_m_name_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_objectType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_objectType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_objectType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintFloatData_m_objectType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_userConstraintType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_userConstraintType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_userConstraintType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintFloatData_m_userConstraintType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_userConstraintId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_userConstraintId_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_userConstraintId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintFloatData_m_userConstraintId_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_needsFeedback(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_needsFeedback_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_needsFeedback() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintFloatData_m_needsFeedback_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_appliedImpulse(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_appliedImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_appliedImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTypedConstraintFloatData_m_appliedImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_dbgDrawSize(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_dbgDrawSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_dbgDrawSize() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTypedConstraintFloatData_m_dbgDrawSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_disableCollisionsBetweenLinkedBodies(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_disableCollisionsBetweenLinkedBodies_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_disableCollisionsBetweenLinkedBodies() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintFloatData_m_disableCollisionsBetweenLinkedBodies_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_overrideNumSolverIterations(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_overrideNumSolverIterations() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintFloatData_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_breakingImpulseThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_breakingImpulseThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_breakingImpulseThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTypedConstraintFloatData_m_breakingImpulseThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) SetM_isEnabled(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintFloatData_m_isEnabled_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintFloatData) GetM_isEnabled() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintFloatData_m_isEnabled_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtTypedConstraintFloatData() (_swig_ret BtTypedConstraintFloatData) { + var swig_r BtTypedConstraintFloatData + swig_r = (BtTypedConstraintFloatData)(SwigcptrBtTypedConstraintFloatData(C._wrap_new_btTypedConstraintFloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtTypedConstraintFloatData(arg1 BtTypedConstraintFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTypedConstraintFloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTypedConstraintFloatData interface { + Swigcptr() uintptr + SwigIsBtTypedConstraintFloatData() + SetM_rbA(arg2 BtRigidBodyFloatData) + GetM_rbA() (_swig_ret BtRigidBodyFloatData) + SetM_rbB(arg2 BtRigidBodyFloatData) + GetM_rbB() (_swig_ret BtRigidBodyFloatData) + SetM_name(arg2 string) + GetM_name() (_swig_ret string) + SetM_objectType(arg2 int) + GetM_objectType() (_swig_ret int) + SetM_userConstraintType(arg2 int) + GetM_userConstraintType() (_swig_ret int) + SetM_userConstraintId(arg2 int) + GetM_userConstraintId() (_swig_ret int) + SetM_needsFeedback(arg2 int) + GetM_needsFeedback() (_swig_ret int) + SetM_appliedImpulse(arg2 float32) + GetM_appliedImpulse() (_swig_ret float32) + SetM_dbgDrawSize(arg2 float32) + GetM_dbgDrawSize() (_swig_ret float32) + SetM_disableCollisionsBetweenLinkedBodies(arg2 int) + GetM_disableCollisionsBetweenLinkedBodies() (_swig_ret int) + SetM_overrideNumSolverIterations(arg2 int) + GetM_overrideNumSolverIterations() (_swig_ret int) + SetM_breakingImpulseThreshold(arg2 float32) + GetM_breakingImpulseThreshold() (_swig_ret float32) + SetM_isEnabled(arg2 int) + GetM_isEnabled() (_swig_ret int) +} + +type SwigcptrBtTypedConstraintData uintptr + +func (p SwigcptrBtTypedConstraintData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTypedConstraintData) SwigIsBtTypedConstraintData() { +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_rbA(arg2 BtRigidBodyFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTypedConstraintData_m_rbA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_rbA() (_swig_ret BtRigidBodyFloatData) { + var swig_r BtRigidBodyFloatData + _swig_i_0 := arg1 + swig_r = (BtRigidBodyFloatData)(SwigcptrBtRigidBodyFloatData(C._wrap_btTypedConstraintData_m_rbA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_rbB(arg2 BtRigidBodyFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTypedConstraintData_m_rbB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_rbB() (_swig_ret BtRigidBodyFloatData) { + var swig_r BtRigidBodyFloatData + _swig_i_0 := arg1 + swig_r = (BtRigidBodyFloatData)(SwigcptrBtRigidBodyFloatData(C._wrap_btTypedConstraintData_m_rbB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_name(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_name_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_65)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_name() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btTypedConstraintData_m_name_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_objectType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_objectType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_objectType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintData_m_objectType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_userConstraintType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_userConstraintType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_userConstraintType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintData_m_userConstraintType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_userConstraintId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_userConstraintId_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_userConstraintId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintData_m_userConstraintId_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_needsFeedback(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_needsFeedback_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_needsFeedback() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintData_m_needsFeedback_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_appliedImpulse(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_appliedImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_appliedImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTypedConstraintData_m_appliedImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_dbgDrawSize(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_dbgDrawSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_dbgDrawSize() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTypedConstraintData_m_dbgDrawSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_disableCollisionsBetweenLinkedBodies(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_disableCollisionsBetweenLinkedBodies_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_disableCollisionsBetweenLinkedBodies() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintData_m_disableCollisionsBetweenLinkedBodies_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_overrideNumSolverIterations(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_overrideNumSolverIterations() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintData_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_breakingImpulseThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_breakingImpulseThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_breakingImpulseThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTypedConstraintData_m_breakingImpulseThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintData) SetM_isEnabled(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintData_m_isEnabled_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintData) GetM_isEnabled() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintData_m_isEnabled_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtTypedConstraintData() (_swig_ret BtTypedConstraintData) { + var swig_r BtTypedConstraintData + swig_r = (BtTypedConstraintData)(SwigcptrBtTypedConstraintData(C._wrap_new_btTypedConstraintData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtTypedConstraintData(arg1 BtTypedConstraintData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTypedConstraintData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTypedConstraintData interface { + Swigcptr() uintptr + SwigIsBtTypedConstraintData() + SetM_rbA(arg2 BtRigidBodyFloatData) + GetM_rbA() (_swig_ret BtRigidBodyFloatData) + SetM_rbB(arg2 BtRigidBodyFloatData) + GetM_rbB() (_swig_ret BtRigidBodyFloatData) + SetM_name(arg2 string) + GetM_name() (_swig_ret string) + SetM_objectType(arg2 int) + GetM_objectType() (_swig_ret int) + SetM_userConstraintType(arg2 int) + GetM_userConstraintType() (_swig_ret int) + SetM_userConstraintId(arg2 int) + GetM_userConstraintId() (_swig_ret int) + SetM_needsFeedback(arg2 int) + GetM_needsFeedback() (_swig_ret int) + SetM_appliedImpulse(arg2 float32) + GetM_appliedImpulse() (_swig_ret float32) + SetM_dbgDrawSize(arg2 float32) + GetM_dbgDrawSize() (_swig_ret float32) + SetM_disableCollisionsBetweenLinkedBodies(arg2 int) + GetM_disableCollisionsBetweenLinkedBodies() (_swig_ret int) + SetM_overrideNumSolverIterations(arg2 int) + GetM_overrideNumSolverIterations() (_swig_ret int) + SetM_breakingImpulseThreshold(arg2 float32) + GetM_breakingImpulseThreshold() (_swig_ret float32) + SetM_isEnabled(arg2 int) + GetM_isEnabled() (_swig_ret int) +} + +type SwigcptrBtTypedConstraintDoubleData uintptr + +func (p SwigcptrBtTypedConstraintDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTypedConstraintDoubleData) SwigIsBtTypedConstraintDoubleData() { +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_rbA(arg2 BtRigidBodyDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTypedConstraintDoubleData_m_rbA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_rbA() (_swig_ret BtRigidBodyDoubleData) { + var swig_r BtRigidBodyDoubleData + _swig_i_0 := arg1 + swig_r = (BtRigidBodyDoubleData)(SwigcptrBtRigidBodyDoubleData(C._wrap_btTypedConstraintDoubleData_m_rbA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_rbB(arg2 BtRigidBodyDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTypedConstraintDoubleData_m_rbB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_rbB() (_swig_ret BtRigidBodyDoubleData) { + var swig_r BtRigidBodyDoubleData + _swig_i_0 := arg1 + swig_r = (BtRigidBodyDoubleData)(SwigcptrBtRigidBodyDoubleData(C._wrap_btTypedConstraintDoubleData_m_rbB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_name(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_name_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_67)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_name() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btTypedConstraintDoubleData_m_name_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_objectType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_objectType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_objectType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintDoubleData_m_objectType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_userConstraintType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_userConstraintType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_userConstraintType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintDoubleData_m_userConstraintType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_userConstraintId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_userConstraintId_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_userConstraintId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintDoubleData_m_userConstraintId_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_needsFeedback(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_needsFeedback_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_needsFeedback() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintDoubleData_m_needsFeedback_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_appliedImpulse(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_appliedImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_appliedImpulse() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btTypedConstraintDoubleData_m_appliedImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_dbgDrawSize(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_dbgDrawSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_dbgDrawSize() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btTypedConstraintDoubleData_m_dbgDrawSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_disableCollisionsBetweenLinkedBodies(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_disableCollisionsBetweenLinkedBodies_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_disableCollisionsBetweenLinkedBodies() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintDoubleData_m_disableCollisionsBetweenLinkedBodies_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_overrideNumSolverIterations(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_overrideNumSolverIterations_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_overrideNumSolverIterations() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintDoubleData_m_overrideNumSolverIterations_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_breakingImpulseThreshold(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_breakingImpulseThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_breakingImpulseThreshold() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btTypedConstraintDoubleData_m_breakingImpulseThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetM_isEnabled(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_m_isEnabled_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetM_isEnabled() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTypedConstraintDoubleData_m_isEnabled_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) SetPadding(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTypedConstraintDoubleData_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_69)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtTypedConstraintDoubleData) GetPadding() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btTypedConstraintDoubleData_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtTypedConstraintDoubleData() (_swig_ret BtTypedConstraintDoubleData) { + var swig_r BtTypedConstraintDoubleData + swig_r = (BtTypedConstraintDoubleData)(SwigcptrBtTypedConstraintDoubleData(C._wrap_new_btTypedConstraintDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtTypedConstraintDoubleData(arg1 BtTypedConstraintDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTypedConstraintDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTypedConstraintDoubleData interface { + Swigcptr() uintptr + SwigIsBtTypedConstraintDoubleData() + SetM_rbA(arg2 BtRigidBodyDoubleData) + GetM_rbA() (_swig_ret BtRigidBodyDoubleData) + SetM_rbB(arg2 BtRigidBodyDoubleData) + GetM_rbB() (_swig_ret BtRigidBodyDoubleData) + SetM_name(arg2 string) + GetM_name() (_swig_ret string) + SetM_objectType(arg2 int) + GetM_objectType() (_swig_ret int) + SetM_userConstraintType(arg2 int) + GetM_userConstraintType() (_swig_ret int) + SetM_userConstraintId(arg2 int) + GetM_userConstraintId() (_swig_ret int) + SetM_needsFeedback(arg2 int) + GetM_needsFeedback() (_swig_ret int) + SetM_appliedImpulse(arg2 float64) + GetM_appliedImpulse() (_swig_ret float64) + SetM_dbgDrawSize(arg2 float64) + GetM_dbgDrawSize() (_swig_ret float64) + SetM_disableCollisionsBetweenLinkedBodies(arg2 int) + GetM_disableCollisionsBetweenLinkedBodies() (_swig_ret int) + SetM_overrideNumSolverIterations(arg2 int) + GetM_overrideNumSolverIterations() (_swig_ret int) + SetM_breakingImpulseThreshold(arg2 float64) + GetM_breakingImpulseThreshold() (_swig_ret float64) + SetM_isEnabled(arg2 int) + GetM_isEnabled() (_swig_ret int) + SetPadding(arg2 string) + GetPadding() (_swig_ret string) +} + +type SwigcptrBtAngularLimit uintptr + +func (p SwigcptrBtAngularLimit) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtAngularLimit) SwigIsBtAngularLimit() { +} + +func NewBtAngularLimit() (_swig_ret BtAngularLimit) { + var swig_r BtAngularLimit + swig_r = (BtAngularLimit)(SwigcptrBtAngularLimit(C._wrap_new_btAngularLimit_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtAngularLimit) Set__SWIG_0(arg2 float32, arg3 float32, arg4 float32, arg5 float32, arg6 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + C._wrap_btAngularLimit_set__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5)) +} + +func (arg1 SwigcptrBtAngularLimit) Set__SWIG_1(arg2 float32, arg3 float32, arg4 float32, arg5 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btAngularLimit_set__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4)) +} + +func (arg1 SwigcptrBtAngularLimit) Set__SWIG_2(arg2 float32, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btAngularLimit_set__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtAngularLimit) Set__SWIG_3(arg2 float32, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btAngularLimit_set__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)) +} + +func (p SwigcptrBtAngularLimit) Set(a ...interface{}) { + argc := len(a) + if argc == 2 { + p.Set__SWIG_3(a[0].(float32), a[1].(float32)) + return + } + if argc == 3 { + p.Set__SWIG_2(a[0].(float32), a[1].(float32), a[2].(float32)) + return + } + if argc == 4 { + p.Set__SWIG_1(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32)) + return + } + if argc == 5 { + p.Set__SWIG_0(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32), a[4].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtAngularLimit) Test(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btAngularLimit_test_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtAngularLimit) GetSoftness() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAngularLimit_getSoftness_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtAngularLimit) GetBiasFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAngularLimit_getBiasFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtAngularLimit) GetRelaxationFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAngularLimit_getRelaxationFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtAngularLimit) GetCorrection() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAngularLimit_getCorrection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtAngularLimit) GetSign() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAngularLimit_getSign_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtAngularLimit) GetHalfRange() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAngularLimit_getHalfRange_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtAngularLimit) IsLimit() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btAngularLimit_isLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtAngularLimit) Fit(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btAngularLimit_fit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtAngularLimit) GetError() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAngularLimit_getError_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtAngularLimit) GetLow() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAngularLimit_getLow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtAngularLimit) GetHigh() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btAngularLimit_getHigh_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtAngularLimit(arg1 BtAngularLimit) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btAngularLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtAngularLimit interface { + Swigcptr() uintptr + SwigIsBtAngularLimit() + Set(a ...interface{}) + Test(arg2 float32) + GetSoftness() (_swig_ret float32) + GetBiasFactor() (_swig_ret float32) + GetRelaxationFactor() (_swig_ret float32) + GetCorrection() (_swig_ret float32) + GetSign() (_swig_ret float32) + GetHalfRange() (_swig_ret float32) + IsLimit() (_swig_ret bool) + Fit(arg2 *float32) + GetError() (_swig_ret float32) + GetLow() (_swig_ret float32) + GetHigh() (_swig_ret float32) +} + +type SwigcptrBtHashString uintptr + +func (p SwigcptrBtHashString) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtHashString) SwigIsBtHashString() { +} + +func (arg1 SwigcptrBtHashString) SetM_string1(arg2 Std_string) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btHashString_m_string1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtHashString) GetM_string1() (_swig_ret Std_string) { + var swig_r Std_string + _swig_i_0 := arg1 + swig_r = (Std_string)(SwigcptrStd_string(C._wrap_btHashString_m_string1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtHashString) SetM_hash(arg2 uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btHashString_m_hash_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtHashString) GetM_hash() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btHashString_m_hash_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtHashString) GetHash() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btHashString_getHash_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtHashString__SWIG_0() (_swig_ret BtHashString) { + var swig_r BtHashString + swig_r = (BtHashString)(SwigcptrBtHashString(C._wrap_new_btHashString__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtHashString__SWIG_1(arg1 string) (_swig_ret BtHashString) { + var swig_r BtHashString + _swig_i_0 := arg1 + swig_r = (BtHashString)(SwigcptrBtHashString(C._wrap_new_btHashString__SWIG_1_mbt_e879218550ba2e2b(*(*C.swig_type_71)(unsafe.Pointer(&_swig_i_0))))) + if Swig_escape_always_false { + Swig_escape_val = arg1 + } + return swig_r +} + +func NewBtHashString(a ...interface{}) BtHashString { + argc := len(a) + if argc == 0 { + return NewBtHashString__SWIG_0() + } + if argc == 1 { + return NewBtHashString__SWIG_1(a[0].(string)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHashString) Equals(arg2 BtHashString) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btHashString_equals_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func DeleteBtHashString(arg1 BtHashString) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btHashString_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtHashString interface { + Swigcptr() uintptr + SwigIsBtHashString() + SetM_string1(arg2 Std_string) + GetM_string1() (_swig_ret Std_string) + SetM_hash(arg2 uint) + GetM_hash() (_swig_ret uint) + GetHash() (_swig_ret uint) + Equals(arg2 BtHashString) (_swig_ret bool) +} + +func GetBT_HASH_NULL() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_BT_HASH_NULL_get_mbt_e879218550ba2e2b()) + return swig_r +} + +type SwigcptrBtHashInt uintptr + +func (p SwigcptrBtHashInt) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtHashInt) SwigIsBtHashInt() { +} + +func NewBtHashInt__SWIG_0() (_swig_ret BtHashInt) { + var swig_r BtHashInt + swig_r = (BtHashInt)(SwigcptrBtHashInt(C._wrap_new_btHashInt__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtHashInt__SWIG_1(arg1 int) (_swig_ret BtHashInt) { + var swig_r BtHashInt + _swig_i_0 := arg1 + swig_r = (BtHashInt)(SwigcptrBtHashInt(C._wrap_new_btHashInt__SWIG_1_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0)))) + return swig_r +} + +func NewBtHashInt(a ...interface{}) BtHashInt { + argc := len(a) + if argc == 0 { + return NewBtHashInt__SWIG_0() + } + if argc == 1 { + return NewBtHashInt__SWIG_1(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHashInt) GetUid1() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btHashInt_getUid1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtHashInt) SetUid1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btHashInt_setUid1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtHashInt) Equals(arg2 BtHashInt) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btHashInt_equals_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtHashInt) GetHash() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btHashInt_getHash_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtHashInt(arg1 BtHashInt) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btHashInt_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtHashInt interface { + Swigcptr() uintptr + SwigIsBtHashInt() + GetUid1() (_swig_ret int) + SetUid1(arg2 int) + Equals(arg2 BtHashInt) (_swig_ret bool) + GetHash() (_swig_ret uint) +} + +type SwigcptrBtHashPtr uintptr + +func (p SwigcptrBtHashPtr) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtHashPtr) SwigIsBtHashPtr() { +} + +func NewBtHashPtr__SWIG_0() (_swig_ret BtHashPtr) { + var swig_r BtHashPtr + swig_r = (BtHashPtr)(SwigcptrBtHashPtr(C._wrap_new_btHashPtr__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtHashPtr__SWIG_1(arg1 uintptr) (_swig_ret BtHashPtr) { + var swig_r BtHashPtr + _swig_i_0 := arg1 + swig_r = (BtHashPtr)(SwigcptrBtHashPtr(C._wrap_new_btHashPtr__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtHashPtr(a ...interface{}) BtHashPtr { + argc := len(a) + if argc == 0 { + return NewBtHashPtr__SWIG_0() + } + if argc == 1 { + return NewBtHashPtr__SWIG_1(a[0].(uintptr)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHashPtr) GetPointer() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btHashPtr_getPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtHashPtr) Equals(arg2 BtHashPtr) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btHashPtr_equals_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtHashPtr) GetHash() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btHashPtr_getHash_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtHashPtr(arg1 BtHashPtr) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btHashPtr_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtHashPtr interface { + Swigcptr() uintptr + SwigIsBtHashPtr() + GetPointer() (_swig_ret uintptr) + Equals(arg2 BtHashPtr) (_swig_ret bool) + GetHash() (_swig_ret uint) +} + +func SetSBulletDNAstr(arg1 string) { + _swig_i_0 := arg1 + C._wrap_sBulletDNAstr_set_mbt_e879218550ba2e2b(*(*C.swig_type_72)(unsafe.Pointer(&_swig_i_0))) + if Swig_escape_always_false { + Swig_escape_val = arg1 + } +} + +func GetSBulletDNAstr() (_swig_ret string) { + var swig_r string + swig_r_p := C._wrap_sBulletDNAstr_get_mbt_e879218550ba2e2b() + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func SetSBulletDNAlen(arg1 int) { + _swig_i_0 := arg1 + C._wrap_sBulletDNAlen_set_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0)) +} + +func GetSBulletDNAlen() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_sBulletDNAlen_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetSBulletDNAstr64(arg1 string) { + _swig_i_0 := arg1 + C._wrap_sBulletDNAstr64_set_mbt_e879218550ba2e2b(*(*C.swig_type_74)(unsafe.Pointer(&_swig_i_0))) + if Swig_escape_always_false { + Swig_escape_val = arg1 + } +} + +func GetSBulletDNAstr64() (_swig_ret string) { + var swig_r string + swig_r_p := C._wrap_sBulletDNAstr64_get_mbt_e879218550ba2e2b() + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func SetSBulletDNAlen64(arg1 int) { + _swig_i_0 := arg1 + C._wrap_sBulletDNAlen64_set_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0)) +} + +func GetSBulletDNAlen64() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_sBulletDNAlen64_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtStrLen(arg1 string) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btStrLen_mbt_e879218550ba2e2b(*(*C.swig_type_76)(unsafe.Pointer(&_swig_i_0)))) + if Swig_escape_always_false { + Swig_escape_val = arg1 + } + return swig_r +} + +type SwigcptrBtChunk uintptr + +func (p SwigcptrBtChunk) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtChunk) SwigIsBtChunk() { +} + +func (arg1 SwigcptrBtChunk) SetM_chunkCode(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btChunk_m_chunkCode_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtChunk) GetM_chunkCode() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btChunk_m_chunkCode_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtChunk) SetM_length(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btChunk_m_length_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtChunk) GetM_length() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btChunk_m_length_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtChunk) SetM_oldPtr(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btChunk_m_oldPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtChunk) GetM_oldPtr() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btChunk_m_oldPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtChunk) SetM_dna_nr(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btChunk_m_dna_nr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtChunk) GetM_dna_nr() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btChunk_m_dna_nr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtChunk) SetM_number(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btChunk_m_number_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtChunk) GetM_number() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btChunk_m_number_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtChunk() (_swig_ret BtChunk) { + var swig_r BtChunk + swig_r = (BtChunk)(SwigcptrBtChunk(C._wrap_new_btChunk_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtChunk(arg1 BtChunk) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btChunk_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtChunk interface { + Swigcptr() uintptr + SwigIsBtChunk() + SetM_chunkCode(arg2 int) + GetM_chunkCode() (_swig_ret int) + SetM_length(arg2 int) + GetM_length() (_swig_ret int) + SetM_oldPtr(arg2 uintptr) + GetM_oldPtr() (_swig_ret uintptr) + SetM_dna_nr(arg2 int) + GetM_dna_nr() (_swig_ret int) + SetM_number(arg2 int) + GetM_number() (_swig_ret int) +} + +type BtSerializationFlags int + +func _swig_getBT_SERIALIZE_NO_BVH() (_swig_ret BtSerializationFlags) { + var swig_r BtSerializationFlags + swig_r = (BtSerializationFlags)(C._wrap_BT_SERIALIZE_NO_BVH_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_SERIALIZE_NO_BVH BtSerializationFlags = _swig_getBT_SERIALIZE_NO_BVH() + +func _swig_getBT_SERIALIZE_NO_TRIANGLEINFOMAP() (_swig_ret BtSerializationFlags) { + var swig_r BtSerializationFlags + swig_r = (BtSerializationFlags)(C._wrap_BT_SERIALIZE_NO_TRIANGLEINFOMAP_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_SERIALIZE_NO_TRIANGLEINFOMAP BtSerializationFlags = _swig_getBT_SERIALIZE_NO_TRIANGLEINFOMAP() + +func _swig_getBT_SERIALIZE_NO_DUPLICATE_ASSERT() (_swig_ret BtSerializationFlags) { + var swig_r BtSerializationFlags + swig_r = (BtSerializationFlags)(C._wrap_BT_SERIALIZE_NO_DUPLICATE_ASSERT_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_SERIALIZE_NO_DUPLICATE_ASSERT BtSerializationFlags = _swig_getBT_SERIALIZE_NO_DUPLICATE_ASSERT() + +func _swig_getBT_SERIALIZE_CONTACT_MANIFOLDS() (_swig_ret BtSerializationFlags) { + var swig_r BtSerializationFlags + swig_r = (BtSerializationFlags)(C._wrap_BT_SERIALIZE_CONTACT_MANIFOLDS_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_SERIALIZE_CONTACT_MANIFOLDS BtSerializationFlags = _swig_getBT_SERIALIZE_CONTACT_MANIFOLDS() + +type SwigcptrBtSerializer uintptr + +func (p SwigcptrBtSerializer) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSerializer) SwigIsBtSerializer() { +} + +func DeleteBtSerializer(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSerializer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSerializer) GetBufferPointer() (_swig_ret *byte) { + var swig_r *byte + _swig_i_0 := arg1 + swig_r = (*byte)(C._wrap_btSerializer_getBufferPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSerializer) GetCurrentBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSerializer_getCurrentBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSerializer) Allocate(arg2 int64, arg3 int) (_swig_ret BtChunk) { + var swig_r BtChunk + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtChunk)(SwigcptrBtChunk(C._wrap_btSerializer_allocate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_77(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtSerializer) FinalizeChunk(arg2 BtChunk, arg3 string, arg4 int, arg5 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btSerializer_finalizeChunk_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), *(*C.swig_type_78)(unsafe.Pointer(&_swig_i_2)), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4)) + if Swig_escape_always_false { + Swig_escape_val = arg3 + } +} + +func (arg1 SwigcptrBtSerializer) FindPointer(arg2 uintptr) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (uintptr)(C._wrap_btSerializer_findPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtSerializer) GetUniquePointer(arg2 uintptr) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (uintptr)(C._wrap_btSerializer_getUniquePointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtSerializer) StartSerialization() { + _swig_i_0 := arg1 + C._wrap_btSerializer_startSerialization_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSerializer) FinishSerialization() { + _swig_i_0 := arg1 + C._wrap_btSerializer_finishSerialization_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSerializer) FindNameForPointer(arg2 uintptr) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r_p := C._wrap_btSerializer_findNameForPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtSerializer) RegisterNameForPointer(arg2 uintptr, arg3 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btSerializer_registerNameForPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), *(*C.swig_type_80)(unsafe.Pointer(&_swig_i_2))) + if Swig_escape_always_false { + Swig_escape_val = arg3 + } +} + +func (arg1 SwigcptrBtSerializer) SerializeName(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSerializer_serializeName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_81)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtSerializer) GetSerializationFlags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSerializer_getSerializationFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSerializer) SetSerializationFlags(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSerializer_setSerializationFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSerializer) GetNumChunks() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSerializer_getNumChunks_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSerializer) GetChunk(arg2 int) (_swig_ret BtChunk) { + var swig_r BtChunk + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtChunk)(SwigcptrBtChunk(C._wrap_btSerializer_getChunk_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +type BtSerializer interface { + Swigcptr() uintptr + SwigIsBtSerializer() + GetBufferPointer() (_swig_ret *byte) + GetCurrentBufferSize() (_swig_ret int) + Allocate(arg2 int64, arg3 int) (_swig_ret BtChunk) + FinalizeChunk(arg2 BtChunk, arg3 string, arg4 int, arg5 uintptr) + FindPointer(arg2 uintptr) (_swig_ret uintptr) + GetUniquePointer(arg2 uintptr) (_swig_ret uintptr) + StartSerialization() + FinishSerialization() + FindNameForPointer(arg2 uintptr) (_swig_ret string) + RegisterNameForPointer(arg2 uintptr, arg3 string) + SerializeName(arg2 string) + GetSerializationFlags() (_swig_ret int) + SetSerializationFlags(arg2 int) + GetNumChunks() (_swig_ret int) + GetChunk(arg2 int) (_swig_ret BtChunk) +} + +const BT_HEADER_LENGTH int = 12 + +type SwigcptrBtPointerUid uintptr + +func (p SwigcptrBtPointerUid) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtPointerUid) SwigIsBtPointerUid() { +} + +func NewBtPointerUid() (_swig_ret BtPointerUid) { + var swig_r BtPointerUid + swig_r = (BtPointerUid)(SwigcptrBtPointerUid(C._wrap_new_btPointerUid_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtPointerUid(arg1 BtPointerUid) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btPointerUid_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtPointerUid interface { + Swigcptr() uintptr + SwigIsBtPointerUid() +} + +type SwigcptrBtBulletSerializedArrays uintptr + +func (p SwigcptrBtBulletSerializedArrays) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBulletSerializedArrays) SwigIsBtBulletSerializedArrays() { +} + +func NewBtBulletSerializedArrays() (_swig_ret BtBulletSerializedArrays) { + var swig_r BtBulletSerializedArrays + swig_r = (BtBulletSerializedArrays)(SwigcptrBtBulletSerializedArrays(C._wrap_new_btBulletSerializedArrays_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_bvhsDouble(arg2 BtAlignedObjectArray_Sl_btQuantizedBvhDoubleData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_bvhsDouble_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_bvhsDouble() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhDoubleData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btQuantizedBvhDoubleData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btQuantizedBvhDoubleData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhDoubleData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_bvhsDouble_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_bvhsFloat(arg2 BtAlignedObjectArray_Sl_btQuantizedBvhFloatData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_bvhsFloat_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_bvhsFloat() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhFloatData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btQuantizedBvhFloatData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btQuantizedBvhFloatData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhFloatData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_bvhsFloat_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_colShapeData(arg2 BtAlignedObjectArray_Sl_btCollisionShapeData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_colShapeData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_colShapeData() (_swig_ret BtAlignedObjectArray_Sl_btCollisionShapeData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btCollisionShapeData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btCollisionShapeData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btCollisionShapeData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_colShapeData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_dynamicWorldInfoDataDouble(arg2 BtAlignedObjectArray_Sl_btDynamicsWorldDoubleData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataDouble_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_dynamicWorldInfoDataDouble() (_swig_ret BtAlignedObjectArray_Sl_btDynamicsWorldDoubleData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btDynamicsWorldDoubleData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btDynamicsWorldDoubleData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btDynamicsWorldDoubleData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataDouble_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_dynamicWorldInfoDataFloat(arg2 BtAlignedObjectArray_Sl_btDynamicsWorldFloatData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataFloat_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_dynamicWorldInfoDataFloat() (_swig_ret BtAlignedObjectArray_Sl_btDynamicsWorldFloatData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btDynamicsWorldFloatData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btDynamicsWorldFloatData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btDynamicsWorldFloatData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_dynamicWorldInfoDataFloat_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_rigidBodyDataDouble(arg2 BtAlignedObjectArray_Sl_btRigidBodyDoubleData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_rigidBodyDataDouble_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_rigidBodyDataDouble() (_swig_ret BtAlignedObjectArray_Sl_btRigidBodyDoubleData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btRigidBodyDoubleData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btRigidBodyDoubleData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btRigidBodyDoubleData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_rigidBodyDataDouble_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_rigidBodyDataFloat(arg2 BtAlignedObjectArray_Sl_btRigidBodyFloatData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_rigidBodyDataFloat_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_rigidBodyDataFloat() (_swig_ret BtAlignedObjectArray_Sl_btRigidBodyFloatData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btRigidBodyFloatData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btRigidBodyFloatData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btRigidBodyFloatData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_rigidBodyDataFloat_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_collisionObjectDataDouble(arg2 BtAlignedObjectArray_Sl_btCollisionObjectDoubleData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_collisionObjectDataDouble_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_collisionObjectDataDouble() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObjectDoubleData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btCollisionObjectDoubleData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btCollisionObjectDoubleData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btCollisionObjectDoubleData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_collisionObjectDataDouble_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_collisionObjectDataFloat(arg2 BtAlignedObjectArray_Sl_btCollisionObjectFloatData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_collisionObjectDataFloat_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_collisionObjectDataFloat() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObjectFloatData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btCollisionObjectFloatData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btCollisionObjectFloatData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btCollisionObjectFloatData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_collisionObjectDataFloat_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_constraintDataFloat(arg2 BtAlignedObjectArray_Sl_btTypedConstraintFloatData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_constraintDataFloat_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_constraintDataFloat() (_swig_ret BtAlignedObjectArray_Sl_btTypedConstraintFloatData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btTypedConstraintFloatData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btTypedConstraintFloatData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btTypedConstraintFloatData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_constraintDataFloat_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_constraintDataDouble(arg2 BtAlignedObjectArray_Sl_btTypedConstraintDoubleData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_constraintDataDouble_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_constraintDataDouble() (_swig_ret BtAlignedObjectArray_Sl_btTypedConstraintDoubleData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btTypedConstraintDoubleData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btTypedConstraintDoubleData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btTypedConstraintDoubleData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_constraintDataDouble_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_constraintData(arg2 BtAlignedObjectArray_Sl_btTypedConstraintData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_constraintData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_constraintData() (_swig_ret BtAlignedObjectArray_Sl_btTypedConstraintData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btTypedConstraintData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btTypedConstraintData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btTypedConstraintData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_constraintData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_softBodyFloatData(arg2 BtAlignedObjectArray_Sl_btSoftBodyFloatData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_softBodyFloatData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_softBodyFloatData() (_swig_ret BtAlignedObjectArray_Sl_btSoftBodyFloatData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btSoftBodyFloatData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btSoftBodyFloatData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btSoftBodyFloatData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_softBodyFloatData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBulletSerializedArrays) SetM_softBodyDoubleData(arg2 BtAlignedObjectArray_Sl_btSoftBodyDoubleData_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBulletSerializedArrays_m_softBodyDoubleData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBulletSerializedArrays) GetM_softBodyDoubleData() (_swig_ret BtAlignedObjectArray_Sl_btSoftBodyDoubleData_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btSoftBodyDoubleData_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btSoftBodyDoubleData_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btSoftBodyDoubleData_Sm__Sg_(C._wrap_btBulletSerializedArrays_m_softBodyDoubleData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func DeleteBtBulletSerializedArrays(arg1 BtBulletSerializedArrays) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBulletSerializedArrays_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtBulletSerializedArrays interface { + Swigcptr() uintptr + SwigIsBtBulletSerializedArrays() + SetM_bvhsDouble(arg2 BtAlignedObjectArray_Sl_btQuantizedBvhDoubleData_Sm__Sg_) + GetM_bvhsDouble() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhDoubleData_Sm__Sg_) + SetM_bvhsFloat(arg2 BtAlignedObjectArray_Sl_btQuantizedBvhFloatData_Sm__Sg_) + GetM_bvhsFloat() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhFloatData_Sm__Sg_) + SetM_colShapeData(arg2 BtAlignedObjectArray_Sl_btCollisionShapeData_Sm__Sg_) + GetM_colShapeData() (_swig_ret BtAlignedObjectArray_Sl_btCollisionShapeData_Sm__Sg_) + SetM_dynamicWorldInfoDataDouble(arg2 BtAlignedObjectArray_Sl_btDynamicsWorldDoubleData_Sm__Sg_) + GetM_dynamicWorldInfoDataDouble() (_swig_ret BtAlignedObjectArray_Sl_btDynamicsWorldDoubleData_Sm__Sg_) + SetM_dynamicWorldInfoDataFloat(arg2 BtAlignedObjectArray_Sl_btDynamicsWorldFloatData_Sm__Sg_) + GetM_dynamicWorldInfoDataFloat() (_swig_ret BtAlignedObjectArray_Sl_btDynamicsWorldFloatData_Sm__Sg_) + SetM_rigidBodyDataDouble(arg2 BtAlignedObjectArray_Sl_btRigidBodyDoubleData_Sm__Sg_) + GetM_rigidBodyDataDouble() (_swig_ret BtAlignedObjectArray_Sl_btRigidBodyDoubleData_Sm__Sg_) + SetM_rigidBodyDataFloat(arg2 BtAlignedObjectArray_Sl_btRigidBodyFloatData_Sm__Sg_) + GetM_rigidBodyDataFloat() (_swig_ret BtAlignedObjectArray_Sl_btRigidBodyFloatData_Sm__Sg_) + SetM_collisionObjectDataDouble(arg2 BtAlignedObjectArray_Sl_btCollisionObjectDoubleData_Sm__Sg_) + GetM_collisionObjectDataDouble() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObjectDoubleData_Sm__Sg_) + SetM_collisionObjectDataFloat(arg2 BtAlignedObjectArray_Sl_btCollisionObjectFloatData_Sm__Sg_) + GetM_collisionObjectDataFloat() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObjectFloatData_Sm__Sg_) + SetM_constraintDataFloat(arg2 BtAlignedObjectArray_Sl_btTypedConstraintFloatData_Sm__Sg_) + GetM_constraintDataFloat() (_swig_ret BtAlignedObjectArray_Sl_btTypedConstraintFloatData_Sm__Sg_) + SetM_constraintDataDouble(arg2 BtAlignedObjectArray_Sl_btTypedConstraintDoubleData_Sm__Sg_) + GetM_constraintDataDouble() (_swig_ret BtAlignedObjectArray_Sl_btTypedConstraintDoubleData_Sm__Sg_) + SetM_constraintData(arg2 BtAlignedObjectArray_Sl_btTypedConstraintData_Sm__Sg_) + GetM_constraintData() (_swig_ret BtAlignedObjectArray_Sl_btTypedConstraintData_Sm__Sg_) + SetM_softBodyFloatData(arg2 BtAlignedObjectArray_Sl_btSoftBodyFloatData_Sm__Sg_) + GetM_softBodyFloatData() (_swig_ret BtAlignedObjectArray_Sl_btSoftBodyFloatData_Sm__Sg_) + SetM_softBodyDoubleData(arg2 BtAlignedObjectArray_Sl_btSoftBodyDoubleData_Sm__Sg_) + GetM_softBodyDoubleData() (_swig_ret BtAlignedObjectArray_Sl_btSoftBodyDoubleData_Sm__Sg_) +} + +type SwigcptrBtDefaultSerializer uintptr + +func (p SwigcptrBtDefaultSerializer) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDefaultSerializer) SwigIsBtDefaultSerializer() { +} + +func (arg1 SwigcptrBtDefaultSerializer) SetM_skipPointers(arg2 BtHashMap_Sl_btHashPtr_Sc_void_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDefaultSerializer_m_skipPointers_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultSerializer) GetM_skipPointers() (_swig_ret BtHashMap_Sl_btHashPtr_Sc_void_Sm__Sg_) { + var swig_r BtHashMap_Sl_btHashPtr_Sc_void_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtHashMap_Sl_btHashPtr_Sc_void_Sm__Sg_)(SwigcptrBtHashMap_Sl_btHashPtr_Sc_void_Sm__Sg_(C._wrap_btDefaultSerializer_m_skipPointers_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtDefaultSerializer__SWIG_0(arg1 int, arg2 *byte) (_swig_ret BtDefaultSerializer) { + var swig_r BtDefaultSerializer + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtDefaultSerializer)(SwigcptrBtDefaultSerializer(C._wrap_new_btDefaultSerializer__SWIG_0_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_voidp(_swig_i_1)))) + return swig_r +} + +func NewBtDefaultSerializer__SWIG_1(arg1 int) (_swig_ret BtDefaultSerializer) { + var swig_r BtDefaultSerializer + _swig_i_0 := arg1 + swig_r = (BtDefaultSerializer)(SwigcptrBtDefaultSerializer(C._wrap_new_btDefaultSerializer__SWIG_1_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0)))) + return swig_r +} + +func NewBtDefaultSerializer__SWIG_2() (_swig_ret BtDefaultSerializer) { + var swig_r BtDefaultSerializer + swig_r = (BtDefaultSerializer)(SwigcptrBtDefaultSerializer(C._wrap_new_btDefaultSerializer__SWIG_2_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtDefaultSerializer(a ...interface{}) BtDefaultSerializer { + argc := len(a) + if argc == 0 { + return NewBtDefaultSerializer__SWIG_2() + } + if argc == 1 { + return NewBtDefaultSerializer__SWIG_1(a[0].(int)) + } + if argc == 2 { + return NewBtDefaultSerializer__SWIG_0(a[0].(int), a[1].(*byte)) + } + panic("No match for overloaded function call") +} + +func DeleteBtDefaultSerializer(arg1 BtDefaultSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDefaultSerializer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func BtDefaultSerializerGetMemoryDnaSizeInBytes() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btDefaultSerializer_getMemoryDnaSizeInBytes_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtDefaultSerializerGetMemoryDna() (_swig_ret string) { + var swig_r string + swig_r_p := C._wrap_btDefaultSerializer_getMemoryDna_mbt_e879218550ba2e2b() + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtDefaultSerializer) InsertHeader() { + _swig_i_0 := arg1 + C._wrap_btDefaultSerializer_insertHeader_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDefaultSerializer) WriteHeader(arg2 *byte) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDefaultSerializer_writeHeader_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultSerializer) StartSerialization() { + _swig_i_0 := arg1 + C._wrap_btDefaultSerializer_startSerialization_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDefaultSerializer) FinishSerialization() { + _swig_i_0 := arg1 + C._wrap_btDefaultSerializer_finishSerialization_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDefaultSerializer) GetUniquePointer(arg2 uintptr) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (uintptr)(C._wrap_btDefaultSerializer_getUniquePointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultSerializer) GetBufferPointer() (_swig_ret *byte) { + var swig_r *byte + _swig_i_0 := arg1 + swig_r = (*byte)(C._wrap_btDefaultSerializer_getBufferPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultSerializer) GetCurrentBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDefaultSerializer_getCurrentBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultSerializer) FinalizeChunk(arg2 BtChunk, arg3 string, arg4 int, arg5 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btDefaultSerializer_finalizeChunk_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), *(*C.swig_type_83)(unsafe.Pointer(&_swig_i_2)), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4)) + if Swig_escape_always_false { + Swig_escape_val = arg3 + } +} + +func (arg1 SwigcptrBtDefaultSerializer) InternalAlloc(arg2 int64) (_swig_ret *byte) { + var swig_r *byte + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (*byte)(C._wrap_btDefaultSerializer_internalAlloc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_84(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultSerializer) Allocate(arg2 int64, arg3 int) (_swig_ret BtChunk) { + var swig_r BtChunk + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtChunk)(SwigcptrBtChunk(C._wrap_btDefaultSerializer_allocate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_85(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultSerializer) FindNameForPointer(arg2 uintptr) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r_p := C._wrap_btDefaultSerializer_findNameForPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtDefaultSerializer) RegisterNameForPointer(arg2 uintptr, arg3 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btDefaultSerializer_registerNameForPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), *(*C.swig_type_87)(unsafe.Pointer(&_swig_i_2))) + if Swig_escape_always_false { + Swig_escape_val = arg3 + } +} + +func (arg1 SwigcptrBtDefaultSerializer) SerializeName(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDefaultSerializer_serializeName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_88)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtDefaultSerializer) GetSerializationFlags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDefaultSerializer_getSerializationFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultSerializer) SetSerializationFlags(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDefaultSerializer_setSerializationFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultSerializer) GetNumChunks() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDefaultSerializer_getNumChunks_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultSerializer) GetChunk(arg2 int) (_swig_ret BtChunk) { + var swig_r BtChunk + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtChunk)(SwigcptrBtChunk(C._wrap_btDefaultSerializer_getChunk_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (_swig_base SwigcptrBtDefaultSerializer) FindPointer(arg1 uintptr) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btDefaultSerializer_findPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (p SwigcptrBtDefaultSerializer) SwigIsBtSerializer() { +} + +func (p SwigcptrBtDefaultSerializer) SwigGetBtSerializer() BtSerializer { + return SwigcptrBtSerializer(getSwigcptr(p)) +} + +type BtDefaultSerializer interface { + Swigcptr() uintptr + SwigIsBtDefaultSerializer() + SetM_skipPointers(arg2 BtHashMap_Sl_btHashPtr_Sc_void_Sm__Sg_) + GetM_skipPointers() (_swig_ret BtHashMap_Sl_btHashPtr_Sc_void_Sm__Sg_) + InsertHeader() + WriteHeader(arg2 *byte) + StartSerialization() + FinishSerialization() + GetUniquePointer(arg2 uintptr) (_swig_ret uintptr) + GetBufferPointer() (_swig_ret *byte) + GetCurrentBufferSize() (_swig_ret int) + FinalizeChunk(arg2 BtChunk, arg3 string, arg4 int, arg5 uintptr) + InternalAlloc(arg2 int64) (_swig_ret *byte) + Allocate(arg2 int64, arg3 int) (_swig_ret BtChunk) + FindNameForPointer(arg2 uintptr) (_swig_ret string) + RegisterNameForPointer(arg2 uintptr, arg3 string) + SerializeName(arg2 string) + GetSerializationFlags() (_swig_ret int) + SetSerializationFlags(arg2 int) + GetNumChunks() (_swig_ret int) + GetChunk(arg2 int) (_swig_ret BtChunk) + FindPointer(arg1 uintptr) (_swig_ret uintptr) + SwigIsBtSerializer() + SwigGetBtSerializer() BtSerializer +} + +func SetUniqueId(arg1 int) { + _swig_i_0 := arg1 + C._wrap_uniqueId_set_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0)) +} + +func GetUniqueId() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_uniqueId_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func EvalEulerEqn(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtMatrix3x3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_evalEulerEqn_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4)))) + return swig_r +} + +func EvalEulerEqnDeriv(arg1 BtVector3, arg2 BtVector3, arg3 float32, arg4 BtMatrix3x3) (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_evalEulerEqnDeriv_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +const DBVT_IMPL_GENERIC int = 0 +const DBVT_IMPL_SSE int = 1 +const DBVT_USE_TEMPLATE int = 0 +const DBVT_USE_INTRINSIC_SSE int = 1 +const DBVT_USE_MEMMOVE int = 1 +const DBVT_ENABLE_BENCHMARK int = 0 +const DBVT_SELECT_IMPL int = 0 +const DBVT_MERGE_IMPL int = 0 +const DBVT_INT0_IMPL int = 0 + +type SwigcptrBtDbvtAabbMm uintptr + +func (p SwigcptrBtDbvtAabbMm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDbvtAabbMm) SwigIsBtDbvtAabbMm() { +} + +func NewBtDbvtAabbMm() (_swig_ret BtDbvtAabbMm) { + var swig_r BtDbvtAabbMm + swig_r = (BtDbvtAabbMm)(SwigcptrBtDbvtAabbMm(C._wrap_new_btDbvtAabbMm_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtDbvtAabbMm) Center() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btDbvtAabbMm_Center_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtAabbMm) Lengths() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btDbvtAabbMm_Lengths_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtAabbMm) Extents() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btDbvtAabbMm_Extents_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtAabbMm) Mins() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btDbvtAabbMm_Mins_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtAabbMm) Maxs() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btDbvtAabbMm_Maxs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func BtDbvtAabbMmFromCE(arg1 BtVector3, arg2 BtVector3) (_swig_ret BtDbvtAabbMm) { + var swig_r BtDbvtAabbMm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtDbvtAabbMm)(SwigcptrBtDbvtAabbMm(C._wrap_btDbvtAabbMm_FromCE_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func BtDbvtAabbMmFromCR(arg1 BtVector3, arg2 float32) (_swig_ret BtDbvtAabbMm) { + var swig_r BtDbvtAabbMm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtDbvtAabbMm)(SwigcptrBtDbvtAabbMm(C._wrap_btDbvtAabbMm_FromCR_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func BtDbvtAabbMmFromMM(arg1 BtVector3, arg2 BtVector3) (_swig_ret BtDbvtAabbMm) { + var swig_r BtDbvtAabbMm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtDbvtAabbMm)(SwigcptrBtDbvtAabbMm(C._wrap_btDbvtAabbMm_FromMM_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func BtDbvtAabbMmFromPoints__SWIG_0(arg1 BtVector3, arg2 int) (_swig_ret BtDbvtAabbMm) { + var swig_r BtDbvtAabbMm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtDbvtAabbMm)(SwigcptrBtDbvtAabbMm(C._wrap_btDbvtAabbMm_FromPoints__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func BtDbvtAabbMmFromPoints__SWIG_1(arg1 BtVector3, arg2 int) (_swig_ret BtDbvtAabbMm) { + var swig_r BtDbvtAabbMm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtDbvtAabbMm)(SwigcptrBtDbvtAabbMm(C._wrap_btDbvtAabbMm_FromPoints__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func BtDbvtAabbMmFromPoints(a ...interface{}) BtDbvtAabbMm { + argc := len(a) + if argc == 2 { + return BtDbvtAabbMmFromPoints__SWIG_0(a[0].(BtVector3), a[1].(int)) + } + if argc == 2 { + return BtDbvtAabbMmFromPoints__SWIG_1(a[0].(BtVector3), a[1].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDbvtAabbMm) Expand(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtAabbMm_Expand_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtAabbMm) SignedExpand(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtAabbMm_SignedExpand_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtAabbMm) Contain(arg2 BtDbvtAabbMm) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btDbvtAabbMm_Contain_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtAabbMm) Classify(arg2 BtVector3, arg3 float32, arg4 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (int)(C._wrap_btDbvtAabbMm_Classify_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtAabbMm) ProjectMinimum(arg2 BtVector3, arg3 uint) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btDbvtAabbMm_ProjectMinimum_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func Intersect__SWIG_0(arg1 BtDbvtAabbMm, arg2 BtDbvtAabbMm) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_Intersect__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func Intersect__SWIG_1(arg1 BtDbvtAabbMm, arg2 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_Intersect__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func Intersect(a ...interface{}) bool { + argc := len(a) + if argc == 2 { + if _, ok := a[1].(BtDbvtAabbMm); !ok { + goto check_1 + } + return Intersect__SWIG_0(a[0].(BtDbvtAabbMm), a[1].(BtDbvtAabbMm)) + } +check_1: + if argc == 2 { + return Intersect__SWIG_1(a[0].(BtDbvtAabbMm), a[1].(BtVector3)) + } + panic("No match for overloaded function call") +} + +func Proximity(arg1 BtDbvtAabbMm, arg2 BtDbvtAabbMm) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_Proximity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func Select(arg1 BtDbvtAabbMm, arg2 BtDbvtAabbMm, arg3 BtDbvtAabbMm) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (int)(C._wrap_Select_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func Merge(arg1 BtDbvtAabbMm, arg2 BtDbvtAabbMm, arg3 BtDbvtAabbMm) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_Merge_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func NotEqual(arg1 BtDbvtAabbMm, arg2 BtDbvtAabbMm) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_NotEqual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtAabbMm) TMins() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btDbvtAabbMm_tMins_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtAabbMm) TMaxs() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btDbvtAabbMm_tMaxs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func DeleteBtDbvtAabbMm(arg1 BtDbvtAabbMm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDbvtAabbMm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtDbvtAabbMm interface { + Swigcptr() uintptr + SwigIsBtDbvtAabbMm() + Center() (_swig_ret BtVector3) + Lengths() (_swig_ret BtVector3) + Extents() (_swig_ret BtVector3) + Mins() (_swig_ret BtVector3) + Maxs() (_swig_ret BtVector3) + Expand(arg2 BtVector3) + SignedExpand(arg2 BtVector3) + Contain(arg2 BtDbvtAabbMm) (_swig_ret bool) + Classify(arg2 BtVector3, arg3 float32, arg4 int) (_swig_ret int) + ProjectMinimum(arg2 BtVector3, arg3 uint) (_swig_ret float32) + TMins() (_swig_ret BtVector3) + TMaxs() (_swig_ret BtVector3) +} + +type SwigcptrBtDbvtNode uintptr + +func (p SwigcptrBtDbvtNode) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDbvtNode) SwigIsBtDbvtNode() { +} + +func (arg1 SwigcptrBtDbvtNode) SetVolume(arg2 BtDbvtAabbMm) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtNode_volume_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtNode) GetVolume() (_swig_ret BtDbvtAabbMm) { + var swig_r BtDbvtAabbMm + _swig_i_0 := arg1 + swig_r = (BtDbvtAabbMm)(SwigcptrBtDbvtAabbMm(C._wrap_btDbvtNode_volume_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtNode) SetParent(arg2 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtNode_parent_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtNode) GetParent() (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := arg1 + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_btDbvtNode_parent_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtNode) Isleaf() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtNode_isleaf_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtNode) Isinternal() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtNode_isinternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtDbvtNode() (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_new_btDbvtNode_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtDbvtNode(arg1 BtDbvtNode) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDbvtNode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtDbvtNode interface { + Swigcptr() uintptr + SwigIsBtDbvtNode() + SetVolume(arg2 BtDbvtAabbMm) + GetVolume() (_swig_ret BtDbvtAabbMm) + SetParent(arg2 BtDbvtNode) + GetParent() (_swig_ret BtDbvtNode) + Isleaf() (_swig_ret bool) + Isinternal() (_swig_ret bool) +} + +type SwigcptrBtDbvntNode uintptr + +func (p SwigcptrBtDbvntNode) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDbvntNode) SwigIsBtDbvntNode() { +} + +func (arg1 SwigcptrBtDbvntNode) SetVolume(arg2 BtDbvtAabbMm) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvntNode_volume_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvntNode) GetVolume() (_swig_ret BtDbvtAabbMm) { + var swig_r BtDbvtAabbMm + _swig_i_0 := arg1 + swig_r = (BtDbvtAabbMm)(SwigcptrBtDbvtAabbMm(C._wrap_btDbvntNode_volume_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvntNode) SetNormal(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvntNode_normal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvntNode) GetNormal() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btDbvntNode_normal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvntNode) SetAngle(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvntNode_angle_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvntNode) GetAngle() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btDbvntNode_angle_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvntNode) Isleaf() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvntNode_isleaf_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvntNode) Isinternal() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvntNode_isinternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvntNode) SetChilds(arg2 BtDbvntNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvntNode_childs_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvntNode) GetChilds() (_swig_ret BtDbvntNode) { + var swig_r BtDbvntNode + _swig_i_0 := arg1 + swig_r = (BtDbvntNode)(SwigcptrBtDbvntNode(C._wrap_btDbvntNode_childs_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvntNode) SetData(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvntNode_data_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvntNode) GetData() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btDbvntNode_data_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtDbvntNode(arg1 BtDbvtNode) (_swig_ret BtDbvntNode) { + var swig_r BtDbvntNode + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtDbvntNode)(SwigcptrBtDbvntNode(C._wrap_new_btDbvntNode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func DeleteBtDbvntNode(arg1 BtDbvntNode) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDbvntNode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtDbvntNode interface { + Swigcptr() uintptr + SwigIsBtDbvntNode() + SetVolume(arg2 BtDbvtAabbMm) + GetVolume() (_swig_ret BtDbvtAabbMm) + SetNormal(arg2 BtVector3) + GetNormal() (_swig_ret BtVector3) + SetAngle(arg2 float32) + GetAngle() (_swig_ret float32) + Isleaf() (_swig_ret bool) + Isinternal() (_swig_ret bool) + SetChilds(arg2 BtDbvntNode) + GetChilds() (_swig_ret BtDbvntNode) + SetData(arg2 uintptr) + GetData() (_swig_ret uintptr) +} + +type SwigcptrBtDbvt uintptr + +func (p SwigcptrBtDbvt) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDbvt) SwigIsBtDbvt() { +} + +func _swig_getbtDbvt_SIMPLE_STACKSIZE_btDbvt() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_SIMPLE_STACKSIZE_btDbvt_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtDbvtSIMPLE_STACKSIZE int = _swig_getbtDbvt_SIMPLE_STACKSIZE_btDbvt() + +func _swig_getbtDbvt_DOUBLE_STACKSIZE_btDbvt() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_DOUBLE_STACKSIZE_btDbvt_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtDbvtDOUBLE_STACKSIZE int = _swig_getbtDbvt_DOUBLE_STACKSIZE_btDbvt() + +func (arg1 SwigcptrBtDbvt) SetM_root(arg2 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_m_root_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) GetM_root() (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := arg1 + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_btDbvt_m_root_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvt) SetM_free(arg2 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_m_free_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) GetM_free() (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := arg1 + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_btDbvt_m_free_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvt) SetM_lkhd(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvt_m_lkhd_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) GetM_lkhd() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvt_m_lkhd_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvt) SetM_leaves(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvt_m_leaves_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) GetM_leaves() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvt_m_leaves_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvt) SetM_opath(arg2 uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvt_m_opath_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) GetM_opath() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btDbvt_m_opath_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvt) SetM_stkStack(arg2 BtAlignedObjectArray_Sl_btDbvt_sStkNN_Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_m_stkStack_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) GetM_stkStack() (_swig_ret BtAlignedObjectArray_Sl_btDbvt_sStkNN_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btDbvt_sStkNN_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btDbvt_sStkNN_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btDbvt_sStkNN_Sg_(C._wrap_btDbvt_m_stkStack_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtDbvt() (_swig_ret BtDbvt) { + var swig_r BtDbvt + swig_r = (BtDbvt)(SwigcptrBtDbvt(C._wrap_new_btDbvt_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtDbvt(arg1 BtDbvt) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDbvt_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDbvt) Clear() { + _swig_i_0 := arg1 + C._wrap_btDbvt_clear_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDbvt) Empty() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvt_empty_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvt) OptimizeBottomUp() { + _swig_i_0 := arg1 + C._wrap_btDbvt_optimizeBottomUp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDbvt) OptimizeTopDown__SWIG_0(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvt_optimizeTopDown__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) OptimizeTopDown__SWIG_1() { + _swig_i_0 := arg1 + C._wrap_btDbvt_optimizeTopDown__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtDbvt) OptimizeTopDown(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.OptimizeTopDown__SWIG_1() + return + } + if argc == 1 { + p.OptimizeTopDown__SWIG_0(a[0].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDbvt) OptimizeIncremental(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvt_optimizeIncremental_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) Insert(arg2 BtDbvtAabbMm, arg3 uintptr) (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_btDbvt_insert_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvt) Update__SWIG_0(arg2 BtDbvtNode, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btDbvt_update__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtDbvt) Update__SWIG_1(arg2 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_update__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) Update__SWIG_2(arg2 BtDbvtNode, arg3 BtDbvtAabbMm) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDbvt_update__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtDbvt) Update__SWIG_3(arg2 BtDbvtNode, arg3 BtDbvtAabbMm, arg4 BtVector3, arg5 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (bool)(C._wrap_btDbvt_update__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtDbvt) Update__SWIG_4(arg2 BtDbvtNode, arg3 BtDbvtAabbMm, arg4 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (bool)(C._wrap_btDbvt_update__SWIG_4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtDbvt) Update__SWIG_5(arg2 BtDbvtNode, arg3 BtDbvtAabbMm, arg4 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + swig_r = (bool)(C._wrap_btDbvt_update__SWIG_5_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3))) + return swig_r +} + +func (p SwigcptrBtDbvt) Update(a ...interface{}) interface{} { + argc := len(a) + if argc == 1 { + p.Update__SWIG_1(a[0].(BtDbvtNode)) + return 0 + } + if argc == 2 { + if _, ok := a[1].(BtDbvtAabbMm); !ok { + goto check_2 + } + p.Update__SWIG_2(a[0].(BtDbvtNode), a[1].(BtDbvtAabbMm)) + return 0 + } +check_2: + if argc == 2 { + p.Update__SWIG_0(a[0].(BtDbvtNode), a[1].(int)) + return 0 + } + if argc == 3 { + if _, ok := a[2].(BtVector3); !ok { + goto check_4 + } + return p.Update__SWIG_4(a[0].(BtDbvtNode), a[1].(BtDbvtAabbMm), a[2].(BtVector3)) + } +check_4: + if argc == 3 { + return p.Update__SWIG_5(a[0].(BtDbvtNode), a[1].(BtDbvtAabbMm), a[2].(float32)) + } + if argc == 4 { + return p.Update__SWIG_3(a[0].(BtDbvtNode), a[1].(BtDbvtAabbMm), a[2].(BtVector3), a[3].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDbvt) Remove(arg2 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_remove_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) Write(arg2 BtDbvt_IWriter) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_write_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) Clone__SWIG_0(arg2 BtDbvt, arg3 BtDbvt_IClone) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDbvt_clone__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtDbvt) Clone__SWIG_1(arg2 BtDbvt) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_clone__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtDbvt) Clone(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.Clone__SWIG_1(a[0].(BtDbvt)) + return + } + if argc == 2 { + p.Clone__SWIG_0(a[0].(BtDbvt), a[1].(BtDbvt_IClone)) + return + } + panic("No match for overloaded function call") +} + +func BtDbvtMaxdepth(arg1 BtDbvtNode) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + swig_r = (int)(C._wrap_btDbvt_maxdepth_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func BtDbvtCountLeaves(arg1 BtDbvtNode) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + swig_r = (int)(C._wrap_btDbvt_countLeaves_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func BtDbvtExtractLeaves(arg1 BtDbvtNode, arg2 BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_extractLeaves_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func BtDbvtBenchmark() { + C._wrap_btDbvt_benchmark_mbt_e879218550ba2e2b() +} + +func BtDbvtEnumNodes(arg1 BtDbvtNode, arg2 BtDbvt_ICollide) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_enumNodes_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func BtDbvtEnumLeaves(arg1 BtDbvtNode, arg2 BtDbvt_ICollide) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_enumLeaves_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvt) CollideTT(arg2 BtDbvtNode, arg3 BtDbvtNode, arg4 BtDbvt_ICollide) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDbvt_collideTT_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtDbvt) SelfCollideT(arg2 BtDbvntNode, arg3 BtDbvt_ICollide) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDbvt_selfCollideT_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtDbvt) SelfCollideTT(arg2 BtDbvtNode, arg3 BtDbvt_ICollide) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDbvt_selfCollideTT_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtDbvt) CollideTTpersistentStack(arg2 BtDbvtNode, arg3 BtDbvtNode, arg4 BtDbvt_ICollide) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDbvt_collideTTpersistentStack_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtDbvt) CollideTV(arg2 BtDbvtNode, arg3 BtDbvtAabbMm, arg4 BtDbvt_ICollide) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDbvt_collideTV_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtDbvt) CollideTVNoStackAlloc(arg2 BtDbvtNode, arg3 BtDbvtAabbMm, arg4 BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_, arg5 BtDbvt_ICollide) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btDbvt_collideTVNoStackAlloc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func BtDbvtRayTest(arg1 BtDbvtNode, arg2 BtVector3, arg3 BtVector3, arg4 BtDbvt_ICollide) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDbvt_rayTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtDbvt) RayTestInternal(arg2 BtDbvtNode, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 *uint, arg7 float32, arg8 BtVector3, arg9 BtVector3, arg10 BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_, arg11 BtDbvt_ICollide) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := getSwigcptr(arg10) + _swig_i_10 := getSwigcptr(arg11) + C._wrap_btDbvt_rayTestInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.swig_voidp(_swig_i_5), C.float(_swig_i_6), C.uintptr_t(_swig_i_7), C.uintptr_t(_swig_i_8), C.uintptr_t(_swig_i_9), C.uintptr_t(_swig_i_10)) +} + +func BtDbvtCollideKDOP(arg1 BtDbvtNode, arg2 BtVector3, arg3 *float32, arg4 int, arg5 BtDbvt_ICollide) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btDbvt_collideKDOP_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func BtDbvtCollideOCL__SWIG_0(arg1 BtDbvtNode, arg2 BtVector3, arg3 *float32, arg4 BtVector3, arg5 int, arg6 BtDbvt_ICollide, arg7 bool) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := arg7 + C._wrap_btDbvt_collideOCL__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_intgo(_swig_i_4), C.uintptr_t(_swig_i_5), C._Bool(_swig_i_6)) +} + +func BtDbvtCollideOCL__SWIG_1(arg1 BtDbvtNode, arg2 BtVector3, arg3 *float32, arg4 BtVector3, arg5 int, arg6 BtDbvt_ICollide) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btDbvt_collideOCL__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_intgo(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func BtDbvtCollideOCL(a ...interface{}) { + argc := len(a) + if argc == 6 { + BtDbvtCollideOCL__SWIG_1(a[0].(BtDbvtNode), a[1].(BtVector3), a[2].(*float32), a[3].(BtVector3), a[4].(int), a[5].(BtDbvt_ICollide)) + return + } + if argc == 7 { + BtDbvtCollideOCL__SWIG_0(a[0].(BtDbvtNode), a[1].(BtVector3), a[2].(*float32), a[3].(BtVector3), a[4].(int), a[5].(BtDbvt_ICollide), a[6].(bool)) + return + } + panic("No match for overloaded function call") +} + +func BtDbvtCollideTU(arg1 BtDbvtNode, arg2 BtDbvt_ICollide) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvt_collideTU_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func BtDbvtNearest(arg1 *int, arg2 BtDbvt_sStkNPS, arg3 float32, arg4 int, arg5 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + swig_r = (int)(C._wrap_btDbvt_nearest_mbt_e879218550ba2e2b(C.swig_voidp(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3), C.swig_intgo(_swig_i_4))) + return swig_r +} + +func BtDbvtAllocate(arg1 BtAlignedObjectArray_Sl_int_Sg_, arg2 BtAlignedObjectArray_Sl_btDbvt_sStkNPS_Sg_, arg3 BtDbvt_sStkNPS) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (int)(C._wrap_btDbvt_allocate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +type BtDbvt interface { + Swigcptr() uintptr + SwigIsBtDbvt() + SetM_root(arg2 BtDbvtNode) + GetM_root() (_swig_ret BtDbvtNode) + SetM_free(arg2 BtDbvtNode) + GetM_free() (_swig_ret BtDbvtNode) + SetM_lkhd(arg2 int) + GetM_lkhd() (_swig_ret int) + SetM_leaves(arg2 int) + GetM_leaves() (_swig_ret int) + SetM_opath(arg2 uint) + GetM_opath() (_swig_ret uint) + SetM_stkStack(arg2 BtAlignedObjectArray_Sl_btDbvt_sStkNN_Sg_) + GetM_stkStack() (_swig_ret BtAlignedObjectArray_Sl_btDbvt_sStkNN_Sg_) + Clear() + Empty() (_swig_ret bool) + OptimizeBottomUp() + OptimizeTopDown(a ...interface{}) + OptimizeIncremental(arg2 int) + Insert(arg2 BtDbvtAabbMm, arg3 uintptr) (_swig_ret BtDbvtNode) + Update(a ...interface{}) interface{} + Remove(arg2 BtDbvtNode) + Write(arg2 BtDbvt_IWriter) + Clone(a ...interface{}) + CollideTT(arg2 BtDbvtNode, arg3 BtDbvtNode, arg4 BtDbvt_ICollide) + SelfCollideT(arg2 BtDbvntNode, arg3 BtDbvt_ICollide) + SelfCollideTT(arg2 BtDbvtNode, arg3 BtDbvt_ICollide) + CollideTTpersistentStack(arg2 BtDbvtNode, arg3 BtDbvtNode, arg4 BtDbvt_ICollide) + CollideTV(arg2 BtDbvtNode, arg3 BtDbvtAabbMm, arg4 BtDbvt_ICollide) + CollideTVNoStackAlloc(arg2 BtDbvtNode, arg3 BtDbvtAabbMm, arg4 BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_, arg5 BtDbvt_ICollide) + RayTestInternal(arg2 BtDbvtNode, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 *uint, arg7 float32, arg8 BtVector3, arg9 BtVector3, arg10 BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_, arg11 BtDbvt_ICollide) +} + +type SwigcptrBtDbvtNodeEnumerator uintptr + +func (p SwigcptrBtDbvtNodeEnumerator) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDbvtNodeEnumerator) SwigIsBtDbvtNodeEnumerator() { +} + +func (arg1 SwigcptrBtDbvtNodeEnumerator) SetNodes(arg2 BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtNodeEnumerator_nodes_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtNodeEnumerator) GetNodes() (_swig_ret BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_(C._wrap_btDbvtNodeEnumerator_nodes_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtNodeEnumerator) Process(arg2 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtNodeEnumerator_Process_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func NewBtDbvtNodeEnumerator() (_swig_ret BtDbvtNodeEnumerator) { + var swig_r BtDbvtNodeEnumerator + swig_r = (BtDbvtNodeEnumerator)(SwigcptrBtDbvtNodeEnumerator(C._wrap_new_btDbvtNodeEnumerator_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtDbvtNodeEnumerator(arg1 BtDbvtNodeEnumerator) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDbvtNodeEnumerator_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtDbvtNodeEnumerator interface { + Swigcptr() uintptr + SwigIsBtDbvtNodeEnumerator() + SetNodes(arg2 BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_) + GetNodes() (_swig_ret BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_) + Process(arg2 BtDbvtNode) +} + +func Indexof(arg1 BtDbvtNode) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + swig_r = (int)(C._wrap_indexof_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func Size(arg1 BtDbvtAabbMm) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (float32)(C._wrap_size_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func Getmaxdepth(arg1 BtDbvtNode, arg2 int, arg3 *int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_getmaxdepth_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_voidp(_swig_i_2)) +} + +func Deletenode(arg1 BtDbvt, arg2 BtDbvtNode) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_deletenode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func Recursedeletenode(arg1 BtDbvt, arg2 BtDbvtNode) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_recursedeletenode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func Createnode__SWIG_0(arg1 BtDbvt, arg2 BtDbvtNode, arg3 uintptr) (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_createnode__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func Createnode__SWIG_1(arg1 BtDbvt, arg2 BtDbvtNode, arg3 BtDbvtAabbMm, arg4 uintptr) (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_createnode__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func Createnode__SWIG_2(arg1 BtDbvt, arg2 BtDbvtNode, arg3 BtDbvtAabbMm, arg4 BtDbvtAabbMm, arg5 uintptr) (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_createnode__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)))) + return swig_r +} + +func Createnode(a ...interface{}) BtDbvtNode { + argc := len(a) + if argc == 3 { + return Createnode__SWIG_0(a[0].(BtDbvt), a[1].(BtDbvtNode), a[2].(uintptr)) + } + if argc == 4 { + return Createnode__SWIG_1(a[0].(BtDbvt), a[1].(BtDbvtNode), a[2].(BtDbvtAabbMm), a[3].(uintptr)) + } + if argc == 5 { + return Createnode__SWIG_2(a[0].(BtDbvt), a[1].(BtDbvtNode), a[2].(BtDbvtAabbMm), a[3].(BtDbvtAabbMm), a[4].(uintptr)) + } + panic("No match for overloaded function call") +} + +func Insertleaf(arg1 BtDbvt, arg2 BtDbvtNode, arg3 BtDbvtNode) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_insertleaf_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func Removeleaf(arg1 BtDbvt, arg2 BtDbvtNode) (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_removeleaf_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func Fetchleaves__SWIG_0(arg1 BtDbvt, arg2 BtDbvtNode, arg3 BtAlignedObjectArray_Sl_btDbvtNode_Sm__Sg_, arg4 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_fetchleaves__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func Fetchleaves__SWIG_1(arg1 BtDbvt, arg2 BtDbvtNode, arg3 BtAlignedObjectArray_Sl_btDbvtNode_Sm__Sg_) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_fetchleaves__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func Fetchleaves(a ...interface{}) { + argc := len(a) + if argc == 3 { + Fetchleaves__SWIG_1(a[0].(BtDbvt), a[1].(BtDbvtNode), a[2].(BtAlignedObjectArray_Sl_btDbvtNode_Sm__Sg_)) + return + } + if argc == 4 { + Fetchleaves__SWIG_0(a[0].(BtDbvt), a[1].(BtDbvtNode), a[2].(BtAlignedObjectArray_Sl_btDbvtNode_Sm__Sg_), a[3].(int)) + return + } + panic("No match for overloaded function call") +} + +func LeftOfAxis(arg1 BtDbvtNode, arg2 BtVector3, arg3 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_leftOfAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func Split(arg1 BtDbvtNode, arg2 int, arg3 BtVector3, arg4 BtVector3) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (int)(C._wrap_split_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +func Bounds(arg1 BtDbvtNode, arg2 int) (_swig_ret BtDbvtAabbMm) { + var swig_r BtDbvtAabbMm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtDbvtAabbMm)(SwigcptrBtDbvtAabbMm(C._wrap_bounds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func Bottomup(arg1 BtDbvt, arg2 BtDbvtNode, arg3 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_bottomup_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func Topdown(arg1 BtDbvt, arg2 BtDbvtNode, arg3 int, arg4 int) (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_topdown_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)))) + return swig_r +} + +func Sort(arg1 BtDbvtNode, arg2 BtDbvtNode) (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_sort_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +type SwigcptrBtBroadphaseAabbCallback uintptr + +func (p SwigcptrBtBroadphaseAabbCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBroadphaseAabbCallback) SwigIsBtBroadphaseAabbCallback() { +} + +func DeleteBtBroadphaseAabbCallback(arg1 BtBroadphaseAabbCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBroadphaseAabbCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtBroadphaseAabbCallback) Process(arg2 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btBroadphaseAabbCallback_process_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +type BtBroadphaseAabbCallback interface { + Swigcptr() uintptr + SwigIsBtBroadphaseAabbCallback() + Process(arg2 BtBroadphaseProxy) (_swig_ret bool) +} + +type SwigcptrBtBroadphaseRayCallback uintptr + +func (p SwigcptrBtBroadphaseRayCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBroadphaseRayCallback) SwigIsBtBroadphaseRayCallback() { +} + +func (arg1 SwigcptrBtBroadphaseRayCallback) SetM_rayDirectionInverse(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBroadphaseRayCallback_m_rayDirectionInverse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseRayCallback) GetM_rayDirectionInverse() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBroadphaseRayCallback_m_rayDirectionInverse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphaseRayCallback) SetM_signs(arg2 *uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBroadphaseRayCallback_m_signs_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseRayCallback) GetM_signs() (_swig_ret *uint) { + var swig_r *uint + _swig_i_0 := arg1 + swig_r = (*uint)(C._wrap_btBroadphaseRayCallback_m_signs_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphaseRayCallback) SetM_lambda_max(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBroadphaseRayCallback_m_lambda_max_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseRayCallback) GetM_lambda_max() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btBroadphaseRayCallback_m_lambda_max_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtBroadphaseRayCallback(arg1 BtBroadphaseRayCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBroadphaseRayCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBroadphaseRayCallback) Process(arg1 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + swig_r = (bool)(C._wrap_btBroadphaseRayCallback_process_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (p SwigcptrBtBroadphaseRayCallback) SwigIsBtBroadphaseAabbCallback() { +} + +func (p SwigcptrBtBroadphaseRayCallback) SwigGetBtBroadphaseAabbCallback() BtBroadphaseAabbCallback { + return SwigcptrBtBroadphaseAabbCallback(getSwigcptr(p)) +} + +type BtBroadphaseRayCallback interface { + Swigcptr() uintptr + SwigIsBtBroadphaseRayCallback() + SetM_rayDirectionInverse(arg2 BtVector3) + GetM_rayDirectionInverse() (_swig_ret BtVector3) + SetM_signs(arg2 *uint) + GetM_signs() (_swig_ret *uint) + SetM_lambda_max(arg2 float32) + GetM_lambda_max() (_swig_ret float32) + Process(arg1 BtBroadphaseProxy) (_swig_ret bool) + SwigIsBtBroadphaseAabbCallback() + SwigGetBtBroadphaseAabbCallback() BtBroadphaseAabbCallback +} + +type SwigcptrBtBroadphaseInterface uintptr + +func (p SwigcptrBtBroadphaseInterface) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBroadphaseInterface) SwigIsBtBroadphaseInterface() { +} + +func DeleteBtBroadphaseInterface(arg1 BtBroadphaseInterface) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBroadphaseInterface_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtBroadphaseInterface) CreateProxy(arg2 BtVector3, arg3 BtVector3, arg4 int, arg5 uintptr, arg6 int, arg7 int, arg8 BtDispatcher) (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := getSwigcptr(arg8) + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_btBroadphaseInterface_createProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4), C.swig_intgo(_swig_i_5), C.swig_intgo(_swig_i_6), C.uintptr_t(_swig_i_7)))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphaseInterface) DestroyProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBroadphaseInterface_destroyProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtBroadphaseInterface) SetAabb(arg2 BtBroadphaseProxy, arg3 BtVector3, arg4 BtVector3, arg5 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btBroadphaseInterface_setAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtBroadphaseInterface) GetAabb(arg2 BtBroadphaseProxy, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btBroadphaseInterface_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtBroadphaseInterface) RayTest__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtBroadphaseRayCallback, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btBroadphaseInterface_rayTest__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtBroadphaseInterface) RayTest__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtBroadphaseRayCallback, arg5 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btBroadphaseInterface_rayTest__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtBroadphaseInterface) RayTest__SWIG_2(arg2 BtVector3, arg3 BtVector3, arg4 BtBroadphaseRayCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btBroadphaseInterface_rayTest__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtBroadphaseInterface) RayTest(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.RayTest__SWIG_2(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtBroadphaseRayCallback)) + return + } + if argc == 4 { + p.RayTest__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtBroadphaseRayCallback), a[3].(BtVector3)) + return + } + if argc == 5 { + p.RayTest__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtBroadphaseRayCallback), a[3].(BtVector3), a[4].(BtVector3)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtBroadphaseInterface) AabbTest(arg2 BtVector3, arg3 BtVector3, arg4 BtBroadphaseAabbCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btBroadphaseInterface_aabbTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtBroadphaseInterface) CalculateOverlappingPairs(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBroadphaseInterface_calculateOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseInterface) GetOverlappingPairCache__SWIG_0() (_swig_ret BtOverlappingPairCache) { + var swig_r BtOverlappingPairCache + _swig_i_0 := arg1 + swig_r = (BtOverlappingPairCache)(SwigcptrBtOverlappingPairCache(C._wrap_btBroadphaseInterface_getOverlappingPairCache__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBroadphaseInterface) GetOverlappingPairCache__SWIG_1() (_swig_ret BtOverlappingPairCache) { + var swig_r BtOverlappingPairCache + _swig_i_0 := arg1 + swig_r = (BtOverlappingPairCache)(SwigcptrBtOverlappingPairCache(C._wrap_btBroadphaseInterface_getOverlappingPairCache__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtBroadphaseInterface) GetOverlappingPairCache(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOverlappingPairCache__SWIG_0() + } + if argc == 0 { + return p.GetOverlappingPairCache__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtBroadphaseInterface) GetBroadphaseAabb(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBroadphaseInterface_getBroadphaseAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtBroadphaseInterface) ResetPool(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBroadphaseInterface_resetPool_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBroadphaseInterface) PrintStats() { + _swig_i_0 := arg1 + C._wrap_btBroadphaseInterface_printStats_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtBroadphaseInterface interface { + Swigcptr() uintptr + SwigIsBtBroadphaseInterface() + CreateProxy(arg2 BtVector3, arg3 BtVector3, arg4 int, arg5 uintptr, arg6 int, arg7 int, arg8 BtDispatcher) (_swig_ret BtBroadphaseProxy) + DestroyProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) + SetAabb(arg2 BtBroadphaseProxy, arg3 BtVector3, arg4 BtVector3, arg5 BtDispatcher) + GetAabb(arg2 BtBroadphaseProxy, arg3 BtVector3, arg4 BtVector3) + RayTest(a ...interface{}) + AabbTest(arg2 BtVector3, arg3 BtVector3, arg4 BtBroadphaseAabbCallback) + CalculateOverlappingPairs(arg2 BtDispatcher) + GetOverlappingPairCache(a ...interface{}) interface{} + GetBroadphaseAabb(arg2 BtVector3, arg3 BtVector3) + ResetPool(arg2 BtDispatcher) + PrintStats() +} + +type SwigcptrBtOverlappingPairCallback uintptr + +func (p SwigcptrBtOverlappingPairCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtOverlappingPairCallback) SwigIsBtOverlappingPairCallback() { +} + +func DeleteBtOverlappingPairCallback(arg1 BtOverlappingPairCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btOverlappingPairCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtOverlappingPairCallback) AddOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btOverlappingPairCallback_addOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtOverlappingPairCallback) RemoveOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy, arg4 BtDispatcher) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (uintptr)(C._wrap_btOverlappingPairCallback_removeOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtOverlappingPairCallback) RemoveOverlappingPairsContainingProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btOverlappingPairCallback_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +type BtOverlappingPairCallback interface { + Swigcptr() uintptr + SwigIsBtOverlappingPairCallback() + AddOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) + RemoveOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy, arg4 BtDispatcher) (_swig_ret uintptr) + RemoveOverlappingPairsContainingProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) +} + +type SwigcptrBtOverlapCallback uintptr + +func (p SwigcptrBtOverlapCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtOverlapCallback) SwigIsBtOverlapCallback() { +} + +func DeleteBtOverlapCallback(arg1 BtOverlapCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btOverlapCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtOverlapCallback) ProcessOverlap(arg2 BtBroadphasePair) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btOverlapCallback_processOverlap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +type BtOverlapCallback interface { + Swigcptr() uintptr + SwigIsBtOverlapCallback() + ProcessOverlap(arg2 BtBroadphasePair) (_swig_ret bool) +} + +type SwigcptrBtOverlapFilterCallback uintptr + +func (p SwigcptrBtOverlapFilterCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtOverlapFilterCallback) SwigIsBtOverlapFilterCallback() { +} + +func DeleteBtOverlapFilterCallback(arg1 BtOverlapFilterCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btOverlapFilterCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtOverlapFilterCallback) NeedBroadphaseCollision(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_btOverlapFilterCallback_needBroadphaseCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +type BtOverlapFilterCallback interface { + Swigcptr() uintptr + SwigIsBtOverlapFilterCallback() + NeedBroadphaseCollision(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret bool) +} + +func GetBT_NULL_PAIR() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_BT_NULL_PAIR_get_mbt_e879218550ba2e2b()) + return swig_r +} + +type SwigcptrBtOverlappingPairCache uintptr + +func (p SwigcptrBtOverlappingPairCache) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtOverlappingPairCache) SwigIsBtOverlappingPairCache() { +} + +func DeleteBtOverlappingPairCache(arg1 BtOverlappingPairCache) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btOverlappingPairCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtOverlappingPairCache) GetOverlappingPairArrayPtr__SWIG_0() (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtOverlappingPairCache) GetOverlappingPairArrayPtr__SWIG_1() (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtOverlappingPairCache) GetOverlappingPairArrayPtr(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOverlappingPairArrayPtr__SWIG_0() + } + if argc == 0 { + return p.GetOverlappingPairArrayPtr__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtOverlappingPairCache) GetOverlappingPairArray() (_swig_ret BtAlignedObjectArray_Sl_btBroadphasePair_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btBroadphasePair_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btBroadphasePair_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btBroadphasePair_Sg_(C._wrap_btOverlappingPairCache_getOverlappingPairArray_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtOverlappingPairCache) CleanOverlappingPair(arg2 BtBroadphasePair, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btOverlappingPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtOverlappingPairCache) GetNumOverlappingPairs() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btOverlappingPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOverlappingPairCache) NeedsBroadphaseCollision(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_btOverlappingPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtOverlappingPairCache) GetOverlapFilterCallback() (_swig_ret BtOverlapFilterCallback) { + var swig_r BtOverlapFilterCallback + _swig_i_0 := arg1 + swig_r = (BtOverlapFilterCallback)(SwigcptrBtOverlapFilterCallback(C._wrap_btOverlappingPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtOverlappingPairCache) CleanProxyFromPairs(arg2 BtBroadphaseProxy, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btOverlappingPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtOverlappingPairCache) SetOverlapFilterCallback(arg2 BtOverlapFilterCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOverlappingPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtOverlappingPairCache) ProcessAllOverlappingPairs__SWIG_0(arg2 BtOverlapCallback, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btOverlappingPairCache_processAllOverlappingPairs__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtOverlappingPairCache) ProcessAllOverlappingPairs__SWIG_1(arg2 BtOverlapCallback, arg3 BtDispatcher, arg4 BtDispatcherInfo) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btOverlappingPairCache_processAllOverlappingPairs__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtOverlappingPairCache) ProcessAllOverlappingPairs(a ...interface{}) { + argc := len(a) + if argc == 2 { + p.ProcessAllOverlappingPairs__SWIG_0(a[0].(BtOverlapCallback), a[1].(BtDispatcher)) + return + } + if argc == 3 { + p.ProcessAllOverlappingPairs__SWIG_1(a[0].(BtOverlapCallback), a[1].(BtDispatcher), a[2].(BtDispatcherInfo)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtOverlappingPairCache) FindPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btOverlappingPairCache_findPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtOverlappingPairCache) HasDeferredRemoval() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btOverlappingPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOverlappingPairCache) SetInternalGhostPairCallback(arg2 BtOverlappingPairCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOverlappingPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtOverlappingPairCache) SortOverlappingPairs(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOverlappingPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtOverlappingPairCache) AddOverlappingPair(arg1 BtBroadphaseProxy, arg2 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btOverlappingPairCache_addOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (_swig_base SwigcptrBtOverlappingPairCache) RemoveOverlappingPair(arg1 BtBroadphaseProxy, arg2 BtBroadphaseProxy, arg3 BtDispatcher) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (uintptr)(C._wrap_btOverlappingPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (_swig_base SwigcptrBtOverlappingPairCache) RemoveOverlappingPairsContainingProxy(arg1 BtBroadphaseProxy, arg2 BtDispatcher) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOverlappingPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtOverlappingPairCache) SwigIsBtOverlappingPairCallback() { +} + +func (p SwigcptrBtOverlappingPairCache) SwigGetBtOverlappingPairCallback() BtOverlappingPairCallback { + return SwigcptrBtOverlappingPairCallback(getSwigcptr(p)) +} + +type BtOverlappingPairCache interface { + Swigcptr() uintptr + SwigIsBtOverlappingPairCache() + GetOverlappingPairArrayPtr(a ...interface{}) interface{} + GetOverlappingPairArray() (_swig_ret BtAlignedObjectArray_Sl_btBroadphasePair_Sg_) + CleanOverlappingPair(arg2 BtBroadphasePair, arg3 BtDispatcher) + GetNumOverlappingPairs() (_swig_ret int) + NeedsBroadphaseCollision(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret bool) + GetOverlapFilterCallback() (_swig_ret BtOverlapFilterCallback) + CleanProxyFromPairs(arg2 BtBroadphaseProxy, arg3 BtDispatcher) + SetOverlapFilterCallback(arg2 BtOverlapFilterCallback) + ProcessAllOverlappingPairs(a ...interface{}) + FindPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) + HasDeferredRemoval() (_swig_ret bool) + SetInternalGhostPairCallback(arg2 BtOverlappingPairCallback) + SortOverlappingPairs(arg2 BtDispatcher) + AddOverlappingPair(arg1 BtBroadphaseProxy, arg2 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) + RemoveOverlappingPair(arg1 BtBroadphaseProxy, arg2 BtBroadphaseProxy, arg3 BtDispatcher) (_swig_ret uintptr) + RemoveOverlappingPairsContainingProxy(arg1 BtBroadphaseProxy, arg2 BtDispatcher) + SwigIsBtOverlappingPairCallback() + SwigGetBtOverlappingPairCallback() BtOverlappingPairCallback +} + +type SwigcptrBtHashedOverlappingPairCache uintptr + +func (p SwigcptrBtHashedOverlappingPairCache) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtHashedOverlappingPairCache) SwigIsBtHashedOverlappingPairCache() { +} + +func NewBtHashedOverlappingPairCache() (_swig_ret BtHashedOverlappingPairCache) { + var swig_r BtHashedOverlappingPairCache + swig_r = (BtHashedOverlappingPairCache)(SwigcptrBtHashedOverlappingPairCache(C._wrap_new_btHashedOverlappingPairCache_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtHashedOverlappingPairCache(arg1 BtHashedOverlappingPairCache) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btHashedOverlappingPairCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) RemoveOverlappingPairsContainingProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btHashedOverlappingPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) RemoveOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy, arg4 BtDispatcher) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (uintptr)(C._wrap_btHashedOverlappingPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) NeedsBroadphaseCollision(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_btHashedOverlappingPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) AddOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btHashedOverlappingPairCache_addOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) CleanProxyFromPairs(arg2 BtBroadphaseProxy, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btHashedOverlappingPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) ProcessAllOverlappingPairs__SWIG_0(arg2 BtOverlapCallback, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btHashedOverlappingPairCache_processAllOverlappingPairs__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) ProcessAllOverlappingPairs__SWIG_1(arg2 BtOverlapCallback, arg3 BtDispatcher, arg4 BtDispatcherInfo) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btHashedOverlappingPairCache_processAllOverlappingPairs__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtHashedOverlappingPairCache) ProcessAllOverlappingPairs(a ...interface{}) { + argc := len(a) + if argc == 2 { + p.ProcessAllOverlappingPairs__SWIG_0(a[0].(BtOverlapCallback), a[1].(BtDispatcher)) + return + } + if argc == 3 { + p.ProcessAllOverlappingPairs__SWIG_1(a[0].(BtOverlapCallback), a[1].(BtDispatcher), a[2].(BtDispatcherInfo)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) GetOverlappingPairArrayPtr__SWIG_0() (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btHashedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) GetOverlappingPairArrayPtr__SWIG_1() (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btHashedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtHashedOverlappingPairCache) GetOverlappingPairArrayPtr(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOverlappingPairArrayPtr__SWIG_0() + } + if argc == 0 { + return p.GetOverlappingPairArrayPtr__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) GetOverlappingPairArray__SWIG_0() (_swig_ret BtAlignedObjectArray_Sl_btBroadphasePair_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btBroadphasePair_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btBroadphasePair_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btBroadphasePair_Sg_(C._wrap_btHashedOverlappingPairCache_getOverlappingPairArray__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) GetOverlappingPairArray__SWIG_1() (_swig_ret BtAlignedObjectArray_Sl_btBroadphasePair_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btBroadphasePair_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btBroadphasePair_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btBroadphasePair_Sg_(C._wrap_btHashedOverlappingPairCache_getOverlappingPairArray__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtHashedOverlappingPairCache) GetOverlappingPairArray(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOverlappingPairArray__SWIG_0() + } + if argc == 0 { + return p.GetOverlappingPairArray__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) CleanOverlappingPair(arg2 BtBroadphasePair, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btHashedOverlappingPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) FindPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btHashedOverlappingPairCache_findPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) GetCount() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btHashedOverlappingPairCache_GetCount_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) GetOverlapFilterCallback() (_swig_ret BtOverlapFilterCallback) { + var swig_r BtOverlapFilterCallback + _swig_i_0 := arg1 + swig_r = (BtOverlapFilterCallback)(SwigcptrBtOverlapFilterCallback(C._wrap_btHashedOverlappingPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) SetOverlapFilterCallback(arg2 BtOverlapFilterCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btHashedOverlappingPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtHashedOverlappingPairCache) GetNumOverlappingPairs() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btHashedOverlappingPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtHashedOverlappingPairCache) HasDeferredRemoval() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btHashedOverlappingPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHashedOverlappingPairCache) SetInternalGhostPairCallback(arg1 BtOverlappingPairCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btHashedOverlappingPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtHashedOverlappingPairCache) SortOverlappingPairs(arg1 BtDispatcher) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btHashedOverlappingPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtHashedOverlappingPairCache) SwigIsBtOverlappingPairCache() { +} + +func (p SwigcptrBtHashedOverlappingPairCache) SwigGetBtOverlappingPairCache() BtOverlappingPairCache { + return SwigcptrBtOverlappingPairCache(getSwigcptr(p)) +} + +func (p SwigcptrBtHashedOverlappingPairCache) SwigIsBtOverlappingPairCallback() { +} + +func (p SwigcptrBtHashedOverlappingPairCache) SwigGetBtOverlappingPairCallback() BtOverlappingPairCallback { + return SwigcptrBtOverlappingPairCallback(getSwigcptr(p)) +} + +type BtHashedOverlappingPairCache interface { + Swigcptr() uintptr + SwigIsBtHashedOverlappingPairCache() + RemoveOverlappingPairsContainingProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) + RemoveOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy, arg4 BtDispatcher) (_swig_ret uintptr) + NeedsBroadphaseCollision(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret bool) + AddOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) + CleanProxyFromPairs(arg2 BtBroadphaseProxy, arg3 BtDispatcher) + ProcessAllOverlappingPairs(a ...interface{}) + GetOverlappingPairArrayPtr(a ...interface{}) interface{} + GetOverlappingPairArray(a ...interface{}) interface{} + CleanOverlappingPair(arg2 BtBroadphasePair, arg3 BtDispatcher) + FindPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) + GetCount() (_swig_ret int) + GetOverlapFilterCallback() (_swig_ret BtOverlapFilterCallback) + SetOverlapFilterCallback(arg2 BtOverlapFilterCallback) + GetNumOverlappingPairs() (_swig_ret int) + HasDeferredRemoval() (_swig_ret bool) + SetInternalGhostPairCallback(arg1 BtOverlappingPairCallback) + SortOverlappingPairs(arg1 BtDispatcher) + SwigIsBtOverlappingPairCache() + SwigGetBtOverlappingPairCache() BtOverlappingPairCache + SwigIsBtOverlappingPairCallback() + SwigGetBtOverlappingPairCallback() BtOverlappingPairCallback +} + +type SwigcptrBtSortedOverlappingPairCache uintptr + +func (p SwigcptrBtSortedOverlappingPairCache) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSortedOverlappingPairCache) SwigIsBtSortedOverlappingPairCache() { +} + +func NewBtSortedOverlappingPairCache() (_swig_ret BtSortedOverlappingPairCache) { + var swig_r BtSortedOverlappingPairCache + swig_r = (BtSortedOverlappingPairCache)(SwigcptrBtSortedOverlappingPairCache(C._wrap_new_btSortedOverlappingPairCache_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtSortedOverlappingPairCache(arg1 BtSortedOverlappingPairCache) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSortedOverlappingPairCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) ProcessAllOverlappingPairs(arg2 BtOverlapCallback, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSortedOverlappingPairCache_processAllOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) RemoveOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy, arg4 BtDispatcher) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (uintptr)(C._wrap_btSortedOverlappingPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) CleanOverlappingPair(arg2 BtBroadphasePair, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSortedOverlappingPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) AddOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btSortedOverlappingPairCache_addOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) FindPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btSortedOverlappingPairCache_findPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) CleanProxyFromPairs(arg2 BtBroadphaseProxy, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSortedOverlappingPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) RemoveOverlappingPairsContainingProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSortedOverlappingPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) NeedsBroadphaseCollision(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_btSortedOverlappingPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) GetOverlappingPairArray__SWIG_0() (_swig_ret BtAlignedObjectArray_Sl_btBroadphasePair_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btBroadphasePair_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btBroadphasePair_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btBroadphasePair_Sg_(C._wrap_btSortedOverlappingPairCache_getOverlappingPairArray__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) GetOverlappingPairArray__SWIG_1() (_swig_ret BtAlignedObjectArray_Sl_btBroadphasePair_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btBroadphasePair_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btBroadphasePair_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btBroadphasePair_Sg_(C._wrap_btSortedOverlappingPairCache_getOverlappingPairArray__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtSortedOverlappingPairCache) GetOverlappingPairArray(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOverlappingPairArray__SWIG_0() + } + if argc == 0 { + return p.GetOverlappingPairArray__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) GetOverlappingPairArrayPtr__SWIG_0() (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btSortedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) GetOverlappingPairArrayPtr__SWIG_1() (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btSortedOverlappingPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtSortedOverlappingPairCache) GetOverlappingPairArrayPtr(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOverlappingPairArrayPtr__SWIG_0() + } + if argc == 0 { + return p.GetOverlappingPairArrayPtr__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) GetNumOverlappingPairs() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSortedOverlappingPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) GetOverlapFilterCallback() (_swig_ret BtOverlapFilterCallback) { + var swig_r BtOverlapFilterCallback + _swig_i_0 := arg1 + swig_r = (BtOverlapFilterCallback)(SwigcptrBtOverlapFilterCallback(C._wrap_btSortedOverlappingPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) SetOverlapFilterCallback(arg2 BtOverlapFilterCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSortedOverlappingPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) HasDeferredRemoval() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btSortedOverlappingPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) SetInternalGhostPairCallback(arg2 BtOverlappingPairCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSortedOverlappingPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSortedOverlappingPairCache) SortOverlappingPairs(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSortedOverlappingPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtSortedOverlappingPairCache) SwigIsBtOverlappingPairCache() { +} + +func (p SwigcptrBtSortedOverlappingPairCache) SwigGetBtOverlappingPairCache() BtOverlappingPairCache { + return SwigcptrBtOverlappingPairCache(getSwigcptr(p)) +} + +func (p SwigcptrBtSortedOverlappingPairCache) SwigIsBtOverlappingPairCallback() { +} + +func (p SwigcptrBtSortedOverlappingPairCache) SwigGetBtOverlappingPairCallback() BtOverlappingPairCallback { + return SwigcptrBtOverlappingPairCallback(getSwigcptr(p)) +} + +type BtSortedOverlappingPairCache interface { + Swigcptr() uintptr + SwigIsBtSortedOverlappingPairCache() + ProcessAllOverlappingPairs(arg2 BtOverlapCallback, arg3 BtDispatcher) + RemoveOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy, arg4 BtDispatcher) (_swig_ret uintptr) + CleanOverlappingPair(arg2 BtBroadphasePair, arg3 BtDispatcher) + AddOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) + FindPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) + CleanProxyFromPairs(arg2 BtBroadphaseProxy, arg3 BtDispatcher) + RemoveOverlappingPairsContainingProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) + NeedsBroadphaseCollision(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret bool) + GetOverlappingPairArray(a ...interface{}) interface{} + GetOverlappingPairArrayPtr(a ...interface{}) interface{} + GetNumOverlappingPairs() (_swig_ret int) + GetOverlapFilterCallback() (_swig_ret BtOverlapFilterCallback) + SetOverlapFilterCallback(arg2 BtOverlapFilterCallback) + HasDeferredRemoval() (_swig_ret bool) + SetInternalGhostPairCallback(arg2 BtOverlappingPairCallback) + SortOverlappingPairs(arg2 BtDispatcher) + SwigIsBtOverlappingPairCache() + SwigGetBtOverlappingPairCache() BtOverlappingPairCache + SwigIsBtOverlappingPairCallback() + SwigGetBtOverlappingPairCallback() BtOverlappingPairCallback +} + +type SwigcptrBtNullPairCache uintptr + +func (p SwigcptrBtNullPairCache) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtNullPairCache) SwigIsBtNullPairCache() { +} + +func (arg1 SwigcptrBtNullPairCache) GetOverlappingPairArrayPtr__SWIG_0() (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btNullPairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtNullPairCache) GetOverlappingPairArrayPtr__SWIG_1() (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btNullPairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtNullPairCache) GetOverlappingPairArrayPtr(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOverlappingPairArrayPtr__SWIG_0() + } + if argc == 0 { + return p.GetOverlappingPairArrayPtr__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtNullPairCache) GetOverlappingPairArray() (_swig_ret BtAlignedObjectArray_Sl_btBroadphasePair_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btBroadphasePair_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btBroadphasePair_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btBroadphasePair_Sg_(C._wrap_btNullPairCache_getOverlappingPairArray_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtNullPairCache) CleanOverlappingPair(arg2 BtBroadphasePair, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btNullPairCache_cleanOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtNullPairCache) GetNumOverlappingPairs() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btNullPairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtNullPairCache) CleanProxyFromPairs(arg2 BtBroadphaseProxy, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btNullPairCache_cleanProxyFromPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtNullPairCache) NeedsBroadphaseCollision(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_btNullPairCache_needsBroadphaseCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtNullPairCache) GetOverlapFilterCallback() (_swig_ret BtOverlapFilterCallback) { + var swig_r BtOverlapFilterCallback + _swig_i_0 := arg1 + swig_r = (BtOverlapFilterCallback)(SwigcptrBtOverlapFilterCallback(C._wrap_btNullPairCache_getOverlapFilterCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtNullPairCache) SetOverlapFilterCallback(arg2 BtOverlapFilterCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btNullPairCache_setOverlapFilterCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtNullPairCache) ProcessAllOverlappingPairs(arg2 BtOverlapCallback, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btNullPairCache_processAllOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtNullPairCache) FindPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btNullPairCache_findPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtNullPairCache) HasDeferredRemoval() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btNullPairCache_hasDeferredRemoval_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtNullPairCache) SetInternalGhostPairCallback(arg2 BtOverlappingPairCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btNullPairCache_setInternalGhostPairCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtNullPairCache) AddOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) { + var swig_r BtBroadphasePair + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtBroadphasePair)(SwigcptrBtBroadphasePair(C._wrap_btNullPairCache_addOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtNullPairCache) RemoveOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy, arg4 BtDispatcher) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (uintptr)(C._wrap_btNullPairCache_removeOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtNullPairCache) RemoveOverlappingPairsContainingProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btNullPairCache_removeOverlappingPairsContainingProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtNullPairCache) SortOverlappingPairs(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btNullPairCache_sortOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func NewBtNullPairCache() (_swig_ret BtNullPairCache) { + var swig_r BtNullPairCache + swig_r = (BtNullPairCache)(SwigcptrBtNullPairCache(C._wrap_new_btNullPairCache_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtNullPairCache(arg1 BtNullPairCache) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btNullPairCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtNullPairCache) SwigIsBtOverlappingPairCache() { +} + +func (p SwigcptrBtNullPairCache) SwigGetBtOverlappingPairCache() BtOverlappingPairCache { + return SwigcptrBtOverlappingPairCache(getSwigcptr(p)) +} + +func (p SwigcptrBtNullPairCache) SwigIsBtOverlappingPairCallback() { +} + +func (p SwigcptrBtNullPairCache) SwigGetBtOverlappingPairCallback() BtOverlappingPairCallback { + return SwigcptrBtOverlappingPairCallback(getSwigcptr(p)) +} + +type BtNullPairCache interface { + Swigcptr() uintptr + SwigIsBtNullPairCache() + GetOverlappingPairArrayPtr(a ...interface{}) interface{} + GetOverlappingPairArray() (_swig_ret BtAlignedObjectArray_Sl_btBroadphasePair_Sg_) + CleanOverlappingPair(arg2 BtBroadphasePair, arg3 BtDispatcher) + GetNumOverlappingPairs() (_swig_ret int) + CleanProxyFromPairs(arg2 BtBroadphaseProxy, arg3 BtDispatcher) + NeedsBroadphaseCollision(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret bool) + GetOverlapFilterCallback() (_swig_ret BtOverlapFilterCallback) + SetOverlapFilterCallback(arg2 BtOverlapFilterCallback) + ProcessAllOverlappingPairs(arg2 BtOverlapCallback, arg3 BtDispatcher) + FindPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) + HasDeferredRemoval() (_swig_ret bool) + SetInternalGhostPairCallback(arg2 BtOverlappingPairCallback) + AddOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy) (_swig_ret BtBroadphasePair) + RemoveOverlappingPair(arg2 BtBroadphaseProxy, arg3 BtBroadphaseProxy, arg4 BtDispatcher) (_swig_ret uintptr) + RemoveOverlappingPairsContainingProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) + SortOverlappingPairs(arg2 BtDispatcher) + SwigIsBtOverlappingPairCache() + SwigGetBtOverlappingPairCache() BtOverlappingPairCache + SwigIsBtOverlappingPairCallback() + SwigGetBtOverlappingPairCallback() BtOverlappingPairCallback +} + +type SwigcptrMyPairIndex uintptr + +func (p SwigcptrMyPairIndex) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrMyPairIndex) SwigIsMyPairIndex() { +} + +func (arg1 SwigcptrMyPairIndex) SetM_orgIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_MyPairIndex_m_orgIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrMyPairIndex) GetM_orgIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_MyPairIndex_m_orgIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrMyPairIndex) SetM_uidA0(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_MyPairIndex_m_uidA0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrMyPairIndex) GetM_uidA0() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_MyPairIndex_m_uidA0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrMyPairIndex) SetM_uidA1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_MyPairIndex_m_uidA1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrMyPairIndex) GetM_uidA1() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_MyPairIndex_m_uidA1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewMyPairIndex() (_swig_ret MyPairIndex) { + var swig_r MyPairIndex + swig_r = (MyPairIndex)(SwigcptrMyPairIndex(C._wrap_new_MyPairIndex_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteMyPairIndex(arg1 MyPairIndex) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_MyPairIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type MyPairIndex interface { + Swigcptr() uintptr + SwigIsMyPairIndex() + SetM_orgIndex(arg2 int) + GetM_orgIndex() (_swig_ret int) + SetM_uidA0(arg2 int) + GetM_uidA0() (_swig_ret int) + SetM_uidA1(arg2 int) + GetM_uidA1() (_swig_ret int) +} + +type SwigcptrMyPairIndeSortPredicate uintptr + +func (p SwigcptrMyPairIndeSortPredicate) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrMyPairIndeSortPredicate) SwigIsMyPairIndeSortPredicate() { +} + +func NewMyPairIndeSortPredicate() (_swig_ret MyPairIndeSortPredicate) { + var swig_r MyPairIndeSortPredicate + swig_r = (MyPairIndeSortPredicate)(SwigcptrMyPairIndeSortPredicate(C._wrap_new_MyPairIndeSortPredicate_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteMyPairIndeSortPredicate(arg1 MyPairIndeSortPredicate) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_MyPairIndeSortPredicate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type MyPairIndeSortPredicate interface { + Swigcptr() uintptr + SwigIsMyPairIndeSortPredicate() +} + +const DBVT_BP_PROFILE int = 0 +const DBVT_BP_PREVENTFALSEUPDATE int = 0 +const DBVT_BP_ACCURATESLEEPING int = 0 +const DBVT_BP_ENABLE_BENCHMARK int = 0 + +func SetGDbvtMargin(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_gDbvtMargin_set_mbt_e879218550ba2e2b(C.float(_swig_i_0)) +} + +func GetGDbvtMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_gDbvtMargin_get_mbt_e879218550ba2e2b()) + return swig_r +} + +type SwigcptrBtDbvtProxy uintptr + +func (p SwigcptrBtDbvtProxy) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDbvtProxy) SwigIsBtDbvtProxy() { +} + +func (arg1 SwigcptrBtDbvtProxy) SetLeaf(arg2 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtProxy_leaf_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtProxy) GetLeaf() (_swig_ret BtDbvtNode) { + var swig_r BtDbvtNode + _swig_i_0 := arg1 + swig_r = (BtDbvtNode)(SwigcptrBtDbvtNode(C._wrap_btDbvtProxy_leaf_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtProxy) SetLinks(arg2 BtDbvtProxy) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtProxy_links_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtProxy) GetLinks() (_swig_ret BtDbvtProxy) { + var swig_r BtDbvtProxy + _swig_i_0 := arg1 + swig_r = (BtDbvtProxy)(SwigcptrBtDbvtProxy(C._wrap_btDbvtProxy_links_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtProxy) SetStage(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtProxy_stage_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtProxy) GetStage() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvtProxy_stage_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtDbvtProxy(arg1 BtVector3, arg2 BtVector3, arg3 uintptr, arg4 int, arg5 int) (_swig_ret BtDbvtProxy) { + var swig_r BtDbvtProxy + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + swig_r = (BtDbvtProxy)(SwigcptrBtDbvtProxy(C._wrap_new_btDbvtProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3), C.swig_intgo(_swig_i_4)))) + return swig_r +} + +func DeleteBtDbvtProxy(arg1 BtDbvtProxy) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDbvtProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDbvtProxy) SetM_clientObject(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_SetbtDbvtProxy_M_clientObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDbvtProxy) GetM_clientObject() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_GetbtDbvtProxy_M_clientObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtDbvtProxy) SetM_collisionFilterGroup(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtDbvtProxy_M_collisionFilterGroup_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDbvtProxy) GetM_collisionFilterGroup() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtDbvtProxy_M_collisionFilterGroup_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtDbvtProxy) SetM_collisionFilterMask(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtDbvtProxy_M_collisionFilterMask_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDbvtProxy) GetM_collisionFilterMask() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtDbvtProxy_M_collisionFilterMask_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtDbvtProxy) SetM_uniqueId(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtDbvtProxy_M_uniqueId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDbvtProxy) GetM_uniqueId() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtDbvtProxy_M_uniqueId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtDbvtProxy) SetM_aabbMin(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_SetbtDbvtProxy_M_aabbMin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDbvtProxy) GetM_aabbMin() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GetbtDbvtProxy_M_aabbMin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDbvtProxy) SetM_aabbMax(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_SetbtDbvtProxy_M_aabbMax_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDbvtProxy) GetM_aabbMax() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GetbtDbvtProxy_M_aabbMax_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDbvtProxy) GetUid() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btDbvtProxy_getUid_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func BtDbvtProxyIsPolyhedral(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtProxy_isPolyhedral_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtDbvtProxyIsConvex(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtProxy_isConvex_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtDbvtProxyIsNonMoving(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtProxy_isNonMoving_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtDbvtProxyIsConcave(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtProxy_isConcave_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtDbvtProxyIsCompound(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtProxy_isCompound_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtDbvtProxyIsSoftBody(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtProxy_isSoftBody_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtDbvtProxyIsInfinite(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtProxy_isInfinite_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func BtDbvtProxyIsConvex2d(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtProxy_isConvex2d_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0))) + return swig_r +} + +func (p SwigcptrBtDbvtProxy) SwigIsBtBroadphaseProxy() { +} + +func (p SwigcptrBtDbvtProxy) SwigGetBtBroadphaseProxy() BtBroadphaseProxy { + return SwigcptrBtBroadphaseProxy(getSwigcptr(p)) +} + +type BtDbvtProxy interface { + Swigcptr() uintptr + SwigIsBtDbvtProxy() + SetLeaf(arg2 BtDbvtNode) + GetLeaf() (_swig_ret BtDbvtNode) + SetLinks(arg2 BtDbvtProxy) + GetLinks() (_swig_ret BtDbvtProxy) + SetStage(arg2 int) + GetStage() (_swig_ret int) + SetM_clientObject(arg1 uintptr) + GetM_clientObject() (_swig_ret uintptr) + SetM_collisionFilterGroup(arg1 int) + GetM_collisionFilterGroup() (_swig_ret int) + SetM_collisionFilterMask(arg1 int) + GetM_collisionFilterMask() (_swig_ret int) + SetM_uniqueId(arg1 int) + GetM_uniqueId() (_swig_ret int) + SetM_aabbMin(arg1 BtVector3) + GetM_aabbMin() (_swig_ret BtVector3) + SetM_aabbMax(arg1 BtVector3) + GetM_aabbMax() (_swig_ret BtVector3) + GetUid() (_swig_ret int) + SwigIsBtBroadphaseProxy() + SwigGetBtBroadphaseProxy() BtBroadphaseProxy +} + +type SwigcptrBtDbvtBroadphase uintptr + +func (p SwigcptrBtDbvtBroadphase) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDbvtBroadphase) SwigIsBtDbvtBroadphase() { +} + +func _swig_getbtDbvtBroadphase_DYNAMIC_SET_btDbvtBroadphase() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_DYNAMIC_SET_btDbvtBroadphase_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtDbvtBroadphaseDYNAMIC_SET int = _swig_getbtDbvtBroadphase_DYNAMIC_SET_btDbvtBroadphase() + +func _swig_getbtDbvtBroadphase_FIXED_SET_btDbvtBroadphase() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_FIXED_SET_btDbvtBroadphase_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtDbvtBroadphaseFIXED_SET int = _swig_getbtDbvtBroadphase_FIXED_SET_btDbvtBroadphase() + +func _swig_getbtDbvtBroadphase_STAGECOUNT_btDbvtBroadphase() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_STAGECOUNT_btDbvtBroadphase_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtDbvtBroadphaseSTAGECOUNT int = _swig_getbtDbvtBroadphase_STAGECOUNT_btDbvtBroadphase() + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_sets(arg2 BtDbvt) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtBroadphase_m_sets_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_sets() (_swig_ret BtDbvt) { + var swig_r BtDbvt + _swig_i_0 := arg1 + swig_r = (BtDbvt)(SwigcptrBtDbvt(C._wrap_btDbvtBroadphase_m_sets_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_stageRoots(arg2 BtDbvtProxy) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtBroadphase_m_stageRoots_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_stageRoots() (_swig_ret BtDbvtProxy) { + var swig_r BtDbvtProxy + _swig_i_0 := arg1 + swig_r = (BtDbvtProxy)(SwigcptrBtDbvtProxy(C._wrap_btDbvtBroadphase_m_stageRoots_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_paircache(arg2 BtOverlappingPairCache) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtBroadphase_m_paircache_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_paircache() (_swig_ret BtOverlappingPairCache) { + var swig_r BtOverlappingPairCache + _swig_i_0 := arg1 + swig_r = (BtOverlappingPairCache)(SwigcptrBtOverlappingPairCache(C._wrap_btDbvtBroadphase_m_paircache_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_prediction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_prediction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_prediction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btDbvtBroadphase_m_prediction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_stageCurrent(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_stageCurrent_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_stageCurrent() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvtBroadphase_m_stageCurrent_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_fupdates(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_fupdates_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_fupdates() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvtBroadphase_m_fupdates_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_dupdates(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_dupdates_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_dupdates() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvtBroadphase_m_dupdates_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_cupdates(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_cupdates_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_cupdates() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvtBroadphase_m_cupdates_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_newpairs(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_newpairs_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_newpairs() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvtBroadphase_m_newpairs_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_fixedleft(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_fixedleft_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_fixedleft() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvtBroadphase_m_fixedleft_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_updates_call(arg2 uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_updates_call_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_updates_call() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btDbvtBroadphase_m_updates_call_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_updates_done(arg2 uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_updates_done_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_updates_done() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btDbvtBroadphase_m_updates_done_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_updates_ratio(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_updates_ratio_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_updates_ratio() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btDbvtBroadphase_m_updates_ratio_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_pid(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_pid_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_pid() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvtBroadphase_m_pid_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_cid(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_cid_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_cid() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvtBroadphase_m_cid_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_gid(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_gid_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_gid() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDbvtBroadphase_m_gid_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_releasepaircache(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_releasepaircache_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_releasepaircache() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtBroadphase_m_releasepaircache_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_deferedcollide(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_deferedcollide_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_deferedcollide() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtBroadphase_m_deferedcollide_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_needcleanup(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_m_needcleanup_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_needcleanup() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDbvtBroadphase_m_needcleanup_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetM_rayTestStacks(arg2 BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtBroadphase_m_rayTestStacks_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetM_rayTestStacks() (_swig_ret BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg__Sg_(C._wrap_btDbvtBroadphase_m_rayTestStacks_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtDbvtBroadphase__SWIG_0(arg1 BtOverlappingPairCache) (_swig_ret BtDbvtBroadphase) { + var swig_r BtDbvtBroadphase + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtDbvtBroadphase)(SwigcptrBtDbvtBroadphase(C._wrap_new_btDbvtBroadphase__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtDbvtBroadphase__SWIG_1() (_swig_ret BtDbvtBroadphase) { + var swig_r BtDbvtBroadphase + swig_r = (BtDbvtBroadphase)(SwigcptrBtDbvtBroadphase(C._wrap_new_btDbvtBroadphase__SWIG_1_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtDbvtBroadphase(a ...interface{}) BtDbvtBroadphase { + argc := len(a) + if argc == 0 { + return NewBtDbvtBroadphase__SWIG_1() + } + if argc == 1 { + return NewBtDbvtBroadphase__SWIG_0(a[0].(BtOverlappingPairCache)) + } + panic("No match for overloaded function call") +} + +func DeleteBtDbvtBroadphase(arg1 BtDbvtBroadphase) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDbvtBroadphase_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) Collide(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtBroadphase_collide_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) Optimize() { + _swig_i_0 := arg1 + C._wrap_btDbvtBroadphase_optimize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) CreateProxy(arg2 BtVector3, arg3 BtVector3, arg4 int, arg5 uintptr, arg6 int, arg7 int, arg8 BtDispatcher) (_swig_ret BtBroadphaseProxy) { + var swig_r BtBroadphaseProxy + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := getSwigcptr(arg8) + swig_r = (BtBroadphaseProxy)(SwigcptrBtBroadphaseProxy(C._wrap_btDbvtBroadphase_createProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4), C.swig_intgo(_swig_i_5), C.swig_intgo(_swig_i_6), C.uintptr_t(_swig_i_7)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) DestroyProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDbvtBroadphase_destroyProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetAabb(arg2 BtBroadphaseProxy, arg3 BtVector3, arg4 BtVector3, arg5 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btDbvtBroadphase_setAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) RayTest__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtBroadphaseRayCallback, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btDbvtBroadphase_rayTest__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) RayTest__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtBroadphaseRayCallback, arg5 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btDbvtBroadphase_rayTest__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) RayTest__SWIG_2(arg2 BtVector3, arg3 BtVector3, arg4 BtBroadphaseRayCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDbvtBroadphase_rayTest__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtDbvtBroadphase) RayTest(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.RayTest__SWIG_2(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtBroadphaseRayCallback)) + return + } + if argc == 4 { + p.RayTest__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtBroadphaseRayCallback), a[3].(BtVector3)) + return + } + if argc == 5 { + p.RayTest__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtBroadphaseRayCallback), a[3].(BtVector3), a[4].(BtVector3)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDbvtBroadphase) AabbTest(arg2 BtVector3, arg3 BtVector3, arg4 BtBroadphaseAabbCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDbvtBroadphase_aabbTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetAabb(arg2 BtBroadphaseProxy, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDbvtBroadphase_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) CalculateOverlappingPairs(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtBroadphase_calculateOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetOverlappingPairCache__SWIG_0() (_swig_ret BtOverlappingPairCache) { + var swig_r BtOverlappingPairCache + _swig_i_0 := arg1 + swig_r = (BtOverlappingPairCache)(SwigcptrBtOverlappingPairCache(C._wrap_btDbvtBroadphase_getOverlappingPairCache__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetOverlappingPairCache__SWIG_1() (_swig_ret BtOverlappingPairCache) { + var swig_r BtOverlappingPairCache + _swig_i_0 := arg1 + swig_r = (BtOverlappingPairCache)(SwigcptrBtOverlappingPairCache(C._wrap_btDbvtBroadphase_getOverlappingPairCache__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtDbvtBroadphase) GetOverlappingPairCache(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOverlappingPairCache__SWIG_0() + } + if argc == 0 { + return p.GetOverlappingPairCache__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetBroadphaseAabb(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDbvtBroadphase_getBroadphaseAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) PrintStats() { + _swig_i_0 := arg1 + C._wrap_btDbvtBroadphase_printStats_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) ResetPool(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtBroadphase_resetPool_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) PerformDeferredRemoval(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtBroadphase_performDeferredRemoval_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetVelocityPrediction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDbvtBroadphase_setVelocityPrediction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtBroadphase) GetVelocityPrediction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btDbvtBroadphase_getVelocityPrediction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtBroadphase) SetAabbForceUpdate(arg2 BtBroadphaseProxy, arg3 BtVector3, arg4 BtVector3, arg5 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btDbvtBroadphase_setAabbForceUpdate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func BtDbvtBroadphaseBenchmark(arg1 BtBroadphaseInterface) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDbvtBroadphase_benchmark_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtDbvtBroadphase) SwigIsBtBroadphaseInterface() { +} + +func (p SwigcptrBtDbvtBroadphase) SwigGetBtBroadphaseInterface() BtBroadphaseInterface { + return SwigcptrBtBroadphaseInterface(getSwigcptr(p)) +} + +type BtDbvtBroadphase interface { + Swigcptr() uintptr + SwigIsBtDbvtBroadphase() + SetM_sets(arg2 BtDbvt) + GetM_sets() (_swig_ret BtDbvt) + SetM_stageRoots(arg2 BtDbvtProxy) + GetM_stageRoots() (_swig_ret BtDbvtProxy) + SetM_paircache(arg2 BtOverlappingPairCache) + GetM_paircache() (_swig_ret BtOverlappingPairCache) + SetM_prediction(arg2 float32) + GetM_prediction() (_swig_ret float32) + SetM_stageCurrent(arg2 int) + GetM_stageCurrent() (_swig_ret int) + SetM_fupdates(arg2 int) + GetM_fupdates() (_swig_ret int) + SetM_dupdates(arg2 int) + GetM_dupdates() (_swig_ret int) + SetM_cupdates(arg2 int) + GetM_cupdates() (_swig_ret int) + SetM_newpairs(arg2 int) + GetM_newpairs() (_swig_ret int) + SetM_fixedleft(arg2 int) + GetM_fixedleft() (_swig_ret int) + SetM_updates_call(arg2 uint) + GetM_updates_call() (_swig_ret uint) + SetM_updates_done(arg2 uint) + GetM_updates_done() (_swig_ret uint) + SetM_updates_ratio(arg2 float32) + GetM_updates_ratio() (_swig_ret float32) + SetM_pid(arg2 int) + GetM_pid() (_swig_ret int) + SetM_cid(arg2 int) + GetM_cid() (_swig_ret int) + SetM_gid(arg2 int) + GetM_gid() (_swig_ret int) + SetM_releasepaircache(arg2 bool) + GetM_releasepaircache() (_swig_ret bool) + SetM_deferedcollide(arg2 bool) + GetM_deferedcollide() (_swig_ret bool) + SetM_needcleanup(arg2 bool) + GetM_needcleanup() (_swig_ret bool) + SetM_rayTestStacks(arg2 BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg__Sg_) + GetM_rayTestStacks() (_swig_ret BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg__Sg_) + Collide(arg2 BtDispatcher) + Optimize() + CreateProxy(arg2 BtVector3, arg3 BtVector3, arg4 int, arg5 uintptr, arg6 int, arg7 int, arg8 BtDispatcher) (_swig_ret BtBroadphaseProxy) + DestroyProxy(arg2 BtBroadphaseProxy, arg3 BtDispatcher) + SetAabb(arg2 BtBroadphaseProxy, arg3 BtVector3, arg4 BtVector3, arg5 BtDispatcher) + RayTest(a ...interface{}) + AabbTest(arg2 BtVector3, arg3 BtVector3, arg4 BtBroadphaseAabbCallback) + GetAabb(arg2 BtBroadphaseProxy, arg3 BtVector3, arg4 BtVector3) + CalculateOverlappingPairs(arg2 BtDispatcher) + GetOverlappingPairCache(a ...interface{}) interface{} + GetBroadphaseAabb(arg2 BtVector3, arg3 BtVector3) + PrintStats() + ResetPool(arg2 BtDispatcher) + PerformDeferredRemoval(arg2 BtDispatcher) + SetVelocityPrediction(arg2 float32) + GetVelocityPrediction() (_swig_ret float32) + SetAabbForceUpdate(arg2 BtBroadphaseProxy, arg3 BtVector3, arg4 BtVector3, arg5 BtDispatcher) + SwigIsBtBroadphaseInterface() + SwigGetBtBroadphaseInterface() BtBroadphaseInterface +} + +func GetBT_MAX_THREAD_COUNT() (_swig_ret uint) { + var swig_r uint + swig_r = (uint)(C._wrap_BT_MAX_THREAD_COUNT_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtIsMainThread() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btIsMainThread_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtThreadsAreRunning() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btThreadsAreRunning_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtGetCurrentThreadIndex() (_swig_ret uint) { + var swig_r uint + swig_r = (uint)(C._wrap_btGetCurrentThreadIndex_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtResetThreadIndexCounter() { + C._wrap_btResetThreadIndexCounter_mbt_e879218550ba2e2b() +} + +type SwigcptrBtSpinMutex uintptr + +func (p SwigcptrBtSpinMutex) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSpinMutex) SwigIsBtSpinMutex() { +} + +func NewBtSpinMutex() (_swig_ret BtSpinMutex) { + var swig_r BtSpinMutex + swig_r = (BtSpinMutex)(SwigcptrBtSpinMutex(C._wrap_new_btSpinMutex_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtSpinMutex) Lock() { + _swig_i_0 := arg1 + C._wrap_btSpinMutex_lock_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSpinMutex) Unlock() { + _swig_i_0 := arg1 + C._wrap_btSpinMutex_unlock_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSpinMutex) TryLock() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btSpinMutex_tryLock_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtSpinMutex(arg1 BtSpinMutex) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSpinMutex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtSpinMutex interface { + Swigcptr() uintptr + SwigIsBtSpinMutex() + Lock() + Unlock() + TryLock() (_swig_ret bool) +} + +func BtMutexLock(arg1 BtSpinMutex) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btMutexLock_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func BtMutexUnlock(arg1 BtSpinMutex) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btMutexUnlock_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func BtMutexTryLock(arg1 BtSpinMutex) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + swig_r = (bool)(C._wrap_btMutexTryLock_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +type SwigcptrBtIParallelForBody uintptr + +func (p SwigcptrBtIParallelForBody) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtIParallelForBody) SwigIsBtIParallelForBody() { +} + +func DeleteBtIParallelForBody(arg1 BtIParallelForBody) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btIParallelForBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtIParallelForBody) ForLoop(arg2 int, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btIParallelForBody_forLoop_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +type BtIParallelForBody interface { + Swigcptr() uintptr + SwigIsBtIParallelForBody() + ForLoop(arg2 int, arg3 int) +} + +type SwigcptrBtIParallelSumBody uintptr + +func (p SwigcptrBtIParallelSumBody) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtIParallelSumBody) SwigIsBtIParallelSumBody() { +} + +func DeleteBtIParallelSumBody(arg1 BtIParallelSumBody) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btIParallelSumBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtIParallelSumBody) SumLoop(arg2 int, arg3 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btIParallelSumBody_sumLoop_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +type BtIParallelSumBody interface { + Swigcptr() uintptr + SwigIsBtIParallelSumBody() + SumLoop(arg2 int, arg3 int) (_swig_ret float32) +} + +type SwigcptrBtITaskScheduler uintptr + +func (p SwigcptrBtITaskScheduler) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtITaskScheduler) SwigIsBtITaskScheduler() { +} + +func DeleteBtITaskScheduler(arg1 BtITaskScheduler) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btITaskScheduler_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtITaskScheduler) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btITaskScheduler_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtITaskScheduler) GetMaxNumThreads() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btITaskScheduler_getMaxNumThreads_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtITaskScheduler) GetNumThreads() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btITaskScheduler_getNumThreads_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtITaskScheduler) SetNumThreads(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btITaskScheduler_setNumThreads_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtITaskScheduler) ParallelFor(arg2 int, arg3 int, arg4 int, arg5 BtIParallelForBody) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btITaskScheduler_parallelFor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtITaskScheduler) ParallelSum(arg2 int, arg3 int, arg4 int, arg5 BtIParallelSumBody) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btITaskScheduler_parallelSum_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtITaskScheduler) SleepWorkerThreadsHint() { + _swig_i_0 := arg1 + C._wrap_btITaskScheduler_sleepWorkerThreadsHint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtITaskScheduler) Activate() { + _swig_i_0 := arg1 + C._wrap_btITaskScheduler_activate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtITaskScheduler) Deactivate() { + _swig_i_0 := arg1 + C._wrap_btITaskScheduler_deactivate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtITaskScheduler interface { + Swigcptr() uintptr + SwigIsBtITaskScheduler() + GetName() (_swig_ret string) + GetMaxNumThreads() (_swig_ret int) + GetNumThreads() (_swig_ret int) + SetNumThreads(arg2 int) + ParallelFor(arg2 int, arg3 int, arg4 int, arg5 BtIParallelForBody) + ParallelSum(arg2 int, arg3 int, arg4 int, arg5 BtIParallelSumBody) (_swig_ret float32) + SleepWorkerThreadsHint() + Activate() + Deactivate() +} + +func BtSetTaskScheduler(arg1 BtITaskScheduler) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btSetTaskScheduler_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func BtGetTaskScheduler() (_swig_ret BtITaskScheduler) { + var swig_r BtITaskScheduler + swig_r = (BtITaskScheduler)(SwigcptrBtITaskScheduler(C._wrap_btGetTaskScheduler_mbt_e879218550ba2e2b())) + return swig_r +} + +func BtGetSequentialTaskScheduler() (_swig_ret BtITaskScheduler) { + var swig_r BtITaskScheduler + swig_r = (BtITaskScheduler)(SwigcptrBtITaskScheduler(C._wrap_btGetSequentialTaskScheduler_mbt_e879218550ba2e2b())) + return swig_r +} + +func BtGetOpenMPTaskScheduler() (_swig_ret BtITaskScheduler) { + var swig_r BtITaskScheduler + swig_r = (BtITaskScheduler)(SwigcptrBtITaskScheduler(C._wrap_btGetOpenMPTaskScheduler_mbt_e879218550ba2e2b())) + return swig_r +} + +func BtGetTBBTaskScheduler() (_swig_ret BtITaskScheduler) { + var swig_r BtITaskScheduler + swig_r = (BtITaskScheduler)(SwigcptrBtITaskScheduler(C._wrap_btGetTBBTaskScheduler_mbt_e879218550ba2e2b())) + return swig_r +} + +func BtGetPPLTaskScheduler() (_swig_ret BtITaskScheduler) { + var swig_r BtITaskScheduler + swig_r = (BtITaskScheduler)(SwigcptrBtITaskScheduler(C._wrap_btGetPPLTaskScheduler_mbt_e879218550ba2e2b())) + return swig_r +} + +func BtParallelFor(arg1 int, arg2 int, arg3 int, arg4 BtIParallelForBody) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btParallelFor_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func BtParallelSum(arg1 int, arg2 int, arg3 int, arg4 BtIParallelSumBody) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + swig_r = (float32)(C._wrap_btParallelSum_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +type SwigcptrThreadsafeCounter uintptr + +func (p SwigcptrThreadsafeCounter) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrThreadsafeCounter) SwigIsThreadsafeCounter() { +} + +func (arg1 SwigcptrThreadsafeCounter) SetMCounter(arg2 uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_ThreadsafeCounter_mCounter_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrThreadsafeCounter) GetMCounter() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_ThreadsafeCounter_mCounter_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrThreadsafeCounter) SetMMutex(arg2 BtSpinMutex) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_ThreadsafeCounter_mMutex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrThreadsafeCounter) GetMMutex() (_swig_ret BtSpinMutex) { + var swig_r BtSpinMutex + _swig_i_0 := arg1 + swig_r = (BtSpinMutex)(SwigcptrBtSpinMutex(C._wrap_ThreadsafeCounter_mMutex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewThreadsafeCounter() (_swig_ret ThreadsafeCounter) { + var swig_r ThreadsafeCounter + swig_r = (ThreadsafeCounter)(SwigcptrThreadsafeCounter(C._wrap_new_ThreadsafeCounter_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrThreadsafeCounter) GetNext() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_ThreadsafeCounter_getNext_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteThreadsafeCounter(arg1 ThreadsafeCounter) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_ThreadsafeCounter_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type ThreadsafeCounter interface { + Swigcptr() uintptr + SwigIsThreadsafeCounter() + SetMCounter(arg2 uint) + GetMCounter() (_swig_ret uint) + SetMMutex(arg2 BtSpinMutex) + GetMMutex() (_swig_ret BtSpinMutex) + GetNext() (_swig_ret uint) +} + +func SetGBtTaskScheduler(arg1 BtITaskScheduler) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_gBtTaskScheduler_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func GetGBtTaskScheduler() (_swig_ret BtITaskScheduler) { + var swig_r BtITaskScheduler + swig_r = (BtITaskScheduler)(SwigcptrBtITaskScheduler(C._wrap_gBtTaskScheduler_get_mbt_e879218550ba2e2b())) + return swig_r +} + +func SetGThreadsRunningCounter(arg1 int) { + _swig_i_0 := arg1 + C._wrap_gThreadsRunningCounter_set_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0)) +} + +func GetGThreadsRunningCounter() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_gThreadsRunningCounter_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetGThreadsRunningCounterMutex(arg1 BtSpinMutex) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_gThreadsRunningCounterMutex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func GetGThreadsRunningCounterMutex() (_swig_ret BtSpinMutex) { + var swig_r BtSpinMutex + swig_r = (BtSpinMutex)(SwigcptrBtSpinMutex(C._wrap_gThreadsRunningCounterMutex_get_mbt_e879218550ba2e2b())) + return swig_r +} + +func SetGThreadCounter(arg1 ThreadsafeCounter) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_gThreadCounter_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func GetGThreadCounter() (_swig_ret ThreadsafeCounter) { + var swig_r ThreadsafeCounter + swig_r = (ThreadsafeCounter)(SwigcptrThreadsafeCounter(C._wrap_gThreadCounter_get_mbt_e879218550ba2e2b())) + return swig_r +} + +const BT_DETECT_BAD_THREAD_INDEX int = 0 + +func BtPushThreadsAreRunning() { + C._wrap_btPushThreadsAreRunning_mbt_e879218550ba2e2b() +} + +func BtPopThreadsAreRunning() { + C._wrap_btPopThreadsAreRunning_mbt_e879218550ba2e2b() +} + +type SwigcptrBtTaskSchedulerSequential uintptr + +func (p SwigcptrBtTaskSchedulerSequential) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTaskSchedulerSequential) SwigIsBtTaskSchedulerSequential() { +} + +func NewBtTaskSchedulerSequential() (_swig_ret BtTaskSchedulerSequential) { + var swig_r BtTaskSchedulerSequential + swig_r = (BtTaskSchedulerSequential)(SwigcptrBtTaskSchedulerSequential(C._wrap_new_btTaskSchedulerSequential_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtTaskSchedulerSequential) GetMaxNumThreads() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTaskSchedulerSequential_getMaxNumThreads_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTaskSchedulerSequential) GetNumThreads() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTaskSchedulerSequential_getNumThreads_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTaskSchedulerSequential) SetNumThreads(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTaskSchedulerSequential_setNumThreads_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTaskSchedulerSequential) ParallelFor(arg2 int, arg3 int, arg4 int, arg5 BtIParallelForBody) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btTaskSchedulerSequential_parallelFor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtTaskSchedulerSequential) ParallelSum(arg2 int, arg3 int, arg4 int, arg5 BtIParallelSumBody) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btTaskSchedulerSequential_parallelSum_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func DeleteBtTaskSchedulerSequential(arg1 BtTaskSchedulerSequential) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTaskSchedulerSequential_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtTaskSchedulerSequential) GetName() (_swig_ret string) { + var swig_r string + swig_r_p := C._wrap_btTaskSchedulerSequential_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtTaskSchedulerSequential) SleepWorkerThreadsHint() { + C._wrap_btTaskSchedulerSequential_sleepWorkerThreadsHint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtTaskSchedulerSequential) Activate() { + C._wrap_btTaskSchedulerSequential_activate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtTaskSchedulerSequential) Deactivate() { + C._wrap_btTaskSchedulerSequential_deactivate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (p SwigcptrBtTaskSchedulerSequential) SwigIsBtITaskScheduler() { +} + +func (p SwigcptrBtTaskSchedulerSequential) SwigGetBtITaskScheduler() BtITaskScheduler { + return SwigcptrBtITaskScheduler(getSwigcptr(p)) +} + +type BtTaskSchedulerSequential interface { + Swigcptr() uintptr + SwigIsBtTaskSchedulerSequential() + GetMaxNumThreads() (_swig_ret int) + GetNumThreads() (_swig_ret int) + SetNumThreads(arg2 int) + ParallelFor(arg2 int, arg3 int, arg4 int, arg5 BtIParallelForBody) + ParallelSum(arg2 int, arg3 int, arg4 int, arg5 BtIParallelSumBody) (_swig_ret float32) + GetName() (_swig_ret string) + SleepWorkerThreadsHint() + Activate() + Deactivate() + SwigIsBtITaskScheduler() + SwigGetBtITaskScheduler() BtITaskScheduler +} + +type SwigcptrBtDbvtTreeCollider uintptr + +func (p SwigcptrBtDbvtTreeCollider) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDbvtTreeCollider) SwigIsBtDbvtTreeCollider() { +} + +func (arg1 SwigcptrBtDbvtTreeCollider) SetPbp(arg2 BtDbvtBroadphase) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtTreeCollider_pbp_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtTreeCollider) GetPbp() (_swig_ret BtDbvtBroadphase) { + var swig_r BtDbvtBroadphase + _swig_i_0 := arg1 + swig_r = (BtDbvtBroadphase)(SwigcptrBtDbvtBroadphase(C._wrap_btDbvtTreeCollider_pbp_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtTreeCollider) SetProxy(arg2 BtDbvtProxy) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtTreeCollider_proxy_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDbvtTreeCollider) GetProxy() (_swig_ret BtDbvtProxy) { + var swig_r BtDbvtProxy + _swig_i_0 := arg1 + swig_r = (BtDbvtProxy)(SwigcptrBtDbvtProxy(C._wrap_btDbvtTreeCollider_proxy_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtDbvtTreeCollider(arg1 BtDbvtBroadphase) (_swig_ret BtDbvtTreeCollider) { + var swig_r BtDbvtTreeCollider + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtDbvtTreeCollider)(SwigcptrBtDbvtTreeCollider(C._wrap_new_btDbvtTreeCollider_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDbvtTreeCollider) Process__SWIG_0(arg2 BtDbvtNode, arg3 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDbvtTreeCollider_Process__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtDbvtTreeCollider) Process__SWIG_1(arg2 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDbvtTreeCollider_Process__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtDbvtTreeCollider) Process(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.Process__SWIG_1(a[0].(BtDbvtNode)) + return + } + if argc == 2 { + p.Process__SWIG_0(a[0].(BtDbvtNode), a[1].(BtDbvtNode)) + return + } + panic("No match for overloaded function call") +} + +func DeleteBtDbvtTreeCollider(arg1 BtDbvtTreeCollider) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDbvtTreeCollider_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtDbvtTreeCollider interface { + Swigcptr() uintptr + SwigIsBtDbvtTreeCollider() + SetPbp(arg2 BtDbvtBroadphase) + GetPbp() (_swig_ret BtDbvtBroadphase) + SetProxy(arg2 BtDbvtProxy) + GetProxy() (_swig_ret BtDbvtProxy) + Process(a ...interface{}) +} + +type SwigcptrBroadphaseRayTester uintptr + +func (p SwigcptrBroadphaseRayTester) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBroadphaseRayTester) SwigIsBroadphaseRayTester() { +} + +func (arg1 SwigcptrBroadphaseRayTester) SetM_rayCallback(arg2 BtBroadphaseRayCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_BroadphaseRayTester_m_rayCallback_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBroadphaseRayTester) GetM_rayCallback() (_swig_ret BtBroadphaseRayCallback) { + var swig_r BtBroadphaseRayCallback + _swig_i_0 := arg1 + swig_r = (BtBroadphaseRayCallback)(SwigcptrBtBroadphaseRayCallback(C._wrap_BroadphaseRayTester_m_rayCallback_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBroadphaseRayTester(arg1 BtBroadphaseRayCallback) (_swig_ret BroadphaseRayTester) { + var swig_r BroadphaseRayTester + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BroadphaseRayTester)(SwigcptrBroadphaseRayTester(C._wrap_new_BroadphaseRayTester_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBroadphaseRayTester) Process(arg2 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_BroadphaseRayTester_Process_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBroadphaseRayTester(arg1 BroadphaseRayTester) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_BroadphaseRayTester_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BroadphaseRayTester interface { + Swigcptr() uintptr + SwigIsBroadphaseRayTester() + SetM_rayCallback(arg2 BtBroadphaseRayCallback) + GetM_rayCallback() (_swig_ret BtBroadphaseRayCallback) + Process(arg2 BtDbvtNode) +} + +type SwigcptrBroadphaseAabbTester uintptr + +func (p SwigcptrBroadphaseAabbTester) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBroadphaseAabbTester) SwigIsBroadphaseAabbTester() { +} + +func (arg1 SwigcptrBroadphaseAabbTester) SetM_aabbCallback(arg2 BtBroadphaseAabbCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_BroadphaseAabbTester_m_aabbCallback_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBroadphaseAabbTester) GetM_aabbCallback() (_swig_ret BtBroadphaseAabbCallback) { + var swig_r BtBroadphaseAabbCallback + _swig_i_0 := arg1 + swig_r = (BtBroadphaseAabbCallback)(SwigcptrBtBroadphaseAabbCallback(C._wrap_BroadphaseAabbTester_m_aabbCallback_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBroadphaseAabbTester(arg1 BtBroadphaseAabbCallback) (_swig_ret BroadphaseAabbTester) { + var swig_r BroadphaseAabbTester + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BroadphaseAabbTester)(SwigcptrBroadphaseAabbTester(C._wrap_new_BroadphaseAabbTester_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBroadphaseAabbTester) Process(arg2 BtDbvtNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_BroadphaseAabbTester_Process_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBroadphaseAabbTester(arg1 BroadphaseAabbTester) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_BroadphaseAabbTester_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BroadphaseAabbTester interface { + Swigcptr() uintptr + SwigIsBroadphaseAabbTester() + SetM_aabbCallback(arg2 BtBroadphaseAabbCallback) + GetM_aabbCallback() (_swig_ret BtBroadphaseAabbCallback) + Process(arg2 BtDbvtNode) +} + +type SwigcptrBtDispatcherInfo uintptr + +func (p SwigcptrBtDispatcherInfo) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDispatcherInfo) SwigIsBtDispatcherInfo() { +} + +type BtDispatcherInfoDispatchFunc int + +func _swig_getbtDispatcherInfo_DISPATCH_DISCRETE_btDispatcherInfo() (_swig_ret BtDispatcherInfoDispatchFunc) { + var swig_r BtDispatcherInfoDispatchFunc + swig_r = (BtDispatcherInfoDispatchFunc)(C._wrap_DISPATCH_DISCRETE_btDispatcherInfo_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtDispatcherInfoDISPATCH_DISCRETE BtDispatcherInfoDispatchFunc = _swig_getbtDispatcherInfo_DISPATCH_DISCRETE_btDispatcherInfo() + +func _swig_getbtDispatcherInfo_DISPATCH_CONTINUOUS_btDispatcherInfo() (_swig_ret BtDispatcherInfoDispatchFunc) { + var swig_r BtDispatcherInfoDispatchFunc + swig_r = (BtDispatcherInfoDispatchFunc)(C._wrap_DISPATCH_CONTINUOUS_btDispatcherInfo_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtDispatcherInfoDISPATCH_CONTINUOUS BtDispatcherInfoDispatchFunc = _swig_getbtDispatcherInfo_DISPATCH_CONTINUOUS_btDispatcherInfo() + +func NewBtDispatcherInfo() (_swig_ret BtDispatcherInfo) { + var swig_r BtDispatcherInfo + swig_r = (BtDispatcherInfo)(SwigcptrBtDispatcherInfo(C._wrap_new_btDispatcherInfo_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_timeStep(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_timeStep_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_timeStep() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btDispatcherInfo_m_timeStep_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_stepCount(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_stepCount_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_stepCount() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDispatcherInfo_m_stepCount_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_dispatchFunc(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_dispatchFunc_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_dispatchFunc() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDispatcherInfo_m_dispatchFunc_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_timeOfImpact(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_timeOfImpact_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_timeOfImpact() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btDispatcherInfo_m_timeOfImpact_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_useContinuous(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_useContinuous_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_useContinuous() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDispatcherInfo_m_useContinuous_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_debugDraw(arg2 BtIDebugDraw) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDispatcherInfo_m_debugDraw_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_debugDraw() (_swig_ret BtIDebugDraw) { + var swig_r BtIDebugDraw + _swig_i_0 := arg1 + swig_r = (BtIDebugDraw)(SwigcptrBtIDebugDraw(C._wrap_btDispatcherInfo_m_debugDraw_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_enableSatConvex(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_enableSatConvex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_enableSatConvex() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDispatcherInfo_m_enableSatConvex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_enableSPU(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_enableSPU_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_enableSPU() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDispatcherInfo_m_enableSPU_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_useEpa(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_useEpa_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_useEpa() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDispatcherInfo_m_useEpa_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_allowedCcdPenetration(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_allowedCcdPenetration_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_allowedCcdPenetration() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btDispatcherInfo_m_allowedCcdPenetration_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_useConvexConservativeDistanceUtil(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_useConvexConservativeDistanceUtil_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_useConvexConservativeDistanceUtil() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDispatcherInfo_m_useConvexConservativeDistanceUtil_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_convexConservativeDistanceThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_convexConservativeDistanceThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_convexConservativeDistanceThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btDispatcherInfo_m_convexConservativeDistanceThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcherInfo) SetM_deterministicOverlappingPairs(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcherInfo_m_deterministicOverlappingPairs_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcherInfo) GetM_deterministicOverlappingPairs() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDispatcherInfo_m_deterministicOverlappingPairs_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtDispatcherInfo(arg1 BtDispatcherInfo) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDispatcherInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtDispatcherInfo interface { + Swigcptr() uintptr + SwigIsBtDispatcherInfo() + SetM_timeStep(arg2 float32) + GetM_timeStep() (_swig_ret float32) + SetM_stepCount(arg2 int) + GetM_stepCount() (_swig_ret int) + SetM_dispatchFunc(arg2 int) + GetM_dispatchFunc() (_swig_ret int) + SetM_timeOfImpact(arg2 float32) + GetM_timeOfImpact() (_swig_ret float32) + SetM_useContinuous(arg2 bool) + GetM_useContinuous() (_swig_ret bool) + SetM_debugDraw(arg2 BtIDebugDraw) + GetM_debugDraw() (_swig_ret BtIDebugDraw) + SetM_enableSatConvex(arg2 bool) + GetM_enableSatConvex() (_swig_ret bool) + SetM_enableSPU(arg2 bool) + GetM_enableSPU() (_swig_ret bool) + SetM_useEpa(arg2 bool) + GetM_useEpa() (_swig_ret bool) + SetM_allowedCcdPenetration(arg2 float32) + GetM_allowedCcdPenetration() (_swig_ret float32) + SetM_useConvexConservativeDistanceUtil(arg2 bool) + GetM_useConvexConservativeDistanceUtil() (_swig_ret bool) + SetM_convexConservativeDistanceThreshold(arg2 float32) + GetM_convexConservativeDistanceThreshold() (_swig_ret float32) + SetM_deterministicOverlappingPairs(arg2 bool) + GetM_deterministicOverlappingPairs() (_swig_ret bool) +} + +type EbtDispatcherQueryType int + +func _swig_getBT_CONTACT_POINT_ALGORITHMS() (_swig_ret EbtDispatcherQueryType) { + var swig_r EbtDispatcherQueryType + swig_r = (EbtDispatcherQueryType)(C._wrap_BT_CONTACT_POINT_ALGORITHMS_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONTACT_POINT_ALGORITHMS EbtDispatcherQueryType = _swig_getBT_CONTACT_POINT_ALGORITHMS() + +func _swig_getBT_CLOSEST_POINT_ALGORITHMS() (_swig_ret EbtDispatcherQueryType) { + var swig_r EbtDispatcherQueryType + swig_r = (EbtDispatcherQueryType)(C._wrap_BT_CLOSEST_POINT_ALGORITHMS_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CLOSEST_POINT_ALGORITHMS EbtDispatcherQueryType = _swig_getBT_CLOSEST_POINT_ALGORITHMS() + +type SwigcptrBtDispatcher uintptr + +func (p SwigcptrBtDispatcher) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDispatcher) SwigIsBtDispatcher() { +} + +func DeleteBtDispatcher(arg1 BtDispatcher) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDispatcher_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDispatcher) FindAlgorithm(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtPersistentManifold, arg5 EbtDispatcherQueryType) (_swig_ret BtCollisionAlgorithm) { + var swig_r BtCollisionAlgorithm + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (BtCollisionAlgorithm)(SwigcptrBtCollisionAlgorithm(C._wrap_btDispatcher_findAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_intgo(_swig_i_4)))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcher) GetNewManifold(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btDispatcher_getNewManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcher) ReleaseManifold(arg2 BtPersistentManifold) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDispatcher_releaseManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcher) ClearManifold(arg2 BtPersistentManifold) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDispatcher_clearManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDispatcher) NeedsCollision(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_btDispatcher_needsCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcher) NeedsResponse(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_btDispatcher_needsResponse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcher) DispatchAllCollisionPairs(arg2 BtOverlappingPairCache, arg3 BtDispatcherInfo, arg4 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDispatcher_dispatchAllCollisionPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtDispatcher) GetNumManifolds() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDispatcher_getNumManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcher) GetManifoldByIndexInternal(arg2 int) (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btDispatcher_getManifoldByIndexInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcher) GetInternalManifoldPointer() (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btDispatcher_getInternalManifoldPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcher) GetInternalManifoldPool__SWIG_0() (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_btDispatcher_getInternalManifoldPool__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcher) GetInternalManifoldPool__SWIG_1() (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_btDispatcher_getInternalManifoldPool__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtDispatcher) GetInternalManifoldPool(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetInternalManifoldPool__SWIG_0() + } + if argc == 0 { + return p.GetInternalManifoldPool__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDispatcher) AllocateCollisionAlgorithm(arg2 int) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (uintptr)(C._wrap_btDispatcher_allocateCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtDispatcher) FreeCollisionAlgorithm(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDispatcher_freeCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +type BtDispatcher interface { + Swigcptr() uintptr + SwigIsBtDispatcher() + FindAlgorithm(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtPersistentManifold, arg5 EbtDispatcherQueryType) (_swig_ret BtCollisionAlgorithm) + GetNewManifold(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret BtPersistentManifold) + ReleaseManifold(arg2 BtPersistentManifold) + ClearManifold(arg2 BtPersistentManifold) + NeedsCollision(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret bool) + NeedsResponse(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret bool) + DispatchAllCollisionPairs(arg2 BtOverlappingPairCache, arg3 BtDispatcherInfo, arg4 BtDispatcher) + GetNumManifolds() (_swig_ret int) + GetManifoldByIndexInternal(arg2 int) (_swig_ret BtPersistentManifold) + GetInternalManifoldPointer() (_swig_ret BtPersistentManifold) + GetInternalManifoldPool(a ...interface{}) interface{} + AllocateCollisionAlgorithm(arg2 int) (_swig_ret uintptr) + FreeCollisionAlgorithm(arg2 uintptr) +} + +type SwigcptrBtConstraintRow uintptr + +func (p SwigcptrBtConstraintRow) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConstraintRow) SwigIsBtConstraintRow() { +} + +func (arg1 SwigcptrBtConstraintRow) SetM_normal(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConstraintRow_m_normal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtConstraintRow) GetM_normal() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btConstraintRow_m_normal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConstraintRow) SetM_rhs(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConstraintRow_m_rhs_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConstraintRow) GetM_rhs() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConstraintRow_m_rhs_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConstraintRow) SetM_jacDiagInv(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConstraintRow_m_jacDiagInv_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConstraintRow) GetM_jacDiagInv() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConstraintRow_m_jacDiagInv_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConstraintRow) SetM_lowerLimit(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConstraintRow_m_lowerLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConstraintRow) GetM_lowerLimit() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConstraintRow_m_lowerLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConstraintRow) SetM_upperLimit(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConstraintRow_m_upperLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConstraintRow) GetM_upperLimit() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConstraintRow_m_upperLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConstraintRow) SetM_accumImpulse(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConstraintRow_m_accumImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConstraintRow) GetM_accumImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConstraintRow_m_accumImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtConstraintRow() (_swig_ret BtConstraintRow) { + var swig_r BtConstraintRow + swig_r = (BtConstraintRow)(SwigcptrBtConstraintRow(C._wrap_new_btConstraintRow_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtConstraintRow(arg1 BtConstraintRow) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConstraintRow_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtConstraintRow interface { + Swigcptr() uintptr + SwigIsBtConstraintRow() + SetM_normal(arg2 *float32) + GetM_normal() (_swig_ret *float32) + SetM_rhs(arg2 float32) + GetM_rhs() (_swig_ret float32) + SetM_jacDiagInv(arg2 float32) + GetM_jacDiagInv() (_swig_ret float32) + SetM_lowerLimit(arg2 float32) + GetM_lowerLimit() (_swig_ret float32) + SetM_upperLimit(arg2 float32) + GetM_upperLimit() (_swig_ret float32) + SetM_accumImpulse(arg2 float32) + GetM_accumImpulse() (_swig_ret float32) +} + +type BtContactPointFlags int + +func _swig_getBT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED() (_swig_ret BtContactPointFlags) { + var swig_r BtContactPointFlags + swig_r = (BtContactPointFlags)(C._wrap_BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED BtContactPointFlags = _swig_getBT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED() + +func _swig_getBT_CONTACT_FLAG_HAS_CONTACT_CFM() (_swig_ret BtContactPointFlags) { + var swig_r BtContactPointFlags + swig_r = (BtContactPointFlags)(C._wrap_BT_CONTACT_FLAG_HAS_CONTACT_CFM_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONTACT_FLAG_HAS_CONTACT_CFM BtContactPointFlags = _swig_getBT_CONTACT_FLAG_HAS_CONTACT_CFM() + +func _swig_getBT_CONTACT_FLAG_HAS_CONTACT_ERP() (_swig_ret BtContactPointFlags) { + var swig_r BtContactPointFlags + swig_r = (BtContactPointFlags)(C._wrap_BT_CONTACT_FLAG_HAS_CONTACT_ERP_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONTACT_FLAG_HAS_CONTACT_ERP BtContactPointFlags = _swig_getBT_CONTACT_FLAG_HAS_CONTACT_ERP() + +func _swig_getBT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING() (_swig_ret BtContactPointFlags) { + var swig_r BtContactPointFlags + swig_r = (BtContactPointFlags)(C._wrap_BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING BtContactPointFlags = _swig_getBT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING() + +func _swig_getBT_CONTACT_FLAG_FRICTION_ANCHOR() (_swig_ret BtContactPointFlags) { + var swig_r BtContactPointFlags + swig_r = (BtContactPointFlags)(C._wrap_BT_CONTACT_FLAG_FRICTION_ANCHOR_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONTACT_FLAG_FRICTION_ANCHOR BtContactPointFlags = _swig_getBT_CONTACT_FLAG_FRICTION_ANCHOR() + +type SwigcptrBtManifoldPoint uintptr + +func (p SwigcptrBtManifoldPoint) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtManifoldPoint) SwigIsBtManifoldPoint() { +} + +func NewBtManifoldPoint__SWIG_0() (_swig_ret BtManifoldPoint) { + var swig_r BtManifoldPoint + swig_r = (BtManifoldPoint)(SwigcptrBtManifoldPoint(C._wrap_new_btManifoldPoint__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtManifoldPoint__SWIG_1(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 float32) (_swig_ret BtManifoldPoint) { + var swig_r BtManifoldPoint + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + swig_r = (BtManifoldPoint)(SwigcptrBtManifoldPoint(C._wrap_new_btManifoldPoint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)))) + return swig_r +} + +func NewBtManifoldPoint(a ...interface{}) BtManifoldPoint { + argc := len(a) + if argc == 0 { + return NewBtManifoldPoint__SWIG_0() + } + if argc == 4 { + return NewBtManifoldPoint__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_localPointA(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btManifoldPoint_m_localPointA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_localPointA() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btManifoldPoint_m_localPointA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_localPointB(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btManifoldPoint_m_localPointB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_localPointB() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btManifoldPoint_m_localPointB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_positionWorldOnB(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btManifoldPoint_m_positionWorldOnB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_positionWorldOnB() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btManifoldPoint_m_positionWorldOnB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_positionWorldOnA(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btManifoldPoint_m_positionWorldOnA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_positionWorldOnA() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btManifoldPoint_m_positionWorldOnA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_normalWorldOnB(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btManifoldPoint_m_normalWorldOnB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_normalWorldOnB() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btManifoldPoint_m_normalWorldOnB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_distance1(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_distance1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_distance1() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_distance1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_combinedFriction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_combinedFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_combinedFriction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_combinedFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_combinedRollingFriction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_combinedRollingFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_combinedRollingFriction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_combinedRollingFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_combinedSpinningFriction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_combinedSpinningFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_combinedSpinningFriction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_combinedSpinningFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_combinedRestitution(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_combinedRestitution_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_combinedRestitution() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_combinedRestitution_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_partId0(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_partId0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_partId0() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btManifoldPoint_m_partId0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_partId1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_partId1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_partId1() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btManifoldPoint_m_partId1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_index0(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_index0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_index0() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btManifoldPoint_m_index0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_index1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_index1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_index1() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btManifoldPoint_m_index1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_userPersistentData(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_userPersistentData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_userPersistentData() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btManifoldPoint_m_userPersistentData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_contactPointFlags(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_contactPointFlags_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_contactPointFlags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btManifoldPoint_m_contactPointFlags_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_appliedImpulse(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_appliedImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_appliedImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_appliedImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_prevRHS(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_prevRHS_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_prevRHS() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_prevRHS_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_appliedImpulseLateral1(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_appliedImpulseLateral1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_appliedImpulseLateral1() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_appliedImpulseLateral1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_appliedImpulseLateral2(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_appliedImpulseLateral2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_appliedImpulseLateral2() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_appliedImpulseLateral2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_contactMotion1(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_contactMotion1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_contactMotion1() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_contactMotion1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_contactMotion2(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_contactMotion2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_contactMotion2() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_contactMotion2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_frictionCFM(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_frictionCFM_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_frictionCFM() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_m_frictionCFM_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_lifeTime(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_m_lifeTime_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_lifeTime() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btManifoldPoint_m_lifeTime_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_lateralFrictionDir1(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btManifoldPoint_m_lateralFrictionDir1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_lateralFrictionDir1() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btManifoldPoint_m_lateralFrictionDir1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetM_lateralFrictionDir2(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btManifoldPoint_m_lateralFrictionDir2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetM_lateralFrictionDir2() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btManifoldPoint_m_lateralFrictionDir2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) GetDistance() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_getDistance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) GetLifeTime() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btManifoldPoint_getLifeTime_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) GetPositionWorldOnA() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btManifoldPoint_getPositionWorldOnA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) GetPositionWorldOnB() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btManifoldPoint_getPositionWorldOnB_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldPoint) SetDistance(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldPoint_setDistance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldPoint) GetAppliedImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldPoint_getAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtManifoldPoint(arg1 BtManifoldPoint) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btManifoldPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtManifoldPoint interface { + Swigcptr() uintptr + SwigIsBtManifoldPoint() + SetM_localPointA(arg2 BtVector3) + GetM_localPointA() (_swig_ret BtVector3) + SetM_localPointB(arg2 BtVector3) + GetM_localPointB() (_swig_ret BtVector3) + SetM_positionWorldOnB(arg2 BtVector3) + GetM_positionWorldOnB() (_swig_ret BtVector3) + SetM_positionWorldOnA(arg2 BtVector3) + GetM_positionWorldOnA() (_swig_ret BtVector3) + SetM_normalWorldOnB(arg2 BtVector3) + GetM_normalWorldOnB() (_swig_ret BtVector3) + SetM_distance1(arg2 float32) + GetM_distance1() (_swig_ret float32) + SetM_combinedFriction(arg2 float32) + GetM_combinedFriction() (_swig_ret float32) + SetM_combinedRollingFriction(arg2 float32) + GetM_combinedRollingFriction() (_swig_ret float32) + SetM_combinedSpinningFriction(arg2 float32) + GetM_combinedSpinningFriction() (_swig_ret float32) + SetM_combinedRestitution(arg2 float32) + GetM_combinedRestitution() (_swig_ret float32) + SetM_partId0(arg2 int) + GetM_partId0() (_swig_ret int) + SetM_partId1(arg2 int) + GetM_partId1() (_swig_ret int) + SetM_index0(arg2 int) + GetM_index0() (_swig_ret int) + SetM_index1(arg2 int) + GetM_index1() (_swig_ret int) + SetM_userPersistentData(arg2 uintptr) + GetM_userPersistentData() (_swig_ret uintptr) + SetM_contactPointFlags(arg2 int) + GetM_contactPointFlags() (_swig_ret int) + SetM_appliedImpulse(arg2 float32) + GetM_appliedImpulse() (_swig_ret float32) + SetM_prevRHS(arg2 float32) + GetM_prevRHS() (_swig_ret float32) + SetM_appliedImpulseLateral1(arg2 float32) + GetM_appliedImpulseLateral1() (_swig_ret float32) + SetM_appliedImpulseLateral2(arg2 float32) + GetM_appliedImpulseLateral2() (_swig_ret float32) + SetM_contactMotion1(arg2 float32) + GetM_contactMotion1() (_swig_ret float32) + SetM_contactMotion2(arg2 float32) + GetM_contactMotion2() (_swig_ret float32) + SetM_frictionCFM(arg2 float32) + GetM_frictionCFM() (_swig_ret float32) + SetM_lifeTime(arg2 int) + GetM_lifeTime() (_swig_ret int) + SetM_lateralFrictionDir1(arg2 BtVector3) + GetM_lateralFrictionDir1() (_swig_ret BtVector3) + SetM_lateralFrictionDir2(arg2 BtVector3) + GetM_lateralFrictionDir2() (_swig_ret BtVector3) + GetDistance() (_swig_ret float32) + GetLifeTime() (_swig_ret int) + GetPositionWorldOnA() (_swig_ret BtVector3) + GetPositionWorldOnB() (_swig_ret BtVector3) + SetDistance(arg2 float32) + GetAppliedImpulse() (_swig_ret float32) +} + +func SetGContactBreakingThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_gContactBreakingThreshold_set_mbt_e879218550ba2e2b(C.float(_swig_i_0)) +} + +func GetGContactBreakingThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_gContactBreakingThreshold_get_mbt_e879218550ba2e2b()) + return swig_r +} + +type BtContactManifoldTypes int + +func _swig_getMIN_CONTACT_MANIFOLD_TYPE() (_swig_ret BtContactManifoldTypes) { + var swig_r BtContactManifoldTypes + swig_r = (BtContactManifoldTypes)(C._wrap_MIN_CONTACT_MANIFOLD_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var MIN_CONTACT_MANIFOLD_TYPE BtContactManifoldTypes = _swig_getMIN_CONTACT_MANIFOLD_TYPE() + +func _swig_getBT_PERSISTENT_MANIFOLD_TYPE() (_swig_ret BtContactManifoldTypes) { + var swig_r BtContactManifoldTypes + swig_r = (BtContactManifoldTypes)(C._wrap_BT_PERSISTENT_MANIFOLD_TYPE_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_PERSISTENT_MANIFOLD_TYPE BtContactManifoldTypes = _swig_getBT_PERSISTENT_MANIFOLD_TYPE() + +const MANIFOLD_CACHE_SIZE int = 4 + +type SwigcptrBtPersistentManifold uintptr + +func (p SwigcptrBtPersistentManifold) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtPersistentManifold) SwigIsBtPersistentManifold() { +} + +func (arg1 SwigcptrBtPersistentManifold) SetM_companionIdA(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifold_m_companionIdA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifold) GetM_companionIdA() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifold_m_companionIdA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) SetM_companionIdB(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifold_m_companionIdB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifold) GetM_companionIdB() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifold_m_companionIdB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) SetM_index1a(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifold_m_index1a_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifold) GetM_index1a() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifold_m_index1a_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtPersistentManifold__SWIG_0() (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_new_btPersistentManifold__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtPersistentManifold__SWIG_1(arg1 BtCollisionObject, arg2 BtCollisionObject, arg3 int, arg4 float32, arg5 float32) (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_new_btPersistentManifold__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4)))) + return swig_r +} + +func NewBtPersistentManifold(a ...interface{}) BtPersistentManifold { + argc := len(a) + if argc == 0 { + return NewBtPersistentManifold__SWIG_0() + } + if argc == 5 { + return NewBtPersistentManifold__SWIG_1(a[0].(BtCollisionObject), a[1].(BtCollisionObject), a[2].(int), a[3].(float32), a[4].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtPersistentManifold) GetBody0() (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + _swig_i_0 := arg1 + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_btPersistentManifold_getBody0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) GetBody1() (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + _swig_i_0 := arg1 + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_btPersistentManifold_getBody1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) SetBodies(arg2 BtCollisionObject, arg3 BtCollisionObject) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btPersistentManifold_setBodies_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtPersistentManifold) ClearUserCache(arg2 BtManifoldPoint) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifold_clearUserCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifold) GetNumContacts() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifold_getNumContacts_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) SetNumContacts(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifold_setNumContacts_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifold) GetContactPoint__SWIG_0(arg2 int) (_swig_ret BtManifoldPoint) { + var swig_r BtManifoldPoint + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtManifoldPoint)(SwigcptrBtManifoldPoint(C._wrap_btPersistentManifold_getContactPoint__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) GetContactPoint__SWIG_1(arg2 int) (_swig_ret BtManifoldPoint) { + var swig_r BtManifoldPoint + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtManifoldPoint)(SwigcptrBtManifoldPoint(C._wrap_btPersistentManifold_getContactPoint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (p SwigcptrBtPersistentManifold) GetContactPoint(a ...interface{}) interface{} { + argc := len(a) + if argc == 1 { + return p.GetContactPoint__SWIG_0(a[0].(int)) + } + if argc == 1 { + return p.GetContactPoint__SWIG_1(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtPersistentManifold) GetContactBreakingThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btPersistentManifold_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) GetContactProcessingThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btPersistentManifold_getContactProcessingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) SetContactBreakingThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifold_setContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifold) SetContactProcessingThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifold_setContactProcessingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifold) GetCacheEntry(arg2 BtManifoldPoint) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (int)(C._wrap_btPersistentManifold_getCacheEntry_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) AddManifoldPoint__SWIG_0(arg2 BtManifoldPoint, arg3 bool) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (int)(C._wrap_btPersistentManifold_addManifoldPoint__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C._Bool(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) AddManifoldPoint__SWIG_1(arg2 BtManifoldPoint) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (int)(C._wrap_btPersistentManifold_addManifoldPoint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (p SwigcptrBtPersistentManifold) AddManifoldPoint(a ...interface{}) int { + argc := len(a) + if argc == 1 { + return p.AddManifoldPoint__SWIG_1(a[0].(BtManifoldPoint)) + } + if argc == 2 { + return p.AddManifoldPoint__SWIG_0(a[0].(BtManifoldPoint), a[1].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtPersistentManifold) RemoveContactPoint(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifold_removeContactPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifold) ReplaceContactPoint(arg2 BtManifoldPoint, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btPersistentManifold_replaceContactPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtPersistentManifold) ValidContactDistance(arg2 BtManifoldPoint) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btPersistentManifold_validContactDistance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) RefreshContactPoints(arg2 BtTransform, arg3 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btPersistentManifold_refreshContactPoints_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtPersistentManifold) ClearManifold() { + _swig_i_0 := arg1 + C._wrap_btPersistentManifold_clearManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtPersistentManifold) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifold_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifold) Serialize(arg2 BtPersistentManifold, arg3 uintptr, arg4 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + swig_r_p := C._wrap_btPersistentManifold_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtPersistentManifold) DeSerialize__SWIG_0(arg2 BtPersistentManifoldDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifold_deSerialize__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifold) DeSerialize__SWIG_1(arg2 BtPersistentManifoldFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifold_deSerialize__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtPersistentManifold) DeSerialize(a ...interface{}) { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(SwigcptrBtPersistentManifoldDoubleData); !ok { + goto check_1 + } + p.DeSerialize__SWIG_0(a[0].(BtPersistentManifoldDoubleData)) + return + } +check_1: + if argc == 1 { + p.DeSerialize__SWIG_1(a[0].(BtPersistentManifoldFloatData)) + return + } + panic("No match for overloaded function call") +} + +func DeleteBtPersistentManifold(arg1 BtPersistentManifold) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btPersistentManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPersistentManifold) SetM_objectType(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtPersistentManifold_M_objectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtPersistentManifold) GetM_objectType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtPersistentManifold_M_objectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtPersistentManifold) GetObjectType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btPersistentManifold_getObjectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtPersistentManifold) SwigIsBtTypedObject() { +} + +func (p SwigcptrBtPersistentManifold) SwigGetBtTypedObject() BtTypedObject { + return SwigcptrBtTypedObject(getSwigcptr(p)) +} + +type BtPersistentManifold interface { + Swigcptr() uintptr + SwigIsBtPersistentManifold() + SetM_companionIdA(arg2 int) + GetM_companionIdA() (_swig_ret int) + SetM_companionIdB(arg2 int) + GetM_companionIdB() (_swig_ret int) + SetM_index1a(arg2 int) + GetM_index1a() (_swig_ret int) + GetBody0() (_swig_ret BtCollisionObject) + GetBody1() (_swig_ret BtCollisionObject) + SetBodies(arg2 BtCollisionObject, arg3 BtCollisionObject) + ClearUserCache(arg2 BtManifoldPoint) + GetNumContacts() (_swig_ret int) + SetNumContacts(arg2 int) + GetContactPoint(a ...interface{}) interface{} + GetContactBreakingThreshold() (_swig_ret float32) + GetContactProcessingThreshold() (_swig_ret float32) + SetContactBreakingThreshold(arg2 float32) + SetContactProcessingThreshold(arg2 float32) + GetCacheEntry(arg2 BtManifoldPoint) (_swig_ret int) + AddManifoldPoint(a ...interface{}) int + RemoveContactPoint(arg2 int) + ReplaceContactPoint(arg2 BtManifoldPoint, arg3 int) + ValidContactDistance(arg2 BtManifoldPoint) (_swig_ret bool) + RefreshContactPoints(arg2 BtTransform, arg3 BtTransform) + ClearManifold() + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 BtPersistentManifold, arg3 uintptr, arg4 BtSerializer) (_swig_ret string) + DeSerialize(a ...interface{}) + SetM_objectType(arg1 int) + GetM_objectType() (_swig_ret int) + GetObjectType() (_swig_ret int) + SwigIsBtTypedObject() + SwigGetBtTypedObject() BtTypedObject +} + +type SwigcptrBtPersistentManifoldDoubleData uintptr + +func (p SwigcptrBtPersistentManifoldDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtPersistentManifoldDoubleData) SwigIsBtPersistentManifoldDoubleData() { +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheLocalPointA(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheLocalPointA() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheLocalPointB(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheLocalPointB() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btPersistentManifoldDoubleData_m_pointCacheLocalPointB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCachePositionWorldOnA(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCachePositionWorldOnA() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCachePositionWorldOnB(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCachePositionWorldOnB() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btPersistentManifoldDoubleData_m_pointCachePositionWorldOnB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheNormalWorldOnB(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldDoubleData_m_pointCacheNormalWorldOnB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheNormalWorldOnB() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btPersistentManifoldDoubleData_m_pointCacheNormalWorldOnB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheLateralFrictionDir1(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheLateralFrictionDir1() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheLateralFrictionDir2(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheLateralFrictionDir2() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btPersistentManifoldDoubleData_m_pointCacheLateralFrictionDir2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheDistance(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheDistance_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheDistance() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheDistance_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheAppliedImpulse(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheAppliedImpulse() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCachePrevRHS(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCachePrevRHS_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCachePrevRHS() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCachePrevRHS_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheCombinedFriction(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheCombinedFriction() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheCombinedRollingFriction(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRollingFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheCombinedRollingFriction() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRollingFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheCombinedSpinningFriction(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedSpinningFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheCombinedSpinningFriction() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedSpinningFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheCombinedRestitution(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRestitution_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheCombinedRestitution() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedRestitution_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCachePartId0(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCachePartId0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCachePartId0() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldDoubleData_m_pointCachePartId0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCachePartId1(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCachePartId1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCachePartId1() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldDoubleData_m_pointCachePartId1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheIndex0(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheIndex0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheIndex0() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheIndex0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheIndex1(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheIndex1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheIndex1() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheIndex1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheContactPointFlags(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheContactPointFlags_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheContactPointFlags() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheContactPointFlags_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheAppliedImpulseLateral1(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheAppliedImpulseLateral1() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheAppliedImpulseLateral2(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheAppliedImpulseLateral2() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheAppliedImpulseLateral2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheContactMotion1(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheContactMotion1() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheContactMotion2(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheContactMotion2() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheContactMotion2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheContactCFM(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheContactCFM_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheContactCFM() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheContactCFM_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheCombinedContactStiffness1(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactStiffness1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheCombinedContactStiffness1() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactStiffness1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheContactERP(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheContactERP_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheContactERP() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheContactERP_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheCombinedContactDamping1(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactDamping1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheCombinedContactDamping1() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheCombinedContactDamping1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheFrictionCFM(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheFrictionCFM_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheFrictionCFM() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheFrictionCFM_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_pointCacheLifeTime(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_pointCacheLifeTime_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_pointCacheLifeTime() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldDoubleData_m_pointCacheLifeTime_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_numCachedPoints(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_numCachedPoints_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_numCachedPoints() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldDoubleData_m_numCachedPoints_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_companionIdA(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_companionIdA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_companionIdA() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldDoubleData_m_companionIdA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_companionIdB(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_companionIdB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_companionIdB() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldDoubleData_m_companionIdB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_index1a(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_index1a_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_index1a() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldDoubleData_m_index1a_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_objectType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_objectType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_objectType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldDoubleData_m_objectType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_contactBreakingThreshold(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_contactBreakingThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_contactBreakingThreshold() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btPersistentManifoldDoubleData_m_contactBreakingThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_contactProcessingThreshold(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_contactProcessingThreshold() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btPersistentManifoldDoubleData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_padding(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldDoubleData_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_padding() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldDoubleData_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_body0(arg2 BtCollisionObjectDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldDoubleData_m_body0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_body0() (_swig_ret BtCollisionObjectDoubleData) { + var swig_r BtCollisionObjectDoubleData + _swig_i_0 := arg1 + swig_r = (BtCollisionObjectDoubleData)(SwigcptrBtCollisionObjectDoubleData(C._wrap_btPersistentManifoldDoubleData_m_body0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) SetM_body1(arg2 BtCollisionObjectDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldDoubleData_m_body1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldDoubleData) GetM_body1() (_swig_ret BtCollisionObjectDoubleData) { + var swig_r BtCollisionObjectDoubleData + _swig_i_0 := arg1 + swig_r = (BtCollisionObjectDoubleData)(SwigcptrBtCollisionObjectDoubleData(C._wrap_btPersistentManifoldDoubleData_m_body1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtPersistentManifoldDoubleData() (_swig_ret BtPersistentManifoldDoubleData) { + var swig_r BtPersistentManifoldDoubleData + swig_r = (BtPersistentManifoldDoubleData)(SwigcptrBtPersistentManifoldDoubleData(C._wrap_new_btPersistentManifoldDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtPersistentManifoldDoubleData(arg1 BtPersistentManifoldDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btPersistentManifoldDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtPersistentManifoldDoubleData interface { + Swigcptr() uintptr + SwigIsBtPersistentManifoldDoubleData() + SetM_pointCacheLocalPointA(arg2 BtVector3DoubleData) + GetM_pointCacheLocalPointA() (_swig_ret BtVector3DoubleData) + SetM_pointCacheLocalPointB(arg2 BtVector3DoubleData) + GetM_pointCacheLocalPointB() (_swig_ret BtVector3DoubleData) + SetM_pointCachePositionWorldOnA(arg2 BtVector3DoubleData) + GetM_pointCachePositionWorldOnA() (_swig_ret BtVector3DoubleData) + SetM_pointCachePositionWorldOnB(arg2 BtVector3DoubleData) + GetM_pointCachePositionWorldOnB() (_swig_ret BtVector3DoubleData) + SetM_pointCacheNormalWorldOnB(arg2 BtVector3DoubleData) + GetM_pointCacheNormalWorldOnB() (_swig_ret BtVector3DoubleData) + SetM_pointCacheLateralFrictionDir1(arg2 BtVector3DoubleData) + GetM_pointCacheLateralFrictionDir1() (_swig_ret BtVector3DoubleData) + SetM_pointCacheLateralFrictionDir2(arg2 BtVector3DoubleData) + GetM_pointCacheLateralFrictionDir2() (_swig_ret BtVector3DoubleData) + SetM_pointCacheDistance(arg2 *float64) + GetM_pointCacheDistance() (_swig_ret *float64) + SetM_pointCacheAppliedImpulse(arg2 *float64) + GetM_pointCacheAppliedImpulse() (_swig_ret *float64) + SetM_pointCachePrevRHS(arg2 *float64) + GetM_pointCachePrevRHS() (_swig_ret *float64) + SetM_pointCacheCombinedFriction(arg2 *float64) + GetM_pointCacheCombinedFriction() (_swig_ret *float64) + SetM_pointCacheCombinedRollingFriction(arg2 *float64) + GetM_pointCacheCombinedRollingFriction() (_swig_ret *float64) + SetM_pointCacheCombinedSpinningFriction(arg2 *float64) + GetM_pointCacheCombinedSpinningFriction() (_swig_ret *float64) + SetM_pointCacheCombinedRestitution(arg2 *float64) + GetM_pointCacheCombinedRestitution() (_swig_ret *float64) + SetM_pointCachePartId0(arg2 *int) + GetM_pointCachePartId0() (_swig_ret *int) + SetM_pointCachePartId1(arg2 *int) + GetM_pointCachePartId1() (_swig_ret *int) + SetM_pointCacheIndex0(arg2 *int) + GetM_pointCacheIndex0() (_swig_ret *int) + SetM_pointCacheIndex1(arg2 *int) + GetM_pointCacheIndex1() (_swig_ret *int) + SetM_pointCacheContactPointFlags(arg2 *int) + GetM_pointCacheContactPointFlags() (_swig_ret *int) + SetM_pointCacheAppliedImpulseLateral1(arg2 *float64) + GetM_pointCacheAppliedImpulseLateral1() (_swig_ret *float64) + SetM_pointCacheAppliedImpulseLateral2(arg2 *float64) + GetM_pointCacheAppliedImpulseLateral2() (_swig_ret *float64) + SetM_pointCacheContactMotion1(arg2 *float64) + GetM_pointCacheContactMotion1() (_swig_ret *float64) + SetM_pointCacheContactMotion2(arg2 *float64) + GetM_pointCacheContactMotion2() (_swig_ret *float64) + SetM_pointCacheContactCFM(arg2 *float64) + GetM_pointCacheContactCFM() (_swig_ret *float64) + SetM_pointCacheCombinedContactStiffness1(arg2 *float64) + GetM_pointCacheCombinedContactStiffness1() (_swig_ret *float64) + SetM_pointCacheContactERP(arg2 *float64) + GetM_pointCacheContactERP() (_swig_ret *float64) + SetM_pointCacheCombinedContactDamping1(arg2 *float64) + GetM_pointCacheCombinedContactDamping1() (_swig_ret *float64) + SetM_pointCacheFrictionCFM(arg2 *float64) + GetM_pointCacheFrictionCFM() (_swig_ret *float64) + SetM_pointCacheLifeTime(arg2 *int) + GetM_pointCacheLifeTime() (_swig_ret *int) + SetM_numCachedPoints(arg2 int) + GetM_numCachedPoints() (_swig_ret int) + SetM_companionIdA(arg2 int) + GetM_companionIdA() (_swig_ret int) + SetM_companionIdB(arg2 int) + GetM_companionIdB() (_swig_ret int) + SetM_index1a(arg2 int) + GetM_index1a() (_swig_ret int) + SetM_objectType(arg2 int) + GetM_objectType() (_swig_ret int) + SetM_contactBreakingThreshold(arg2 float64) + GetM_contactBreakingThreshold() (_swig_ret float64) + SetM_contactProcessingThreshold(arg2 float64) + GetM_contactProcessingThreshold() (_swig_ret float64) + SetM_padding(arg2 int) + GetM_padding() (_swig_ret int) + SetM_body0(arg2 BtCollisionObjectDoubleData) + GetM_body0() (_swig_ret BtCollisionObjectDoubleData) + SetM_body1(arg2 BtCollisionObjectDoubleData) + GetM_body1() (_swig_ret BtCollisionObjectDoubleData) +} + +type SwigcptrBtPersistentManifoldFloatData uintptr + +func (p SwigcptrBtPersistentManifoldFloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtPersistentManifoldFloatData) SwigIsBtPersistentManifoldFloatData() { +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheLocalPointA(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheLocalPointA() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheLocalPointB(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheLocalPointB() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btPersistentManifoldFloatData_m_pointCacheLocalPointB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCachePositionWorldOnA(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCachePositionWorldOnA() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCachePositionWorldOnB(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCachePositionWorldOnB() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btPersistentManifoldFloatData_m_pointCachePositionWorldOnB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheNormalWorldOnB(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldFloatData_m_pointCacheNormalWorldOnB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheNormalWorldOnB() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btPersistentManifoldFloatData_m_pointCacheNormalWorldOnB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheLateralFrictionDir1(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheLateralFrictionDir1() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheLateralFrictionDir2(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheLateralFrictionDir2() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btPersistentManifoldFloatData_m_pointCacheLateralFrictionDir2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheDistance(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheDistance_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheDistance() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheDistance_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheAppliedImpulse(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheAppliedImpulse() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCachePrevRHS(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCachePrevRHS_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCachePrevRHS() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCachePrevRHS_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheCombinedFriction(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheCombinedFriction() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheCombinedRollingFriction(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRollingFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheCombinedRollingFriction() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRollingFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheCombinedSpinningFriction(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedSpinningFriction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheCombinedSpinningFriction() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedSpinningFriction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheCombinedRestitution(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRestitution_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheCombinedRestitution() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedRestitution_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCachePartId0(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCachePartId0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCachePartId0() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldFloatData_m_pointCachePartId0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCachePartId1(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCachePartId1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCachePartId1() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldFloatData_m_pointCachePartId1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheIndex0(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheIndex0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheIndex0() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldFloatData_m_pointCacheIndex0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheIndex1(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheIndex1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheIndex1() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldFloatData_m_pointCacheIndex1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheContactPointFlags(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheContactPointFlags_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheContactPointFlags() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldFloatData_m_pointCacheContactPointFlags_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheAppliedImpulseLateral1(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheAppliedImpulseLateral1() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheAppliedImpulseLateral2(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheAppliedImpulseLateral2() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheAppliedImpulseLateral2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheContactMotion1(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheContactMotion1() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheContactMotion2(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheContactMotion2() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheContactMotion2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheContactCFM(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheContactCFM_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheContactCFM() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheContactCFM_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheCombinedContactStiffness1(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactStiffness1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheCombinedContactStiffness1() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactStiffness1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheContactERP(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheContactERP_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheContactERP() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheContactERP_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheCombinedContactDamping1(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactDamping1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheCombinedContactDamping1() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheCombinedContactDamping1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheFrictionCFM(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheFrictionCFM_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheFrictionCFM() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btPersistentManifoldFloatData_m_pointCacheFrictionCFM_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_pointCacheLifeTime(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_pointCacheLifeTime_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_pointCacheLifeTime() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btPersistentManifoldFloatData_m_pointCacheLifeTime_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_numCachedPoints(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_numCachedPoints_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_numCachedPoints() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldFloatData_m_numCachedPoints_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_companionIdA(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_companionIdA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_companionIdA() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldFloatData_m_companionIdA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_companionIdB(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_companionIdB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_companionIdB() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldFloatData_m_companionIdB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_index1a(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_index1a_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_index1a() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldFloatData_m_index1a_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_objectType(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_objectType_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_objectType() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldFloatData_m_objectType_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_contactBreakingThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_contactBreakingThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_contactBreakingThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btPersistentManifoldFloatData_m_contactBreakingThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_contactProcessingThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_contactProcessingThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_contactProcessingThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btPersistentManifoldFloatData_m_contactProcessingThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_padding(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPersistentManifoldFloatData_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_padding() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPersistentManifoldFloatData_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_body0(arg2 BtCollisionObjectFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldFloatData_m_body0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_body0() (_swig_ret BtCollisionObjectFloatData) { + var swig_r BtCollisionObjectFloatData + _swig_i_0 := arg1 + swig_r = (BtCollisionObjectFloatData)(SwigcptrBtCollisionObjectFloatData(C._wrap_btPersistentManifoldFloatData_m_body0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) SetM_body1(arg2 BtCollisionObjectFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btPersistentManifoldFloatData_m_body1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPersistentManifoldFloatData) GetM_body1() (_swig_ret BtCollisionObjectFloatData) { + var swig_r BtCollisionObjectFloatData + _swig_i_0 := arg1 + swig_r = (BtCollisionObjectFloatData)(SwigcptrBtCollisionObjectFloatData(C._wrap_btPersistentManifoldFloatData_m_body1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtPersistentManifoldFloatData() (_swig_ret BtPersistentManifoldFloatData) { + var swig_r BtPersistentManifoldFloatData + swig_r = (BtPersistentManifoldFloatData)(SwigcptrBtPersistentManifoldFloatData(C._wrap_new_btPersistentManifoldFloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtPersistentManifoldFloatData(arg1 BtPersistentManifoldFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btPersistentManifoldFloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtPersistentManifoldFloatData interface { + Swigcptr() uintptr + SwigIsBtPersistentManifoldFloatData() + SetM_pointCacheLocalPointA(arg2 BtVector3FloatData) + GetM_pointCacheLocalPointA() (_swig_ret BtVector3FloatData) + SetM_pointCacheLocalPointB(arg2 BtVector3FloatData) + GetM_pointCacheLocalPointB() (_swig_ret BtVector3FloatData) + SetM_pointCachePositionWorldOnA(arg2 BtVector3FloatData) + GetM_pointCachePositionWorldOnA() (_swig_ret BtVector3FloatData) + SetM_pointCachePositionWorldOnB(arg2 BtVector3FloatData) + GetM_pointCachePositionWorldOnB() (_swig_ret BtVector3FloatData) + SetM_pointCacheNormalWorldOnB(arg2 BtVector3FloatData) + GetM_pointCacheNormalWorldOnB() (_swig_ret BtVector3FloatData) + SetM_pointCacheLateralFrictionDir1(arg2 BtVector3FloatData) + GetM_pointCacheLateralFrictionDir1() (_swig_ret BtVector3FloatData) + SetM_pointCacheLateralFrictionDir2(arg2 BtVector3FloatData) + GetM_pointCacheLateralFrictionDir2() (_swig_ret BtVector3FloatData) + SetM_pointCacheDistance(arg2 *float32) + GetM_pointCacheDistance() (_swig_ret *float32) + SetM_pointCacheAppliedImpulse(arg2 *float32) + GetM_pointCacheAppliedImpulse() (_swig_ret *float32) + SetM_pointCachePrevRHS(arg2 *float32) + GetM_pointCachePrevRHS() (_swig_ret *float32) + SetM_pointCacheCombinedFriction(arg2 *float32) + GetM_pointCacheCombinedFriction() (_swig_ret *float32) + SetM_pointCacheCombinedRollingFriction(arg2 *float32) + GetM_pointCacheCombinedRollingFriction() (_swig_ret *float32) + SetM_pointCacheCombinedSpinningFriction(arg2 *float32) + GetM_pointCacheCombinedSpinningFriction() (_swig_ret *float32) + SetM_pointCacheCombinedRestitution(arg2 *float32) + GetM_pointCacheCombinedRestitution() (_swig_ret *float32) + SetM_pointCachePartId0(arg2 *int) + GetM_pointCachePartId0() (_swig_ret *int) + SetM_pointCachePartId1(arg2 *int) + GetM_pointCachePartId1() (_swig_ret *int) + SetM_pointCacheIndex0(arg2 *int) + GetM_pointCacheIndex0() (_swig_ret *int) + SetM_pointCacheIndex1(arg2 *int) + GetM_pointCacheIndex1() (_swig_ret *int) + SetM_pointCacheContactPointFlags(arg2 *int) + GetM_pointCacheContactPointFlags() (_swig_ret *int) + SetM_pointCacheAppliedImpulseLateral1(arg2 *float32) + GetM_pointCacheAppliedImpulseLateral1() (_swig_ret *float32) + SetM_pointCacheAppliedImpulseLateral2(arg2 *float32) + GetM_pointCacheAppliedImpulseLateral2() (_swig_ret *float32) + SetM_pointCacheContactMotion1(arg2 *float32) + GetM_pointCacheContactMotion1() (_swig_ret *float32) + SetM_pointCacheContactMotion2(arg2 *float32) + GetM_pointCacheContactMotion2() (_swig_ret *float32) + SetM_pointCacheContactCFM(arg2 *float32) + GetM_pointCacheContactCFM() (_swig_ret *float32) + SetM_pointCacheCombinedContactStiffness1(arg2 *float32) + GetM_pointCacheCombinedContactStiffness1() (_swig_ret *float32) + SetM_pointCacheContactERP(arg2 *float32) + GetM_pointCacheContactERP() (_swig_ret *float32) + SetM_pointCacheCombinedContactDamping1(arg2 *float32) + GetM_pointCacheCombinedContactDamping1() (_swig_ret *float32) + SetM_pointCacheFrictionCFM(arg2 *float32) + GetM_pointCacheFrictionCFM() (_swig_ret *float32) + SetM_pointCacheLifeTime(arg2 *int) + GetM_pointCacheLifeTime() (_swig_ret *int) + SetM_numCachedPoints(arg2 int) + GetM_numCachedPoints() (_swig_ret int) + SetM_companionIdA(arg2 int) + GetM_companionIdA() (_swig_ret int) + SetM_companionIdB(arg2 int) + GetM_companionIdB() (_swig_ret int) + SetM_index1a(arg2 int) + GetM_index1a() (_swig_ret int) + SetM_objectType(arg2 int) + GetM_objectType() (_swig_ret int) + SetM_contactBreakingThreshold(arg2 float32) + GetM_contactBreakingThreshold() (_swig_ret float32) + SetM_contactProcessingThreshold(arg2 float32) + GetM_contactProcessingThreshold() (_swig_ret float32) + SetM_padding(arg2 int) + GetM_padding() (_swig_ret int) + SetM_body0(arg2 BtCollisionObjectFloatData) + GetM_body0() (_swig_ret BtCollisionObjectFloatData) + SetM_body1(arg2 BtCollisionObjectFloatData) + GetM_body1() (_swig_ret BtCollisionObjectFloatData) +} + +const BtPersistentManifoldDataName string = "btPersistentManifoldFloatData" + +type SwigcptrBtDiscreteCollisionDetectorInterface uintptr + +func (p SwigcptrBtDiscreteCollisionDetectorInterface) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDiscreteCollisionDetectorInterface) SwigIsBtDiscreteCollisionDetectorInterface() { +} + +func DeleteBtDiscreteCollisionDetectorInterface(arg1 BtDiscreteCollisionDetectorInterface) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDiscreteCollisionDetectorInterface_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDiscreteCollisionDetectorInterface) GetClosestPoints__SWIG_0(arg2 BtDiscreteCollisionDetectorInterface_ClosestPointInput, arg3 BtDiscreteCollisionDetectorInterface_Result, arg4 BtIDebugDraw, arg5 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + C._wrap_btDiscreteCollisionDetectorInterface_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4)) +} + +func (arg1 SwigcptrBtDiscreteCollisionDetectorInterface) GetClosestPoints__SWIG_1(arg2 BtDiscreteCollisionDetectorInterface_ClosestPointInput, arg3 BtDiscreteCollisionDetectorInterface_Result, arg4 BtIDebugDraw) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDiscreteCollisionDetectorInterface_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtDiscreteCollisionDetectorInterface) GetClosestPoints(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.GetClosestPoints__SWIG_1(a[0].(BtDiscreteCollisionDetectorInterface_ClosestPointInput), a[1].(BtDiscreteCollisionDetectorInterface_Result), a[2].(BtIDebugDraw)) + return + } + if argc == 4 { + p.GetClosestPoints__SWIG_0(a[0].(BtDiscreteCollisionDetectorInterface_ClosestPointInput), a[1].(BtDiscreteCollisionDetectorInterface_Result), a[2].(BtIDebugDraw), a[3].(bool)) + return + } + panic("No match for overloaded function call") +} + +type BtDiscreteCollisionDetectorInterface interface { + Swigcptr() uintptr + SwigIsBtDiscreteCollisionDetectorInterface() + GetClosestPoints(a ...interface{}) +} + +type SwigcptrBtStorageResult uintptr + +func (p SwigcptrBtStorageResult) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtStorageResult) SwigIsBtStorageResult() { +} + +func (arg1 SwigcptrBtStorageResult) SetM_normalOnSurfaceB(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btStorageResult_m_normalOnSurfaceB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtStorageResult) GetM_normalOnSurfaceB() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btStorageResult_m_normalOnSurfaceB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtStorageResult) SetM_closestPointInB(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btStorageResult_m_closestPointInB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtStorageResult) GetM_closestPointInB() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btStorageResult_m_closestPointInB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtStorageResult) SetM_distance(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btStorageResult_m_distance_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtStorageResult) GetM_distance() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btStorageResult_m_distance_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtStorageResult(arg1 BtStorageResult) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btStorageResult_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtStorageResult) AddContactPoint(arg2 BtVector3, arg3 BtVector3, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btStorageResult_addContactPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +type BtStorageResult interface { + Swigcptr() uintptr + SwigIsBtStorageResult() + SetM_normalOnSurfaceB(arg2 BtVector3) + GetM_normalOnSurfaceB() (_swig_ret BtVector3) + SetM_closestPointInB(arg2 BtVector3) + GetM_closestPointInB() (_swig_ret BtVector3) + SetM_distance(arg2 float32) + GetM_distance() (_swig_ret float32) + AddContactPoint(arg2 BtVector3, arg3 BtVector3, arg4 float32) +} + +func SetGContactAddedCallback(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_gContactAddedCallback_set_mbt_e879218550ba2e2b(C.swig_type_92(_swig_i_0)) +} + +func GetGContactAddedCallback() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_gContactAddedCallback_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetGCalculateCombinedRestitutionCallback(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_gCalculateCombinedRestitutionCallback_set_mbt_e879218550ba2e2b(C.swig_type_94(_swig_i_0)) +} + +func GetGCalculateCombinedRestitutionCallback() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_gCalculateCombinedRestitutionCallback_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetGCalculateCombinedFrictionCallback(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_gCalculateCombinedFrictionCallback_set_mbt_e879218550ba2e2b(C.swig_type_96(_swig_i_0)) +} + +func GetGCalculateCombinedFrictionCallback() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_gCalculateCombinedFrictionCallback_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetGCalculateCombinedRollingFrictionCallback(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_gCalculateCombinedRollingFrictionCallback_set_mbt_e879218550ba2e2b(C.swig_type_98(_swig_i_0)) +} + +func GetGCalculateCombinedRollingFrictionCallback() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_gCalculateCombinedRollingFrictionCallback_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetGCalculateCombinedSpinningFrictionCallback(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_gCalculateCombinedSpinningFrictionCallback_set_mbt_e879218550ba2e2b(C.swig_type_100(_swig_i_0)) +} + +func GetGCalculateCombinedSpinningFrictionCallback() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_gCalculateCombinedSpinningFrictionCallback_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetGCalculateCombinedContactDampingCallback(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_gCalculateCombinedContactDampingCallback_set_mbt_e879218550ba2e2b(C.swig_type_102(_swig_i_0)) +} + +func GetGCalculateCombinedContactDampingCallback() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_gCalculateCombinedContactDampingCallback_get_mbt_e879218550ba2e2b()) + return swig_r +} + +func SetGCalculateCombinedContactStiffnessCallback(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_gCalculateCombinedContactStiffnessCallback_set_mbt_e879218550ba2e2b(C.swig_type_104(_swig_i_0)) +} + +func GetGCalculateCombinedContactStiffnessCallback() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_gCalculateCombinedContactStiffnessCallback_get_mbt_e879218550ba2e2b()) + return swig_r +} + +type SwigcptrBtManifoldResult uintptr + +func (p SwigcptrBtManifoldResult) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtManifoldResult) SwigIsBtManifoldResult() { +} + +func NewBtManifoldResult__SWIG_0() (_swig_ret BtManifoldResult) { + var swig_r BtManifoldResult + swig_r = (BtManifoldResult)(SwigcptrBtManifoldResult(C._wrap_new_btManifoldResult__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtManifoldResult__SWIG_1(arg1 BtCollisionObjectWrapper, arg2 BtCollisionObjectWrapper) (_swig_ret BtManifoldResult) { + var swig_r BtManifoldResult + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtManifoldResult)(SwigcptrBtManifoldResult(C._wrap_new_btManifoldResult__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func NewBtManifoldResult(a ...interface{}) BtManifoldResult { + argc := len(a) + if argc == 0 { + return NewBtManifoldResult__SWIG_0() + } + if argc == 2 { + return NewBtManifoldResult__SWIG_1(a[0].(BtCollisionObjectWrapper), a[1].(BtCollisionObjectWrapper)) + } + panic("No match for overloaded function call") +} + +func DeleteBtManifoldResult(arg1 BtManifoldResult) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btManifoldResult_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtManifoldResult) SetPersistentManifold(arg2 BtPersistentManifold) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btManifoldResult_setPersistentManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldResult) GetPersistentManifold__SWIG_0() (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btManifoldResult_getPersistentManifold__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldResult) GetPersistentManifold__SWIG_1() (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btManifoldResult_getPersistentManifold__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtManifoldResult) GetPersistentManifold(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetPersistentManifold__SWIG_0() + } + if argc == 0 { + return p.GetPersistentManifold__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtManifoldResult) SetShapeIdentifiersA(arg2 int, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btManifoldResult_setShapeIdentifiersA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtManifoldResult) SetShapeIdentifiersB(arg2 int, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btManifoldResult_setShapeIdentifiersB_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtManifoldResult) AddContactPoint(arg2 BtVector3, arg3 BtVector3, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btManifoldResult_addContactPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtManifoldResult) RefreshContactPoints() { + _swig_i_0 := arg1 + C._wrap_btManifoldResult_refreshContactPoints_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtManifoldResult) GetBody0Wrap() (_swig_ret BtCollisionObjectWrapper) { + var swig_r BtCollisionObjectWrapper + _swig_i_0 := arg1 + swig_r = (BtCollisionObjectWrapper)(SwigcptrBtCollisionObjectWrapper(C._wrap_btManifoldResult_getBody0Wrap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldResult) GetBody1Wrap() (_swig_ret BtCollisionObjectWrapper) { + var swig_r BtCollisionObjectWrapper + _swig_i_0 := arg1 + swig_r = (BtCollisionObjectWrapper)(SwigcptrBtCollisionObjectWrapper(C._wrap_btManifoldResult_getBody1Wrap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldResult) SetBody0Wrap(arg2 BtCollisionObjectWrapper) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btManifoldResult_setBody0Wrap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldResult) SetBody1Wrap(arg2 BtCollisionObjectWrapper) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btManifoldResult_setBody1Wrap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldResult) GetBody0Internal() (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + _swig_i_0 := arg1 + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_btManifoldResult_getBody0Internal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldResult) GetBody1Internal() (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + _swig_i_0 := arg1 + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_btManifoldResult_getBody1Internal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtManifoldResult) SetM_closestPointDistanceThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btManifoldResult_m_closestPointDistanceThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtManifoldResult) GetM_closestPointDistanceThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btManifoldResult_m_closestPointDistanceThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func BtManifoldResultCalculateCombinedRestitution(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btManifoldResult_calculateCombinedRestitution_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtManifoldResultCalculateCombinedFriction(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btManifoldResult_calculateCombinedFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtManifoldResultCalculateCombinedRollingFriction(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btManifoldResult_calculateCombinedRollingFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtManifoldResultCalculateCombinedSpinningFriction(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btManifoldResult_calculateCombinedSpinningFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtManifoldResultCalculateCombinedContactDamping(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btManifoldResult_calculateCombinedContactDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtManifoldResultCalculateCombinedContactStiffness(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btManifoldResult_calculateCombinedContactStiffness_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +type BtManifoldResult interface { + Swigcptr() uintptr + SwigIsBtManifoldResult() + SetPersistentManifold(arg2 BtPersistentManifold) + GetPersistentManifold(a ...interface{}) interface{} + SetShapeIdentifiersA(arg2 int, arg3 int) + SetShapeIdentifiersB(arg2 int, arg3 int) + AddContactPoint(arg2 BtVector3, arg3 BtVector3, arg4 float32) + RefreshContactPoints() + GetBody0Wrap() (_swig_ret BtCollisionObjectWrapper) + GetBody1Wrap() (_swig_ret BtCollisionObjectWrapper) + SetBody0Wrap(arg2 BtCollisionObjectWrapper) + SetBody1Wrap(arg2 BtCollisionObjectWrapper) + GetBody0Internal() (_swig_ret BtCollisionObject) + GetBody1Internal() (_swig_ret BtCollisionObject) + SetM_closestPointDistanceThreshold(arg2 float32) + GetM_closestPointDistanceThreshold() (_swig_ret float32) +} + +type SwigcptrBtCollisionAlgorithmCreateFunc uintptr + +func (p SwigcptrBtCollisionAlgorithmCreateFunc) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionAlgorithmCreateFunc) SwigIsBtCollisionAlgorithmCreateFunc() { +} + +func (arg1 SwigcptrBtCollisionAlgorithmCreateFunc) SetM_swapped(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionAlgorithmCreateFunc_m_swapped_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionAlgorithmCreateFunc) GetM_swapped() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionAlgorithmCreateFunc_m_swapped_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtCollisionAlgorithmCreateFunc() (_swig_ret BtCollisionAlgorithmCreateFunc) { + var swig_r BtCollisionAlgorithmCreateFunc + swig_r = (BtCollisionAlgorithmCreateFunc)(SwigcptrBtCollisionAlgorithmCreateFunc(C._wrap_new_btCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtCollisionAlgorithmCreateFunc(arg1 BtCollisionAlgorithmCreateFunc) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionAlgorithmCreateFunc) CreateCollisionAlgorithm(arg2 BtCollisionAlgorithmConstructionInfo, arg3 BtCollisionObjectWrapper, arg4 BtCollisionObjectWrapper) (_swig_ret BtCollisionAlgorithm) { + var swig_r BtCollisionAlgorithm + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtCollisionAlgorithm)(SwigcptrBtCollisionAlgorithm(C._wrap_btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +type BtCollisionAlgorithmCreateFunc interface { + Swigcptr() uintptr + SwigIsBtCollisionAlgorithmCreateFunc() + SetM_swapped(arg2 bool) + GetM_swapped() (_swig_ret bool) + CreateCollisionAlgorithm(arg2 BtCollisionAlgorithmConstructionInfo, arg3 BtCollisionObjectWrapper, arg4 BtCollisionObjectWrapper) (_swig_ret BtCollisionAlgorithm) +} + +const USE_DISPATCH_REGISTRY_ARRAY int = 1 + +type SwigcptrBtCollisionDispatcher uintptr + +func (p SwigcptrBtCollisionDispatcher) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionDispatcher) SwigIsBtCollisionDispatcher() { +} + +type BtCollisionDispatcherDispatcherFlags int + +func _swig_getbtCollisionDispatcher_CD_STATIC_STATIC_REPORTED_btCollisionDispatcher() (_swig_ret BtCollisionDispatcherDispatcherFlags) { + var swig_r BtCollisionDispatcherDispatcherFlags + swig_r = (BtCollisionDispatcherDispatcherFlags)(C._wrap_CD_STATIC_STATIC_REPORTED_btCollisionDispatcher_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionDispatcherCD_STATIC_STATIC_REPORTED BtCollisionDispatcherDispatcherFlags = _swig_getbtCollisionDispatcher_CD_STATIC_STATIC_REPORTED_btCollisionDispatcher() + +func _swig_getbtCollisionDispatcher_CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD_btCollisionDispatcher() (_swig_ret BtCollisionDispatcherDispatcherFlags) { + var swig_r BtCollisionDispatcherDispatcherFlags + swig_r = (BtCollisionDispatcherDispatcherFlags)(C._wrap_CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD_btCollisionDispatcher_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionDispatcherCD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD BtCollisionDispatcherDispatcherFlags = _swig_getbtCollisionDispatcher_CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD_btCollisionDispatcher() + +func _swig_getbtCollisionDispatcher_CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION_btCollisionDispatcher() (_swig_ret BtCollisionDispatcherDispatcherFlags) { + var swig_r BtCollisionDispatcherDispatcherFlags + swig_r = (BtCollisionDispatcherDispatcherFlags)(C._wrap_CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION_btCollisionDispatcher_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtCollisionDispatcherCD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION BtCollisionDispatcherDispatcherFlags = _swig_getbtCollisionDispatcher_CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION_btCollisionDispatcher() + +func (arg1 SwigcptrBtCollisionDispatcher) GetDispatcherFlags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionDispatcher_getDispatcherFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionDispatcher) SetDispatcherFlags(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionDispatcher_setDispatcherFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) RegisterCollisionCreateFunc(arg2 int, arg3 int, arg4 BtCollisionAlgorithmCreateFunc) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btCollisionDispatcher_registerCollisionCreateFunc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) RegisterClosestPointsCreateFunc(arg2 int, arg3 int, arg4 BtCollisionAlgorithmCreateFunc) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btCollisionDispatcher_registerClosestPointsCreateFunc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) GetNumManifolds() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionDispatcher_getNumManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionDispatcher) GetInternalManifoldPointer() (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btCollisionDispatcher_getInternalManifoldPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionDispatcher) GetManifoldByIndexInternal(arg2 int) (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btCollisionDispatcher_getManifoldByIndexInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func NewBtCollisionDispatcher(arg1 BtCollisionConfiguration) (_swig_ret BtCollisionDispatcher) { + var swig_r BtCollisionDispatcher + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtCollisionDispatcher)(SwigcptrBtCollisionDispatcher(C._wrap_new_btCollisionDispatcher_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func DeleteBtCollisionDispatcher(arg1 BtCollisionDispatcher) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionDispatcher_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) GetNewManifold(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btCollisionDispatcher_getNewManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionDispatcher) ReleaseManifold(arg2 BtPersistentManifold) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionDispatcher_releaseManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) ClearManifold(arg2 BtPersistentManifold) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionDispatcher_clearManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) FindAlgorithm(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtPersistentManifold, arg5 EbtDispatcherQueryType) (_swig_ret BtCollisionAlgorithm) { + var swig_r BtCollisionAlgorithm + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (BtCollisionAlgorithm)(SwigcptrBtCollisionAlgorithm(C._wrap_btCollisionDispatcher_findAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_intgo(_swig_i_4)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionDispatcher) NeedsCollision(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_btCollisionDispatcher_needsCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionDispatcher) NeedsResponse(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (bool)(C._wrap_btCollisionDispatcher_needsResponse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionDispatcher) DispatchAllCollisionPairs(arg2 BtOverlappingPairCache, arg3 BtDispatcherInfo, arg4 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btCollisionDispatcher_dispatchAllCollisionPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) SetNearCallback(arg2 _swig_fnptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionDispatcher_setNearCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_106(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) GetNearCallback() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + _swig_i_0 := arg1 + swig_r = (_swig_fnptr)(C._wrap_btCollisionDispatcher_getNearCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func BtCollisionDispatcherDefaultNearCallback(arg1 BtBroadphasePair, arg2 BtCollisionDispatcher, arg3 BtDispatcherInfo) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCollisionDispatcher_defaultNearCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) AllocateCollisionAlgorithm(arg2 int) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (uintptr)(C._wrap_btCollisionDispatcher_allocateCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionDispatcher) FreeCollisionAlgorithm(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionDispatcher_freeCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) GetCollisionConfiguration__SWIG_0() (_swig_ret BtCollisionConfiguration) { + var swig_r BtCollisionConfiguration + _swig_i_0 := arg1 + swig_r = (BtCollisionConfiguration)(SwigcptrBtCollisionConfiguration(C._wrap_btCollisionDispatcher_getCollisionConfiguration__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionDispatcher) GetCollisionConfiguration__SWIG_1() (_swig_ret BtCollisionConfiguration) { + var swig_r BtCollisionConfiguration + _swig_i_0 := arg1 + swig_r = (BtCollisionConfiguration)(SwigcptrBtCollisionConfiguration(C._wrap_btCollisionDispatcher_getCollisionConfiguration__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCollisionDispatcher) GetCollisionConfiguration(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetCollisionConfiguration__SWIG_0() + } + if argc == 0 { + return p.GetCollisionConfiguration__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionDispatcher) SetCollisionConfiguration(arg2 BtCollisionConfiguration) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionDispatcher_setCollisionConfiguration_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionDispatcher) GetInternalManifoldPool__SWIG_0() (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_btCollisionDispatcher_getInternalManifoldPool__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionDispatcher) GetInternalManifoldPool__SWIG_1() (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_btCollisionDispatcher_getInternalManifoldPool__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCollisionDispatcher) GetInternalManifoldPool(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetInternalManifoldPool__SWIG_0() + } + if argc == 0 { + return p.GetInternalManifoldPool__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (p SwigcptrBtCollisionDispatcher) SwigIsBtDispatcher() { +} + +func (p SwigcptrBtCollisionDispatcher) SwigGetBtDispatcher() BtDispatcher { + return SwigcptrBtDispatcher(getSwigcptr(p)) +} + +type BtCollisionDispatcher interface { + Swigcptr() uintptr + SwigIsBtCollisionDispatcher() + GetDispatcherFlags() (_swig_ret int) + SetDispatcherFlags(arg2 int) + RegisterCollisionCreateFunc(arg2 int, arg3 int, arg4 BtCollisionAlgorithmCreateFunc) + RegisterClosestPointsCreateFunc(arg2 int, arg3 int, arg4 BtCollisionAlgorithmCreateFunc) + GetNumManifolds() (_swig_ret int) + GetInternalManifoldPointer() (_swig_ret BtPersistentManifold) + GetManifoldByIndexInternal(arg2 int) (_swig_ret BtPersistentManifold) + GetNewManifold(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret BtPersistentManifold) + ReleaseManifold(arg2 BtPersistentManifold) + ClearManifold(arg2 BtPersistentManifold) + FindAlgorithm(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtPersistentManifold, arg5 EbtDispatcherQueryType) (_swig_ret BtCollisionAlgorithm) + NeedsCollision(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret bool) + NeedsResponse(arg2 BtCollisionObject, arg3 BtCollisionObject) (_swig_ret bool) + DispatchAllCollisionPairs(arg2 BtOverlappingPairCache, arg3 BtDispatcherInfo, arg4 BtDispatcher) + SetNearCallback(arg2 _swig_fnptr) + GetNearCallback() (_swig_ret _swig_fnptr) + AllocateCollisionAlgorithm(arg2 int) (_swig_ret uintptr) + FreeCollisionAlgorithm(arg2 uintptr) + GetCollisionConfiguration(a ...interface{}) interface{} + SetCollisionConfiguration(arg2 BtCollisionConfiguration) + GetInternalManifoldPool(a ...interface{}) interface{} + SwigIsBtDispatcher() + SwigGetBtDispatcher() BtDispatcher +} + +type SwigcptrBtCollisionPairCallback uintptr + +func (p SwigcptrBtCollisionPairCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionPairCallback) SwigIsBtCollisionPairCallback() { +} + +func NewBtCollisionPairCallback(arg1 BtDispatcherInfo, arg2 BtCollisionDispatcher) (_swig_ret BtCollisionPairCallback) { + var swig_r BtCollisionPairCallback + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtCollisionPairCallback)(SwigcptrBtCollisionPairCallback(C._wrap_new_btCollisionPairCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func DeleteBtCollisionPairCallback(arg1 BtCollisionPairCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionPairCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionPairCallback) ProcessOverlap(arg2 BtBroadphasePair) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btCollisionPairCallback_processOverlap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (p SwigcptrBtCollisionPairCallback) SwigIsBtOverlapCallback() { +} + +func (p SwigcptrBtCollisionPairCallback) SwigGetBtOverlapCallback() BtOverlapCallback { + return SwigcptrBtOverlapCallback(getSwigcptr(p)) +} + +type BtCollisionPairCallback interface { + Swigcptr() uintptr + SwigIsBtCollisionPairCallback() + ProcessOverlap(arg2 BtBroadphasePair) (_swig_ret bool) + SwigIsBtOverlapCallback() + SwigGetBtOverlapCallback() BtOverlapCallback +} + +type SwigcptrBtCollisionWorld uintptr + +func (p SwigcptrBtCollisionWorld) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionWorld) SwigIsBtCollisionWorld() { +} + +func NewBtCollisionWorld(arg1 BtDispatcher, arg2 BtBroadphaseInterface, arg3 BtCollisionConfiguration) (_swig_ret BtCollisionWorld) { + var swig_r BtCollisionWorld + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtCollisionWorld)(SwigcptrBtCollisionWorld(C._wrap_new_btCollisionWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func DeleteBtCollisionWorld(arg1 BtCollisionWorld) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionWorld) SetBroadphase(arg2 BtBroadphaseInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionWorld_setBroadphase_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionWorld) GetBroadphase__SWIG_0() (_swig_ret BtBroadphaseInterface) { + var swig_r BtBroadphaseInterface + _swig_i_0 := arg1 + swig_r = (BtBroadphaseInterface)(SwigcptrBtBroadphaseInterface(C._wrap_btCollisionWorld_getBroadphase__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionWorld) GetBroadphase__SWIG_1() (_swig_ret BtBroadphaseInterface) { + var swig_r BtBroadphaseInterface + _swig_i_0 := arg1 + swig_r = (BtBroadphaseInterface)(SwigcptrBtBroadphaseInterface(C._wrap_btCollisionWorld_getBroadphase__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCollisionWorld) GetBroadphase(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetBroadphase__SWIG_0() + } + if argc == 0 { + return p.GetBroadphase__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionWorld) GetPairCache() (_swig_ret BtOverlappingPairCache) { + var swig_r BtOverlappingPairCache + _swig_i_0 := arg1 + swig_r = (BtOverlappingPairCache)(SwigcptrBtOverlappingPairCache(C._wrap_btCollisionWorld_getPairCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionWorld) GetDispatcher__SWIG_0() (_swig_ret BtDispatcher) { + var swig_r BtDispatcher + _swig_i_0 := arg1 + swig_r = (BtDispatcher)(SwigcptrBtDispatcher(C._wrap_btCollisionWorld_getDispatcher__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionWorld) GetDispatcher__SWIG_1() (_swig_ret BtDispatcher) { + var swig_r BtDispatcher + _swig_i_0 := arg1 + swig_r = (BtDispatcher)(SwigcptrBtDispatcher(C._wrap_btCollisionWorld_getDispatcher__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCollisionWorld) GetDispatcher(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetDispatcher__SWIG_0() + } + if argc == 0 { + return p.GetDispatcher__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionWorld) UpdateSingleAabb(arg2 BtCollisionObject) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionWorld_updateSingleAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionWorld) UpdateAabbs() { + _swig_i_0 := arg1 + C._wrap_btCollisionWorld_updateAabbs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionWorld) ComputeOverlappingPairs() { + _swig_i_0 := arg1 + C._wrap_btCollisionWorld_computeOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionWorld) SetDebugDrawer(arg2 BtIDebugDraw) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionWorld_setDebugDrawer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionWorld) GetDebugDrawer() (_swig_ret BtIDebugDraw) { + var swig_r BtIDebugDraw + _swig_i_0 := arg1 + swig_r = (BtIDebugDraw)(SwigcptrBtIDebugDraw(C._wrap_btCollisionWorld_getDebugDrawer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionWorld) DebugDrawWorld() { + _swig_i_0 := arg1 + C._wrap_btCollisionWorld_debugDrawWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionWorld) DebugDrawObject(arg2 BtTransform, arg3 BtCollisionShape, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btCollisionWorld_debugDrawObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtCollisionWorld) GetNumCollisionObjects() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btCollisionWorld_getNumCollisionObjects_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionWorld) RayTest(arg2 BtVector3, arg3 BtVector3, arg4 BtCollisionWorld_RayResultCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btCollisionWorld_rayTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtCollisionWorld) ConvexSweepTest__SWIG_0(arg2 BtConvexShape, arg3 BtTransform, arg4 BtTransform, arg5 BtCollisionWorld_ConvexResultCallback, arg6 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + C._wrap_btCollisionWorld_convexSweepTest__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.float(_swig_i_5)) +} + +func (arg1 SwigcptrBtCollisionWorld) ConvexSweepTest__SWIG_1(arg2 BtConvexShape, arg3 BtTransform, arg4 BtTransform, arg5 BtCollisionWorld_ConvexResultCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btCollisionWorld_convexSweepTest__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (p SwigcptrBtCollisionWorld) ConvexSweepTest(a ...interface{}) { + argc := len(a) + if argc == 4 { + p.ConvexSweepTest__SWIG_1(a[0].(BtConvexShape), a[1].(BtTransform), a[2].(BtTransform), a[3].(BtCollisionWorld_ConvexResultCallback)) + return + } + if argc == 5 { + p.ConvexSweepTest__SWIG_0(a[0].(BtConvexShape), a[1].(BtTransform), a[2].(BtTransform), a[3].(BtCollisionWorld_ConvexResultCallback), a[4].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionWorld) ContactTest(arg2 BtCollisionObject, arg3 BtCollisionWorld_ContactResultCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btCollisionWorld_contactTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtCollisionWorld) ContactPairTest(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtCollisionWorld_ContactResultCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btCollisionWorld_contactPairTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func BtCollisionWorldRayTestSingle(arg1 BtTransform, arg2 BtTransform, arg3 BtCollisionObject, arg4 BtCollisionShape, arg5 BtTransform, arg6 BtCollisionWorld_RayResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btCollisionWorld_rayTestSingle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func BtCollisionWorldRayTestSingleInternal(arg1 BtTransform, arg2 BtTransform, arg3 BtCollisionObjectWrapper, arg4 BtCollisionWorld_RayResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btCollisionWorld_rayTestSingleInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func BtCollisionWorldObjectQuerySingle(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionObject, arg5 BtCollisionShape, arg6 BtTransform, arg7 BtCollisionWorld_ConvexResultCallback, arg8 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := arg8 + C._wrap_btCollisionWorld_objectQuerySingle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.float(_swig_i_7)) +} + +func BtCollisionWorldObjectQuerySingleInternal(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionObjectWrapper, arg5 BtCollisionWorld_ConvexResultCallback, arg6 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + C._wrap_btCollisionWorld_objectQuerySingleInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.float(_swig_i_5)) +} + +func (arg1 SwigcptrBtCollisionWorld) AddCollisionObject__SWIG_0(arg2 BtCollisionObject, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btCollisionWorld_addCollisionObject__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtCollisionWorld) AddCollisionObject__SWIG_1(arg2 BtCollisionObject, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btCollisionWorld_addCollisionObject__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtCollisionWorld) AddCollisionObject__SWIG_2(arg2 BtCollisionObject) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionWorld_addCollisionObject__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtCollisionWorld) AddCollisionObject(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.AddCollisionObject__SWIG_2(a[0].(BtCollisionObject)) + return + } + if argc == 2 { + p.AddCollisionObject__SWIG_1(a[0].(BtCollisionObject), a[1].(int)) + return + } + if argc == 3 { + p.AddCollisionObject__SWIG_0(a[0].(BtCollisionObject), a[1].(int), a[2].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionWorld) RefreshBroadphaseProxy(arg2 BtCollisionObject) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionWorld_refreshBroadphaseProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionWorld) GetCollisionObjectArray__SWIG_0() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_(C._wrap_btCollisionWorld_getCollisionObjectArray__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionWorld) GetCollisionObjectArray__SWIG_1() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_(C._wrap_btCollisionWorld_getCollisionObjectArray__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCollisionWorld) GetCollisionObjectArray(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetCollisionObjectArray__SWIG_0() + } + if argc == 0 { + return p.GetCollisionObjectArray__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionWorld) RemoveCollisionObject(arg2 BtCollisionObject) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionWorld_removeCollisionObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionWorld) PerformDiscreteCollisionDetection() { + _swig_i_0 := arg1 + C._wrap_btCollisionWorld_performDiscreteCollisionDetection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionWorld) GetDispatchInfo__SWIG_0() (_swig_ret BtDispatcherInfo) { + var swig_r BtDispatcherInfo + _swig_i_0 := arg1 + swig_r = (BtDispatcherInfo)(SwigcptrBtDispatcherInfo(C._wrap_btCollisionWorld_getDispatchInfo__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionWorld) GetDispatchInfo__SWIG_1() (_swig_ret BtDispatcherInfo) { + var swig_r BtDispatcherInfo + _swig_i_0 := arg1 + swig_r = (BtDispatcherInfo)(SwigcptrBtDispatcherInfo(C._wrap_btCollisionWorld_getDispatchInfo__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCollisionWorld) GetDispatchInfo(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetDispatchInfo__SWIG_0() + } + if argc == 0 { + return p.GetDispatchInfo__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionWorld) GetForceUpdateAllAabbs() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btCollisionWorld_getForceUpdateAllAabbs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionWorld) SetForceUpdateAllAabbs(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCollisionWorld_setForceUpdateAllAabbs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionWorld) Serialize(arg2 BtSerializer) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionWorld_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +type BtCollisionWorld interface { + Swigcptr() uintptr + SwigIsBtCollisionWorld() + SetBroadphase(arg2 BtBroadphaseInterface) + GetBroadphase(a ...interface{}) interface{} + GetPairCache() (_swig_ret BtOverlappingPairCache) + GetDispatcher(a ...interface{}) interface{} + UpdateSingleAabb(arg2 BtCollisionObject) + UpdateAabbs() + ComputeOverlappingPairs() + SetDebugDrawer(arg2 BtIDebugDraw) + GetDebugDrawer() (_swig_ret BtIDebugDraw) + DebugDrawWorld() + DebugDrawObject(arg2 BtTransform, arg3 BtCollisionShape, arg4 BtVector3) + GetNumCollisionObjects() (_swig_ret int) + RayTest(arg2 BtVector3, arg3 BtVector3, arg4 BtCollisionWorld_RayResultCallback) + ConvexSweepTest(a ...interface{}) + ContactTest(arg2 BtCollisionObject, arg3 BtCollisionWorld_ContactResultCallback) + ContactPairTest(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtCollisionWorld_ContactResultCallback) + AddCollisionObject(a ...interface{}) + RefreshBroadphaseProxy(arg2 BtCollisionObject) + GetCollisionObjectArray(a ...interface{}) interface{} + RemoveCollisionObject(arg2 BtCollisionObject) + PerformDiscreteCollisionDetection() + GetDispatchInfo(a ...interface{}) interface{} + GetForceUpdateAllAabbs() (_swig_ret bool) + SetForceUpdateAllAabbs(arg2 bool) + Serialize(arg2 BtSerializer) +} + +const VORONOI_SIMPLEX_MAX_VERTS int = 5 +const VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD float32 = 0.0001 + +type SwigcptrBtUsageBitfield uintptr + +func (p SwigcptrBtUsageBitfield) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtUsageBitfield) SwigIsBtUsageBitfield() { +} + +func NewBtUsageBitfield() (_swig_ret BtUsageBitfield) { + var swig_r BtUsageBitfield + swig_r = (BtUsageBitfield)(SwigcptrBtUsageBitfield(C._wrap_new_btUsageBitfield_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtUsageBitfield) Reset() { + _swig_i_0 := arg1 + C._wrap_btUsageBitfield_reset_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtUsageBitfield) SetUsedVertexA(arg2 uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btUsageBitfield_usedVertexA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtUsageBitfield) GetUsedVertexA() (_swig_ret uint16) { + var swig_r uint16 + _swig_i_0 := arg1 + swig_r = (uint16)(C._wrap_btUsageBitfield_usedVertexA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtUsageBitfield) SetUsedVertexB(arg2 uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btUsageBitfield_usedVertexB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtUsageBitfield) GetUsedVertexB() (_swig_ret uint16) { + var swig_r uint16 + _swig_i_0 := arg1 + swig_r = (uint16)(C._wrap_btUsageBitfield_usedVertexB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtUsageBitfield) SetUsedVertexC(arg2 uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btUsageBitfield_usedVertexC_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtUsageBitfield) GetUsedVertexC() (_swig_ret uint16) { + var swig_r uint16 + _swig_i_0 := arg1 + swig_r = (uint16)(C._wrap_btUsageBitfield_usedVertexC_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtUsageBitfield) SetUsedVertexD(arg2 uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btUsageBitfield_usedVertexD_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtUsageBitfield) GetUsedVertexD() (_swig_ret uint16) { + var swig_r uint16 + _swig_i_0 := arg1 + swig_r = (uint16)(C._wrap_btUsageBitfield_usedVertexD_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtUsageBitfield) SetUnused1(arg2 uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btUsageBitfield_unused1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtUsageBitfield) GetUnused1() (_swig_ret uint16) { + var swig_r uint16 + _swig_i_0 := arg1 + swig_r = (uint16)(C._wrap_btUsageBitfield_unused1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtUsageBitfield) SetUnused2(arg2 uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btUsageBitfield_unused2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtUsageBitfield) GetUnused2() (_swig_ret uint16) { + var swig_r uint16 + _swig_i_0 := arg1 + swig_r = (uint16)(C._wrap_btUsageBitfield_unused2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtUsageBitfield) SetUnused3(arg2 uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btUsageBitfield_unused3_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtUsageBitfield) GetUnused3() (_swig_ret uint16) { + var swig_r uint16 + _swig_i_0 := arg1 + swig_r = (uint16)(C._wrap_btUsageBitfield_unused3_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtUsageBitfield) SetUnused4(arg2 uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btUsageBitfield_unused4_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtUsageBitfield) GetUnused4() (_swig_ret uint16) { + var swig_r uint16 + _swig_i_0 := arg1 + swig_r = (uint16)(C._wrap_btUsageBitfield_unused4_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtUsageBitfield(arg1 BtUsageBitfield) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btUsageBitfield_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtUsageBitfield interface { + Swigcptr() uintptr + SwigIsBtUsageBitfield() + Reset() + SetUsedVertexA(arg2 uint16) + GetUsedVertexA() (_swig_ret uint16) + SetUsedVertexB(arg2 uint16) + GetUsedVertexB() (_swig_ret uint16) + SetUsedVertexC(arg2 uint16) + GetUsedVertexC() (_swig_ret uint16) + SetUsedVertexD(arg2 uint16) + GetUsedVertexD() (_swig_ret uint16) + SetUnused1(arg2 uint16) + GetUnused1() (_swig_ret uint16) + SetUnused2(arg2 uint16) + GetUnused2() (_swig_ret uint16) + SetUnused3(arg2 uint16) + GetUnused3() (_swig_ret uint16) + SetUnused4(arg2 uint16) + GetUnused4() (_swig_ret uint16) +} + +type SwigcptrBtSubSimplexClosestResult uintptr + +func (p SwigcptrBtSubSimplexClosestResult) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSubSimplexClosestResult) SwigIsBtSubSimplexClosestResult() { +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) SetM_closestPointOnSimplex(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSubSimplexClosestResult_m_closestPointOnSimplex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) GetM_closestPointOnSimplex() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSubSimplexClosestResult_m_closestPointOnSimplex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) SetM_usedVertices(arg2 BtUsageBitfield) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSubSimplexClosestResult_m_usedVertices_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) GetM_usedVertices() (_swig_ret BtUsageBitfield) { + var swig_r BtUsageBitfield + _swig_i_0 := arg1 + swig_r = (BtUsageBitfield)(SwigcptrBtUsageBitfield(C._wrap_btSubSimplexClosestResult_m_usedVertices_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) SetM_barycentricCoords(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSubSimplexClosestResult_m_barycentricCoords_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) GetM_barycentricCoords() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btSubSimplexClosestResult_m_barycentricCoords_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) SetM_degenerate(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSubSimplexClosestResult_m_degenerate_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) GetM_degenerate() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btSubSimplexClosestResult_m_degenerate_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) Reset() { + _swig_i_0 := arg1 + C._wrap_btSubSimplexClosestResult_reset_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) IsValid() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btSubSimplexClosestResult_isValid_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) SetBarycentricCoordinates__SWIG_0(arg2 float32, arg3 float32, arg4 float32, arg5 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4)) +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) SetBarycentricCoordinates__SWIG_1(arg2 float32, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) SetBarycentricCoordinates__SWIG_2(arg2 float32, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) SetBarycentricCoordinates__SWIG_3(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSubSimplexClosestResult) SetBarycentricCoordinates__SWIG_4() { + _swig_i_0 := arg1 + C._wrap_btSubSimplexClosestResult_setBarycentricCoordinates__SWIG_4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtSubSimplexClosestResult) SetBarycentricCoordinates(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.SetBarycentricCoordinates__SWIG_4() + return + } + if argc == 1 { + p.SetBarycentricCoordinates__SWIG_3(a[0].(float32)) + return + } + if argc == 2 { + p.SetBarycentricCoordinates__SWIG_2(a[0].(float32), a[1].(float32)) + return + } + if argc == 3 { + p.SetBarycentricCoordinates__SWIG_1(a[0].(float32), a[1].(float32), a[2].(float32)) + return + } + if argc == 4 { + p.SetBarycentricCoordinates__SWIG_0(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32)) + return + } + panic("No match for overloaded function call") +} + +func NewBtSubSimplexClosestResult() (_swig_ret BtSubSimplexClosestResult) { + var swig_r BtSubSimplexClosestResult + swig_r = (BtSubSimplexClosestResult)(SwigcptrBtSubSimplexClosestResult(C._wrap_new_btSubSimplexClosestResult_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtSubSimplexClosestResult(arg1 BtSubSimplexClosestResult) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSubSimplexClosestResult_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtSubSimplexClosestResult interface { + Swigcptr() uintptr + SwigIsBtSubSimplexClosestResult() + SetM_closestPointOnSimplex(arg2 BtVector3) + GetM_closestPointOnSimplex() (_swig_ret BtVector3) + SetM_usedVertices(arg2 BtUsageBitfield) + GetM_usedVertices() (_swig_ret BtUsageBitfield) + SetM_barycentricCoords(arg2 *float32) + GetM_barycentricCoords() (_swig_ret *float32) + SetM_degenerate(arg2 bool) + GetM_degenerate() (_swig_ret bool) + Reset() + IsValid() (_swig_ret bool) + SetBarycentricCoordinates(a ...interface{}) +} + +type SwigcptrBtVoronoiSimplexSolver uintptr + +func (p SwigcptrBtVoronoiSimplexSolver) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtVoronoiSimplexSolver) SwigIsBtVoronoiSimplexSolver() { +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_numVertices(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVoronoiSimplexSolver_m_numVertices_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_numVertices() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btVoronoiSimplexSolver_m_numVertices_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_simplexVectorW(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVoronoiSimplexSolver_m_simplexVectorW_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_simplexVectorW() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVoronoiSimplexSolver_m_simplexVectorW_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_simplexPointsP(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVoronoiSimplexSolver_m_simplexPointsP_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_simplexPointsP() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVoronoiSimplexSolver_m_simplexPointsP_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_simplexPointsQ(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVoronoiSimplexSolver_m_simplexPointsQ_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_simplexPointsQ() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVoronoiSimplexSolver_m_simplexPointsQ_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_cachedP1(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVoronoiSimplexSolver_m_cachedP1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_cachedP1() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVoronoiSimplexSolver_m_cachedP1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_cachedP2(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVoronoiSimplexSolver_m_cachedP2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_cachedP2() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVoronoiSimplexSolver_m_cachedP2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_cachedV(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVoronoiSimplexSolver_m_cachedV_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_cachedV() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVoronoiSimplexSolver_m_cachedV_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_lastW(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVoronoiSimplexSolver_m_lastW_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_lastW() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btVoronoiSimplexSolver_m_lastW_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_equalVertexThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVoronoiSimplexSolver_m_equalVertexThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_equalVertexThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVoronoiSimplexSolver_m_equalVertexThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_cachedValidClosest(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVoronoiSimplexSolver_m_cachedValidClosest_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_cachedValidClosest() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btVoronoiSimplexSolver_m_cachedValidClosest_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_cachedBC(arg2 BtSubSimplexClosestResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVoronoiSimplexSolver_m_cachedBC_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_cachedBC() (_swig_ret BtSubSimplexClosestResult) { + var swig_r BtSubSimplexClosestResult + _swig_i_0 := arg1 + swig_r = (BtSubSimplexClosestResult)(SwigcptrBtSubSimplexClosestResult(C._wrap_btVoronoiSimplexSolver_m_cachedBC_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetM_needsUpdate(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVoronoiSimplexSolver_m_needsUpdate_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetM_needsUpdate() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btVoronoiSimplexSolver_m_needsUpdate_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) RemoveVertex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVoronoiSimplexSolver_removeVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) ReduceVertices(arg2 BtUsageBitfield) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVoronoiSimplexSolver_reduceVertices_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) UpdateClosestVectorAndPoints() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btVoronoiSimplexSolver_updateClosestVectorAndPoints_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) ClosestPtPointTetrahedron(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3, arg7 BtSubSimplexClosestResult) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + swig_r = (bool)(C._wrap_btVoronoiSimplexSolver_closestPtPointTetrahedron_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) PointOutsideOfPlane(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (int)(C._wrap_btVoronoiSimplexSolver_pointOutsideOfPlane_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) ClosestPtPointTriangle(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtSubSimplexClosestResult) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_btVoronoiSimplexSolver_closestPtPointTriangle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func NewBtVoronoiSimplexSolver() (_swig_ret BtVoronoiSimplexSolver) { + var swig_r BtVoronoiSimplexSolver + swig_r = (BtVoronoiSimplexSolver)(SwigcptrBtVoronoiSimplexSolver(C._wrap_new_btVoronoiSimplexSolver_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) Reset() { + _swig_i_0 := arg1 + C._wrap_btVoronoiSimplexSolver_reset_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) AddVertex(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btVoronoiSimplexSolver_addVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) SetEqualVertexThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btVoronoiSimplexSolver_setEqualVertexThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetEqualVertexThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVoronoiSimplexSolver_getEqualVertexThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) Closest(arg2 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btVoronoiSimplexSolver_closest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) MaxVertex() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btVoronoiSimplexSolver_maxVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) FullSimplex() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btVoronoiSimplexSolver_fullSimplex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) GetSimplex(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (int)(C._wrap_btVoronoiSimplexSolver_getSimplex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) InSimplex(arg2 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btVoronoiSimplexSolver_inSimplex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) Backup_closest(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btVoronoiSimplexSolver_backup_closest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) EmptySimplex() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btVoronoiSimplexSolver_emptySimplex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) Compute_points(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btVoronoiSimplexSolver_compute_points_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtVoronoiSimplexSolver) NumVertices() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btVoronoiSimplexSolver_numVertices_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtVoronoiSimplexSolver(arg1 BtVoronoiSimplexSolver) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btVoronoiSimplexSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtVoronoiSimplexSolver interface { + Swigcptr() uintptr + SwigIsBtVoronoiSimplexSolver() + SetM_numVertices(arg2 int) + GetM_numVertices() (_swig_ret int) + SetM_simplexVectorW(arg2 BtVector3) + GetM_simplexVectorW() (_swig_ret BtVector3) + SetM_simplexPointsP(arg2 BtVector3) + GetM_simplexPointsP() (_swig_ret BtVector3) + SetM_simplexPointsQ(arg2 BtVector3) + GetM_simplexPointsQ() (_swig_ret BtVector3) + SetM_cachedP1(arg2 BtVector3) + GetM_cachedP1() (_swig_ret BtVector3) + SetM_cachedP2(arg2 BtVector3) + GetM_cachedP2() (_swig_ret BtVector3) + SetM_cachedV(arg2 BtVector3) + GetM_cachedV() (_swig_ret BtVector3) + SetM_lastW(arg2 BtVector3) + GetM_lastW() (_swig_ret BtVector3) + SetM_equalVertexThreshold(arg2 float32) + GetM_equalVertexThreshold() (_swig_ret float32) + SetM_cachedValidClosest(arg2 bool) + GetM_cachedValidClosest() (_swig_ret bool) + SetM_cachedBC(arg2 BtSubSimplexClosestResult) + GetM_cachedBC() (_swig_ret BtSubSimplexClosestResult) + SetM_needsUpdate(arg2 bool) + GetM_needsUpdate() (_swig_ret bool) + RemoveVertex(arg2 int) + ReduceVertices(arg2 BtUsageBitfield) + UpdateClosestVectorAndPoints() (_swig_ret bool) + ClosestPtPointTetrahedron(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3, arg7 BtSubSimplexClosestResult) (_swig_ret bool) + PointOutsideOfPlane(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3) (_swig_ret int) + ClosestPtPointTriangle(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtSubSimplexClosestResult) (_swig_ret bool) + Reset() + AddVertex(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) + SetEqualVertexThreshold(arg2 float32) + GetEqualVertexThreshold() (_swig_ret float32) + Closest(arg2 BtVector3) (_swig_ret bool) + MaxVertex() (_swig_ret float32) + FullSimplex() (_swig_ret bool) + GetSimplex(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) (_swig_ret int) + InSimplex(arg2 BtVector3) (_swig_ret bool) + Backup_closest(arg2 BtVector3) + EmptySimplex() (_swig_ret bool) + Compute_points(arg2 BtVector3, arg3 BtVector3) + NumVertices() (_swig_ret int) +} + +const NO_VIRTUAL_INTERFACE int = 1 + +type SwigcptrBtGjkEpaPenetrationDepthSolver uintptr + +func (p SwigcptrBtGjkEpaPenetrationDepthSolver) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGjkEpaPenetrationDepthSolver) SwigIsBtGjkEpaPenetrationDepthSolver() { +} + +func NewBtGjkEpaPenetrationDepthSolver() (_swig_ret BtGjkEpaPenetrationDepthSolver) { + var swig_r BtGjkEpaPenetrationDepthSolver + swig_r = (BtGjkEpaPenetrationDepthSolver)(SwigcptrBtGjkEpaPenetrationDepthSolver(C._wrap_new_btGjkEpaPenetrationDepthSolver_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtGjkEpaPenetrationDepthSolver) CalcPenDepth(arg2 BtVoronoiSimplexSolver, arg3 BtConvexShape, arg4 BtConvexShape, arg5 BtTransform, arg6 BtTransform, arg7 BtVector3, arg8 BtVector3, arg9 BtVector3, arg10 BtIDebugDraw) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := getSwigcptr(arg10) + swig_r = (bool)(C._wrap_btGjkEpaPenetrationDepthSolver_calcPenDepth_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7), C.uintptr_t(_swig_i_8), C.uintptr_t(_swig_i_9))) + return swig_r +} + +func DeleteBtGjkEpaPenetrationDepthSolver(arg1 BtGjkEpaPenetrationDepthSolver) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGjkEpaPenetrationDepthSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtGjkEpaPenetrationDepthSolver interface { + Swigcptr() uintptr + SwigIsBtGjkEpaPenetrationDepthSolver() + CalcPenDepth(arg2 BtVoronoiSimplexSolver, arg3 BtConvexShape, arg4 BtConvexShape, arg5 BtTransform, arg6 BtTransform, arg7 BtVector3, arg8 BtVector3, arg9 BtVector3, arg10 BtIDebugDraw) (_swig_ret bool) +} + +type SwigcptrBtTriangleCallback uintptr + +func (p SwigcptrBtTriangleCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTriangleCallback) SwigIsBtTriangleCallback() { +} + +func DeleteBtTriangleCallback(arg1 BtTriangleCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTriangleCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtTriangleCallback) ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btTriangleCallback_processTriangle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +type BtTriangleCallback interface { + Swigcptr() uintptr + SwigIsBtTriangleCallback() + ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) +} + +type SwigcptrBtInternalTriangleIndexCallback uintptr + +func (p SwigcptrBtInternalTriangleIndexCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtInternalTriangleIndexCallback) SwigIsBtInternalTriangleIndexCallback() { +} + +func DeleteBtInternalTriangleIndexCallback(arg1 BtInternalTriangleIndexCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btInternalTriangleIndexCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtInternalTriangleIndexCallback) InternalProcessTriangleIndex(arg2 BtVector3, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btInternalTriangleIndexCallback_internalProcessTriangleIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +type BtInternalTriangleIndexCallback interface { + Swigcptr() uintptr + SwigIsBtInternalTriangleIndexCallback() + InternalProcessTriangleIndex(arg2 BtVector3, arg3 int, arg4 int) +} + +type PHY_ScalarType int + +func _swig_getPHY_FLOAT() (_swig_ret PHY_ScalarType) { + var swig_r PHY_ScalarType + swig_r = (PHY_ScalarType)(C._wrap_PHY_FLOAT_mbt_e879218550ba2e2b()) + return swig_r +} + +var PHY_FLOAT PHY_ScalarType = _swig_getPHY_FLOAT() + +func _swig_getPHY_DOUBLE() (_swig_ret PHY_ScalarType) { + var swig_r PHY_ScalarType + swig_r = (PHY_ScalarType)(C._wrap_PHY_DOUBLE_mbt_e879218550ba2e2b()) + return swig_r +} + +var PHY_DOUBLE PHY_ScalarType = _swig_getPHY_DOUBLE() + +func _swig_getPHY_INTEGER() (_swig_ret PHY_ScalarType) { + var swig_r PHY_ScalarType + swig_r = (PHY_ScalarType)(C._wrap_PHY_INTEGER_mbt_e879218550ba2e2b()) + return swig_r +} + +var PHY_INTEGER PHY_ScalarType = _swig_getPHY_INTEGER() + +func _swig_getPHY_SHORT() (_swig_ret PHY_ScalarType) { + var swig_r PHY_ScalarType + swig_r = (PHY_ScalarType)(C._wrap_PHY_SHORT_mbt_e879218550ba2e2b()) + return swig_r +} + +var PHY_SHORT PHY_ScalarType = _swig_getPHY_SHORT() + +func _swig_getPHY_FIXEDPOINT88() (_swig_ret PHY_ScalarType) { + var swig_r PHY_ScalarType + swig_r = (PHY_ScalarType)(C._wrap_PHY_FIXEDPOINT88_mbt_e879218550ba2e2b()) + return swig_r +} + +var PHY_FIXEDPOINT88 PHY_ScalarType = _swig_getPHY_FIXEDPOINT88() + +func _swig_getPHY_UCHAR() (_swig_ret PHY_ScalarType) { + var swig_r PHY_ScalarType + swig_r = (PHY_ScalarType)(C._wrap_PHY_UCHAR_mbt_e879218550ba2e2b()) + return swig_r +} + +var PHY_UCHAR PHY_ScalarType = _swig_getPHY_UCHAR() + +type SwigcptrBtConcaveShape uintptr + +func (p SwigcptrBtConcaveShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConcaveShape) SwigIsBtConcaveShape() { +} + +func DeleteBtConcaveShape(arg1 BtConcaveShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConcaveShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConcaveShape) ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btConcaveShape_processAllTriangles_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtConcaveShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConcaveShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConcaveShape) SetMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConcaveShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConcaveShape) GetAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btConcaveShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtConcaveShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btConcaveShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConcaveShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConcaveShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConcaveShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btConcaveShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtConcaveShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConcaveShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConcaveShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConcaveShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConcaveShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConcaveShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConcaveShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConcaveShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConcaveShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) SetLocalScaling(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btConcaveShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConcaveShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConcaveShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) CalculateLocalInertia(arg1 float32, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConcaveShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtConcaveShape) GetName() (_swig_ret string) { + var swig_r string + swig_r_p := C._wrap_btConcaveShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtConcaveShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConcaveShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConcaveShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btConcaveShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConcaveShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btConcaveShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConcaveShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConcaveShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConcaveShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConcaveShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConcaveShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConcaveShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConcaveShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConcaveShape) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btConcaveShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtConcaveShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btConcaveShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtConcaveShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtConcaveShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtConcaveShape interface { + Swigcptr() uintptr + SwigIsBtConcaveShape() + ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) + GetMargin() (_swig_ret float32) + SetMargin(arg2 float32) + GetAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + SetLocalScaling(arg1 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + CalculateLocalInertia(arg1 float32, arg2 BtVector3) + GetName() (_swig_ret string) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtStridingMeshInterface uintptr + +func (p SwigcptrBtStridingMeshInterface) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtStridingMeshInterface) SwigIsBtStridingMeshInterface() { +} + +func DeleteBtStridingMeshInterface(arg1 BtStridingMeshInterface) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btStridingMeshInterface_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) InternalProcessAllTriangles(arg2 BtInternalTriangleIndexCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btStridingMeshInterface_InternalProcessAllTriangles_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) CalculateAabbBruteForce(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btStridingMeshInterface_calculateAabbBruteForce_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) GetLockedVertexIndexBase__SWIG_0(arg2 **byte, arg3 *int, arg4 *PHY_ScalarType, arg5 *int, arg6 **byte, arg7 *int, arg8 *int, arg9 *PHY_ScalarType, arg10 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + _swig_i_9 := arg10 + C._wrap_btStridingMeshInterface_getLockedVertexIndexBase__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.swig_voidp(_swig_i_4), C.swig_voidp(_swig_i_5), C.swig_voidp(_swig_i_6), C.swig_voidp(_swig_i_7), C.swig_voidp(_swig_i_8), C.swig_intgo(_swig_i_9)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) GetLockedVertexIndexBase__SWIG_1(arg2 **byte, arg3 *int, arg4 *PHY_ScalarType, arg5 *int, arg6 **byte, arg7 *int, arg8 *int, arg9 *PHY_ScalarType) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + C._wrap_btStridingMeshInterface_getLockedVertexIndexBase__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.swig_voidp(_swig_i_4), C.swig_voidp(_swig_i_5), C.swig_voidp(_swig_i_6), C.swig_voidp(_swig_i_7), C.swig_voidp(_swig_i_8)) +} + +func (p SwigcptrBtStridingMeshInterface) GetLockedVertexIndexBase(a ...interface{}) { + argc := len(a) + if argc == 8 { + p.GetLockedVertexIndexBase__SWIG_1(a[0].(**byte), a[1].(*int), a[2].(*PHY_ScalarType), a[3].(*int), a[4].(**byte), a[5].(*int), a[6].(*int), a[7].(*PHY_ScalarType)) + return + } + if argc == 9 { + p.GetLockedVertexIndexBase__SWIG_0(a[0].(**byte), a[1].(*int), a[2].(*PHY_ScalarType), a[3].(*int), a[4].(**byte), a[5].(*int), a[6].(*int), a[7].(*PHY_ScalarType), a[8].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtStridingMeshInterface) GetLockedReadOnlyVertexIndexBase__SWIG_0(arg2 **byte, arg3 *int, arg4 *PHY_ScalarType, arg5 *int, arg6 **byte, arg7 *int, arg8 *int, arg9 *PHY_ScalarType, arg10 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + _swig_i_9 := arg10 + C._wrap_btStridingMeshInterface_getLockedReadOnlyVertexIndexBase__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.swig_voidp(_swig_i_4), C.swig_voidp(_swig_i_5), C.swig_voidp(_swig_i_6), C.swig_voidp(_swig_i_7), C.swig_voidp(_swig_i_8), C.swig_intgo(_swig_i_9)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) GetLockedReadOnlyVertexIndexBase__SWIG_1(arg2 **byte, arg3 *int, arg4 *PHY_ScalarType, arg5 *int, arg6 **byte, arg7 *int, arg8 *int, arg9 *PHY_ScalarType) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + C._wrap_btStridingMeshInterface_getLockedReadOnlyVertexIndexBase__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3), C.swig_voidp(_swig_i_4), C.swig_voidp(_swig_i_5), C.swig_voidp(_swig_i_6), C.swig_voidp(_swig_i_7), C.swig_voidp(_swig_i_8)) +} + +func (p SwigcptrBtStridingMeshInterface) GetLockedReadOnlyVertexIndexBase(a ...interface{}) { + argc := len(a) + if argc == 8 { + p.GetLockedReadOnlyVertexIndexBase__SWIG_1(a[0].(**byte), a[1].(*int), a[2].(*PHY_ScalarType), a[3].(*int), a[4].(**byte), a[5].(*int), a[6].(*int), a[7].(*PHY_ScalarType)) + return + } + if argc == 9 { + p.GetLockedReadOnlyVertexIndexBase__SWIG_0(a[0].(**byte), a[1].(*int), a[2].(*PHY_ScalarType), a[3].(*int), a[4].(**byte), a[5].(*int), a[6].(*int), a[7].(*PHY_ScalarType), a[8].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtStridingMeshInterface) UnLockVertexBase(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btStridingMeshInterface_unLockVertexBase_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) UnLockReadOnlyVertexBase(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btStridingMeshInterface_unLockReadOnlyVertexBase_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) GetNumSubParts() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btStridingMeshInterface_getNumSubParts_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtStridingMeshInterface) PreallocateVertices(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btStridingMeshInterface_preallocateVertices_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) PreallocateIndices(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btStridingMeshInterface_preallocateIndices_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) HasPremadeAabb() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btStridingMeshInterface_hasPremadeAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtStridingMeshInterface) SetPremadeAabb(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btStridingMeshInterface_setPremadeAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) GetPremadeAabb(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btStridingMeshInterface_getPremadeAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) GetScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btStridingMeshInterface_getScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtStridingMeshInterface) SetScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btStridingMeshInterface_setScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtStridingMeshInterface) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btStridingMeshInterface_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtStridingMeshInterface) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btStridingMeshInterface_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +type BtStridingMeshInterface interface { + Swigcptr() uintptr + SwigIsBtStridingMeshInterface() + InternalProcessAllTriangles(arg2 BtInternalTriangleIndexCallback, arg3 BtVector3, arg4 BtVector3) + CalculateAabbBruteForce(arg2 BtVector3, arg3 BtVector3) + GetLockedVertexIndexBase(a ...interface{}) + GetLockedReadOnlyVertexIndexBase(a ...interface{}) + UnLockVertexBase(arg2 int) + UnLockReadOnlyVertexBase(arg2 int) + GetNumSubParts() (_swig_ret int) + PreallocateVertices(arg2 int) + PreallocateIndices(arg2 int) + HasPremadeAabb() (_swig_ret bool) + SetPremadeAabb(arg2 BtVector3, arg3 BtVector3) + GetPremadeAabb(arg2 BtVector3, arg3 BtVector3) + GetScaling() (_swig_ret BtVector3) + SetScaling(arg2 BtVector3) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) +} + +type SwigcptrBtIntIndexData uintptr + +func (p SwigcptrBtIntIndexData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtIntIndexData) SwigIsBtIntIndexData() { +} + +func (arg1 SwigcptrBtIntIndexData) SetM_value(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btIntIndexData_m_value_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtIntIndexData) GetM_value() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btIntIndexData_m_value_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtIntIndexData() (_swig_ret BtIntIndexData) { + var swig_r BtIntIndexData + swig_r = (BtIntIndexData)(SwigcptrBtIntIndexData(C._wrap_new_btIntIndexData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtIntIndexData(arg1 BtIntIndexData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btIntIndexData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtIntIndexData interface { + Swigcptr() uintptr + SwigIsBtIntIndexData() + SetM_value(arg2 int) + GetM_value() (_swig_ret int) +} + +type SwigcptrBtShortIntIndexData uintptr + +func (p SwigcptrBtShortIntIndexData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtShortIntIndexData) SwigIsBtShortIntIndexData() { +} + +func (arg1 SwigcptrBtShortIntIndexData) SetM_value(arg2 int16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btShortIntIndexData_m_value_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.short(_swig_i_1)) +} + +func (arg1 SwigcptrBtShortIntIndexData) GetM_value() (_swig_ret int16) { + var swig_r int16 + _swig_i_0 := arg1 + swig_r = (int16)(C._wrap_btShortIntIndexData_m_value_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtShortIntIndexData) SetM_pad(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btShortIntIndexData_m_pad_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_111)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtShortIntIndexData) GetM_pad() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btShortIntIndexData_m_pad_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtShortIntIndexData() (_swig_ret BtShortIntIndexData) { + var swig_r BtShortIntIndexData + swig_r = (BtShortIntIndexData)(SwigcptrBtShortIntIndexData(C._wrap_new_btShortIntIndexData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtShortIntIndexData(arg1 BtShortIntIndexData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btShortIntIndexData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtShortIntIndexData interface { + Swigcptr() uintptr + SwigIsBtShortIntIndexData() + SetM_value(arg2 int16) + GetM_value() (_swig_ret int16) + SetM_pad(arg2 string) + GetM_pad() (_swig_ret string) +} + +type SwigcptrBtShortIntIndexTripletData uintptr + +func (p SwigcptrBtShortIntIndexTripletData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtShortIntIndexTripletData) SwigIsBtShortIntIndexTripletData() { +} + +func (arg1 SwigcptrBtShortIntIndexTripletData) SetM_values(arg2 *int16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btShortIntIndexTripletData_m_values_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtShortIntIndexTripletData) GetM_values() (_swig_ret *int16) { + var swig_r *int16 + _swig_i_0 := arg1 + swig_r = (*int16)(C._wrap_btShortIntIndexTripletData_m_values_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtShortIntIndexTripletData) SetM_pad(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btShortIntIndexTripletData_m_pad_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_113)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtShortIntIndexTripletData) GetM_pad() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btShortIntIndexTripletData_m_pad_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtShortIntIndexTripletData() (_swig_ret BtShortIntIndexTripletData) { + var swig_r BtShortIntIndexTripletData + swig_r = (BtShortIntIndexTripletData)(SwigcptrBtShortIntIndexTripletData(C._wrap_new_btShortIntIndexTripletData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtShortIntIndexTripletData(arg1 BtShortIntIndexTripletData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btShortIntIndexTripletData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtShortIntIndexTripletData interface { + Swigcptr() uintptr + SwigIsBtShortIntIndexTripletData() + SetM_values(arg2 *int16) + GetM_values() (_swig_ret *int16) + SetM_pad(arg2 string) + GetM_pad() (_swig_ret string) +} + +type SwigcptrBtCharIndexTripletData uintptr + +func (p SwigcptrBtCharIndexTripletData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCharIndexTripletData) SwigIsBtCharIndexTripletData() { +} + +func (arg1 SwigcptrBtCharIndexTripletData) SetM_values(arg2 *byte) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCharIndexTripletData_m_values_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtCharIndexTripletData) GetM_values() (_swig_ret *byte) { + var swig_r *byte + _swig_i_0 := arg1 + swig_r = (*byte)(C._wrap_btCharIndexTripletData_m_values_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtCharIndexTripletData) SetM_pad(arg2 byte) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCharIndexTripletData_m_pad_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.char(_swig_i_1)) +} + +func (arg1 SwigcptrBtCharIndexTripletData) GetM_pad() (_swig_ret byte) { + var swig_r byte + _swig_i_0 := arg1 + swig_r = (byte)(C._wrap_btCharIndexTripletData_m_pad_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtCharIndexTripletData() (_swig_ret BtCharIndexTripletData) { + var swig_r BtCharIndexTripletData + swig_r = (BtCharIndexTripletData)(SwigcptrBtCharIndexTripletData(C._wrap_new_btCharIndexTripletData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtCharIndexTripletData(arg1 BtCharIndexTripletData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCharIndexTripletData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtCharIndexTripletData interface { + Swigcptr() uintptr + SwigIsBtCharIndexTripletData() + SetM_values(arg2 *byte) + GetM_values() (_swig_ret *byte) + SetM_pad(arg2 byte) + GetM_pad() (_swig_ret byte) +} + +type SwigcptrBtMeshPartData uintptr + +func (p SwigcptrBtMeshPartData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMeshPartData) SwigIsBtMeshPartData() { +} + +func (arg1 SwigcptrBtMeshPartData) SetM_vertices3f(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMeshPartData_m_vertices3f_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMeshPartData) GetM_vertices3f() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btMeshPartData_m_vertices3f_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMeshPartData) SetM_vertices3d(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMeshPartData_m_vertices3d_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMeshPartData) GetM_vertices3d() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btMeshPartData_m_vertices3d_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMeshPartData) SetM_indices32(arg2 BtIntIndexData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMeshPartData_m_indices32_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMeshPartData) GetM_indices32() (_swig_ret BtIntIndexData) { + var swig_r BtIntIndexData + _swig_i_0 := arg1 + swig_r = (BtIntIndexData)(SwigcptrBtIntIndexData(C._wrap_btMeshPartData_m_indices32_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMeshPartData) SetM_3indices16(arg2 BtShortIntIndexTripletData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMeshPartData_m_3indices16_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMeshPartData) GetM_3indices16() (_swig_ret BtShortIntIndexTripletData) { + var swig_r BtShortIntIndexTripletData + _swig_i_0 := arg1 + swig_r = (BtShortIntIndexTripletData)(SwigcptrBtShortIntIndexTripletData(C._wrap_btMeshPartData_m_3indices16_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMeshPartData) SetM_3indices8(arg2 BtCharIndexTripletData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMeshPartData_m_3indices8_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMeshPartData) GetM_3indices8() (_swig_ret BtCharIndexTripletData) { + var swig_r BtCharIndexTripletData + _swig_i_0 := arg1 + swig_r = (BtCharIndexTripletData)(SwigcptrBtCharIndexTripletData(C._wrap_btMeshPartData_m_3indices8_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMeshPartData) SetM_indices16(arg2 BtShortIntIndexData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMeshPartData_m_indices16_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMeshPartData) GetM_indices16() (_swig_ret BtShortIntIndexData) { + var swig_r BtShortIntIndexData + _swig_i_0 := arg1 + swig_r = (BtShortIntIndexData)(SwigcptrBtShortIntIndexData(C._wrap_btMeshPartData_m_indices16_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMeshPartData) SetM_numTriangles(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btMeshPartData_m_numTriangles_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtMeshPartData) GetM_numTriangles() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btMeshPartData_m_numTriangles_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtMeshPartData) SetM_numVertices(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btMeshPartData_m_numVertices_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtMeshPartData) GetM_numVertices() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btMeshPartData_m_numVertices_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtMeshPartData() (_swig_ret BtMeshPartData) { + var swig_r BtMeshPartData + swig_r = (BtMeshPartData)(SwigcptrBtMeshPartData(C._wrap_new_btMeshPartData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtMeshPartData(arg1 BtMeshPartData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMeshPartData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtMeshPartData interface { + Swigcptr() uintptr + SwigIsBtMeshPartData() + SetM_vertices3f(arg2 BtVector3FloatData) + GetM_vertices3f() (_swig_ret BtVector3FloatData) + SetM_vertices3d(arg2 BtVector3DoubleData) + GetM_vertices3d() (_swig_ret BtVector3DoubleData) + SetM_indices32(arg2 BtIntIndexData) + GetM_indices32() (_swig_ret BtIntIndexData) + SetM_3indices16(arg2 BtShortIntIndexTripletData) + GetM_3indices16() (_swig_ret BtShortIntIndexTripletData) + SetM_3indices8(arg2 BtCharIndexTripletData) + GetM_3indices8() (_swig_ret BtCharIndexTripletData) + SetM_indices16(arg2 BtShortIntIndexData) + GetM_indices16() (_swig_ret BtShortIntIndexData) + SetM_numTriangles(arg2 int) + GetM_numTriangles() (_swig_ret int) + SetM_numVertices(arg2 int) + GetM_numVertices() (_swig_ret int) +} + +type SwigcptrBtStridingMeshInterfaceData uintptr + +func (p SwigcptrBtStridingMeshInterfaceData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtStridingMeshInterfaceData) SwigIsBtStridingMeshInterfaceData() { +} + +func (arg1 SwigcptrBtStridingMeshInterfaceData) SetM_meshPartsPtr(arg2 BtMeshPartData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btStridingMeshInterfaceData_m_meshPartsPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtStridingMeshInterfaceData) GetM_meshPartsPtr() (_swig_ret BtMeshPartData) { + var swig_r BtMeshPartData + _swig_i_0 := arg1 + swig_r = (BtMeshPartData)(SwigcptrBtMeshPartData(C._wrap_btStridingMeshInterfaceData_m_meshPartsPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtStridingMeshInterfaceData) SetM_scaling(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btStridingMeshInterfaceData_m_scaling_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtStridingMeshInterfaceData) GetM_scaling() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btStridingMeshInterfaceData_m_scaling_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtStridingMeshInterfaceData) SetM_numMeshParts(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btStridingMeshInterfaceData_m_numMeshParts_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtStridingMeshInterfaceData) GetM_numMeshParts() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btStridingMeshInterfaceData_m_numMeshParts_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtStridingMeshInterfaceData) SetM_padding(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btStridingMeshInterfaceData_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_115)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtStridingMeshInterfaceData) GetM_padding() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btStridingMeshInterfaceData_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtStridingMeshInterfaceData() (_swig_ret BtStridingMeshInterfaceData) { + var swig_r BtStridingMeshInterfaceData + swig_r = (BtStridingMeshInterfaceData)(SwigcptrBtStridingMeshInterfaceData(C._wrap_new_btStridingMeshInterfaceData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtStridingMeshInterfaceData(arg1 BtStridingMeshInterfaceData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btStridingMeshInterfaceData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtStridingMeshInterfaceData interface { + Swigcptr() uintptr + SwigIsBtStridingMeshInterfaceData() + SetM_meshPartsPtr(arg2 BtMeshPartData) + GetM_meshPartsPtr() (_swig_ret BtMeshPartData) + SetM_scaling(arg2 BtVector3FloatData) + GetM_scaling() (_swig_ret BtVector3FloatData) + SetM_numMeshParts(arg2 int) + GetM_numMeshParts() (_swig_ret int) + SetM_padding(arg2 string) + GetM_padding() (_swig_ret string) +} + +type SwigcptrBtTriangleMeshShape uintptr + +func (p SwigcptrBtTriangleMeshShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTriangleMeshShape) SwigIsBtTriangleMeshShape() { +} + +func DeleteBtTriangleMeshShape(arg1 BtTriangleMeshShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTriangleMeshShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtTriangleMeshShape) LocalGetSupportingVertex(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTriangleMeshShape_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShape) LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTriangleMeshShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShape) RecalcLocalAabb() { + _swig_i_0 := arg1 + C._wrap_btTriangleMeshShape_recalcLocalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtTriangleMeshShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btTriangleMeshShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtTriangleMeshShape) ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btTriangleMeshShape_processAllTriangles_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtTriangleMeshShape) CalculateLocalInertia(arg2 float32, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btTriangleMeshShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtTriangleMeshShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleMeshShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleMeshShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTriangleMeshShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShape) GetMeshInterface__SWIG_0() (_swig_ret BtStridingMeshInterface) { + var swig_r BtStridingMeshInterface + _swig_i_0 := arg1 + swig_r = (BtStridingMeshInterface)(SwigcptrBtStridingMeshInterface(C._wrap_btTriangleMeshShape_getMeshInterface__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShape) GetMeshInterface__SWIG_1() (_swig_ret BtStridingMeshInterface) { + var swig_r BtStridingMeshInterface + _swig_i_0 := arg1 + swig_r = (BtStridingMeshInterface)(SwigcptrBtStridingMeshInterface(C._wrap_btTriangleMeshShape_getMeshInterface__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtTriangleMeshShape) GetMeshInterface(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetMeshInterface__SWIG_0() + } + if argc == 0 { + return p.GetMeshInterface__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtTriangleMeshShape) GetLocalAabbMin() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTriangleMeshShape_getLocalAabbMin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShape) GetLocalAabbMax() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTriangleMeshShape_getLocalAabbMax_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShape) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btTriangleMeshShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtTriangleMeshShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btTriangleMeshShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) SetMargin(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btTriangleMeshShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtTriangleMeshShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btTriangleMeshShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtTriangleMeshShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btTriangleMeshShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleMeshShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btTriangleMeshShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtTriangleMeshShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btTriangleMeshShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btTriangleMeshShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btTriangleMeshShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btTriangleMeshShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btTriangleMeshShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btTriangleMeshShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btTriangleMeshShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btTriangleMeshShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btTriangleMeshShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTriangleMeshShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btTriangleMeshShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtTriangleMeshShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btTriangleMeshShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btTriangleMeshShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtTriangleMeshShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btTriangleMeshShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btTriangleMeshShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtTriangleMeshShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btTriangleMeshShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btTriangleMeshShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtTriangleMeshShape) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btTriangleMeshShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtTriangleMeshShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btTriangleMeshShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtTriangleMeshShape) SwigIsBtConcaveShape() { +} + +func (p SwigcptrBtTriangleMeshShape) SwigGetBtConcaveShape() BtConcaveShape { + return SwigcptrBtConcaveShape(getSwigcptr(p)) +} + +func (p SwigcptrBtTriangleMeshShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtTriangleMeshShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtTriangleMeshShape interface { + Swigcptr() uintptr + SwigIsBtTriangleMeshShape() + LocalGetSupportingVertex(arg2 BtVector3) (_swig_ret BtVector3) + LocalGetSupportingVertexWithoutMargin(arg2 BtVector3) (_swig_ret BtVector3) + RecalcLocalAabb() + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) + CalculateLocalInertia(arg2 float32, arg3 BtVector3) + SetLocalScaling(arg2 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetMeshInterface(a ...interface{}) interface{} + GetLocalAabbMin() (_swig_ret BtVector3) + GetLocalAabbMax() (_swig_ret BtVector3) + GetName() (_swig_ret string) + GetMargin() (_swig_ret float32) + SetMargin(arg1 float32) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtConcaveShape() + SwigGetBtConcaveShape() BtConcaveShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +const BtQuantizedBvhDataName string = "btQuantizedBvhFloatData" +const MAX_SUBTREE_SIZE_IN_BYTES int = 2048 +const MAX_NUM_PARTS_IN_BITS int = 4 + +type SwigcptrBtQuantizedBvhNode uintptr + +func (p SwigcptrBtQuantizedBvhNode) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtQuantizedBvhNode) SwigIsBtQuantizedBvhNode() { +} + +func (arg1 SwigcptrBtQuantizedBvhNode) SetM_quantizedAabbMin(arg2 *uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhNode_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhNode) GetM_quantizedAabbMin() (_swig_ret *uint16) { + var swig_r *uint16 + _swig_i_0 := arg1 + swig_r = (*uint16)(C._wrap_btQuantizedBvhNode_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhNode) SetM_quantizedAabbMax(arg2 *uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhNode_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhNode) GetM_quantizedAabbMax() (_swig_ret *uint16) { + var swig_r *uint16 + _swig_i_0 := arg1 + swig_r = (*uint16)(C._wrap_btQuantizedBvhNode_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhNode) SetM_escapeIndexOrTriangleIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhNode_m_escapeIndexOrTriangleIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhNode) GetM_escapeIndexOrTriangleIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhNode_m_escapeIndexOrTriangleIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhNode) IsLeafNode() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btQuantizedBvhNode_isLeafNode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhNode) GetEscapeIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhNode_getEscapeIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhNode) GetTriangleIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhNode_getTriangleIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhNode) GetPartId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhNode_getPartId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtQuantizedBvhNode() (_swig_ret BtQuantizedBvhNode) { + var swig_r BtQuantizedBvhNode + swig_r = (BtQuantizedBvhNode)(SwigcptrBtQuantizedBvhNode(C._wrap_new_btQuantizedBvhNode_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtQuantizedBvhNode(arg1 BtQuantizedBvhNode) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btQuantizedBvhNode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtQuantizedBvhNode interface { + Swigcptr() uintptr + SwigIsBtQuantizedBvhNode() + SetM_quantizedAabbMin(arg2 *uint16) + GetM_quantizedAabbMin() (_swig_ret *uint16) + SetM_quantizedAabbMax(arg2 *uint16) + GetM_quantizedAabbMax() (_swig_ret *uint16) + SetM_escapeIndexOrTriangleIndex(arg2 int) + GetM_escapeIndexOrTriangleIndex() (_swig_ret int) + IsLeafNode() (_swig_ret bool) + GetEscapeIndex() (_swig_ret int) + GetTriangleIndex() (_swig_ret int) + GetPartId() (_swig_ret int) +} + +type SwigcptrBtOptimizedBvhNode uintptr + +func (p SwigcptrBtOptimizedBvhNode) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtOptimizedBvhNode) SwigIsBtOptimizedBvhNode() { +} + +func (arg1 SwigcptrBtOptimizedBvhNode) SetM_aabbMinOrg(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOptimizedBvhNode_m_aabbMinOrg_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNode) GetM_aabbMinOrg() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btOptimizedBvhNode_m_aabbMinOrg_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNode) SetM_aabbMaxOrg(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOptimizedBvhNode_m_aabbMaxOrg_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNode) GetM_aabbMaxOrg() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btOptimizedBvhNode_m_aabbMaxOrg_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNode) SetM_escapeIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNode_m_escapeIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNode) GetM_escapeIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btOptimizedBvhNode_m_escapeIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNode) SetM_subPart(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNode_m_subPart_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNode) GetM_subPart() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btOptimizedBvhNode_m_subPart_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNode) SetM_triangleIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNode_m_triangleIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNode) GetM_triangleIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btOptimizedBvhNode_m_triangleIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNode) SetM_padding(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNode_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_119)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtOptimizedBvhNode) GetM_padding() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btOptimizedBvhNode_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtOptimizedBvhNode() (_swig_ret BtOptimizedBvhNode) { + var swig_r BtOptimizedBvhNode + swig_r = (BtOptimizedBvhNode)(SwigcptrBtOptimizedBvhNode(C._wrap_new_btOptimizedBvhNode_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtOptimizedBvhNode(arg1 BtOptimizedBvhNode) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btOptimizedBvhNode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtOptimizedBvhNode interface { + Swigcptr() uintptr + SwigIsBtOptimizedBvhNode() + SetM_aabbMinOrg(arg2 BtVector3) + GetM_aabbMinOrg() (_swig_ret BtVector3) + SetM_aabbMaxOrg(arg2 BtVector3) + GetM_aabbMaxOrg() (_swig_ret BtVector3) + SetM_escapeIndex(arg2 int) + GetM_escapeIndex() (_swig_ret int) + SetM_subPart(arg2 int) + GetM_subPart() (_swig_ret int) + SetM_triangleIndex(arg2 int) + GetM_triangleIndex() (_swig_ret int) + SetM_padding(arg2 string) + GetM_padding() (_swig_ret string) +} + +type SwigcptrBtBvhSubtreeInfo uintptr + +func (p SwigcptrBtBvhSubtreeInfo) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBvhSubtreeInfo) SwigIsBtBvhSubtreeInfo() { +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) SetM_quantizedAabbMin(arg2 *uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBvhSubtreeInfo_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) GetM_quantizedAabbMin() (_swig_ret *uint16) { + var swig_r *uint16 + _swig_i_0 := arg1 + swig_r = (*uint16)(C._wrap_btBvhSubtreeInfo_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) SetM_quantizedAabbMax(arg2 *uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBvhSubtreeInfo_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) GetM_quantizedAabbMax() (_swig_ret *uint16) { + var swig_r *uint16 + _swig_i_0 := arg1 + swig_r = (*uint16)(C._wrap_btBvhSubtreeInfo_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) SetM_rootNodeIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBvhSubtreeInfo_m_rootNodeIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) GetM_rootNodeIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBvhSubtreeInfo_m_rootNodeIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) SetM_subtreeSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBvhSubtreeInfo_m_subtreeSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) GetM_subtreeSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBvhSubtreeInfo_m_subtreeSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) SetM_padding(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBvhSubtreeInfo_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) GetM_padding() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btBvhSubtreeInfo_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtBvhSubtreeInfo() (_swig_ret BtBvhSubtreeInfo) { + var swig_r BtBvhSubtreeInfo + swig_r = (BtBvhSubtreeInfo)(SwigcptrBtBvhSubtreeInfo(C._wrap_new_btBvhSubtreeInfo_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtBvhSubtreeInfo) SetAabbFromQuantizeNode(arg2 BtQuantizedBvhNode) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBvhSubtreeInfo_setAabbFromQuantizeNode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBtBvhSubtreeInfo(arg1 BtBvhSubtreeInfo) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBvhSubtreeInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtBvhSubtreeInfo interface { + Swigcptr() uintptr + SwigIsBtBvhSubtreeInfo() + SetM_quantizedAabbMin(arg2 *uint16) + GetM_quantizedAabbMin() (_swig_ret *uint16) + SetM_quantizedAabbMax(arg2 *uint16) + GetM_quantizedAabbMax() (_swig_ret *uint16) + SetM_rootNodeIndex(arg2 int) + GetM_rootNodeIndex() (_swig_ret int) + SetM_subtreeSize(arg2 int) + GetM_subtreeSize() (_swig_ret int) + SetM_padding(arg2 *int) + GetM_padding() (_swig_ret *int) + SetAabbFromQuantizeNode(arg2 BtQuantizedBvhNode) +} + +type SwigcptrBtNodeOverlapCallback uintptr + +func (p SwigcptrBtNodeOverlapCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtNodeOverlapCallback) SwigIsBtNodeOverlapCallback() { +} + +func DeleteBtNodeOverlapCallback(arg1 BtNodeOverlapCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btNodeOverlapCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtNodeOverlapCallback) ProcessNode(arg2 int, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btNodeOverlapCallback_processNode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +type BtNodeOverlapCallback interface { + Swigcptr() uintptr + SwigIsBtNodeOverlapCallback() + ProcessNode(arg2 int, arg3 int) +} + +type SwigcptrBtQuantizedBvh uintptr + +func (p SwigcptrBtQuantizedBvh) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtQuantizedBvh) SwigIsBtQuantizedBvh() { +} + +type BtQuantizedBvhBtTraversalMode int + +func _swig_getbtQuantizedBvh_TRAVERSAL_STACKLESS_btQuantizedBvh() (_swig_ret BtQuantizedBvhBtTraversalMode) { + var swig_r BtQuantizedBvhBtTraversalMode + swig_r = (BtQuantizedBvhBtTraversalMode)(C._wrap_TRAVERSAL_STACKLESS_btQuantizedBvh_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtQuantizedBvhTRAVERSAL_STACKLESS BtQuantizedBvhBtTraversalMode = _swig_getbtQuantizedBvh_TRAVERSAL_STACKLESS_btQuantizedBvh() + +func _swig_getbtQuantizedBvh_TRAVERSAL_STACKLESS_CACHE_FRIENDLY_btQuantizedBvh() (_swig_ret BtQuantizedBvhBtTraversalMode) { + var swig_r BtQuantizedBvhBtTraversalMode + swig_r = (BtQuantizedBvhBtTraversalMode)(C._wrap_TRAVERSAL_STACKLESS_CACHE_FRIENDLY_btQuantizedBvh_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtQuantizedBvhTRAVERSAL_STACKLESS_CACHE_FRIENDLY BtQuantizedBvhBtTraversalMode = _swig_getbtQuantizedBvh_TRAVERSAL_STACKLESS_CACHE_FRIENDLY_btQuantizedBvh() + +func _swig_getbtQuantizedBvh_TRAVERSAL_RECURSIVE_btQuantizedBvh() (_swig_ret BtQuantizedBvhBtTraversalMode) { + var swig_r BtQuantizedBvhBtTraversalMode + swig_r = (BtQuantizedBvhBtTraversalMode)(C._wrap_TRAVERSAL_RECURSIVE_btQuantizedBvh_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtQuantizedBvhTRAVERSAL_RECURSIVE BtQuantizedBvhBtTraversalMode = _swig_getbtQuantizedBvh_TRAVERSAL_RECURSIVE_btQuantizedBvh() + +func NewBtQuantizedBvh() (_swig_ret BtQuantizedBvh) { + var swig_r BtQuantizedBvh + swig_r = (BtQuantizedBvh)(SwigcptrBtQuantizedBvh(C._wrap_new_btQuantizedBvh_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtQuantizedBvh(arg1 BtQuantizedBvh) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btQuantizedBvh_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtQuantizedBvh) SetQuantizationValues__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btQuantizedBvh_setQuantizationValues__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtQuantizedBvh) SetQuantizationValues__SWIG_1(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btQuantizedBvh_setQuantizationValues__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (p SwigcptrBtQuantizedBvh) SetQuantizationValues(a ...interface{}) { + argc := len(a) + if argc == 2 { + p.SetQuantizationValues__SWIG_1(a[0].(BtVector3), a[1].(BtVector3)) + return + } + if argc == 3 { + p.SetQuantizationValues__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtQuantizedBvh) GetLeafNodeArray() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_(C._wrap_btQuantizedBvh_getLeafNodeArray_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvh) BuildInternal() { + _swig_i_0 := arg1 + C._wrap_btQuantizedBvh_buildInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtQuantizedBvh) ReportAabbOverlappingNodex(arg2 BtNodeOverlapCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btQuantizedBvh_reportAabbOverlappingNodex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtQuantizedBvh) ReportRayOverlappingNodex(arg2 BtNodeOverlapCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btQuantizedBvh_reportRayOverlappingNodex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtQuantizedBvh) ReportBoxCastOverlappingNodex(arg2 BtNodeOverlapCallback, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btQuantizedBvh_reportBoxCastOverlappingNodex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtQuantizedBvh) Quantize(arg2 *uint16, arg3 BtVector3, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btQuantizedBvh_quantize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtQuantizedBvh) QuantizeWithClamp(arg2 *uint16, arg3 BtVector3, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btQuantizedBvh_quantizeWithClamp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtQuantizedBvh) UnQuantize(arg2 *uint16) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btQuantizedBvh_unQuantize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvh) SetTraversalMode(arg2 BtQuantizedBvhBtTraversalMode) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvh_setTraversalMode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvh) GetQuantizedNodeArray() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_(C._wrap_btQuantizedBvh_getQuantizedNodeArray_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvh) GetSubtreeInfoArray() (_swig_ret BtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_(C._wrap_btQuantizedBvh_getSubtreeInfoArray_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvh) CalculateSerializeBufferSize() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btQuantizedBvh_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvh) Serialize__SWIG_0(arg2 uintptr, arg3 uint, arg4 bool) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (bool)(C._wrap_btQuantizedBvh_serialize__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C._Bool(_swig_i_3))) + return swig_r +} + +func BtQuantizedBvhDeSerializeInPlace(arg1 uintptr, arg2 uint, arg3 bool) (_swig_ret BtQuantizedBvh) { + var swig_r BtQuantizedBvh + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtQuantizedBvh)(SwigcptrBtQuantizedBvh(C._wrap_btQuantizedBvh_deSerializeInPlace_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C._Bool(_swig_i_2)))) + return swig_r +} + +func BtQuantizedBvhGetAlignmentSerializationPadding() (_swig_ret uint) { + var swig_r uint + swig_r = (uint)(C._wrap_btQuantizedBvh_getAlignmentSerializationPadding_mbt_e879218550ba2e2b()) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvh) CalculateSerializeBufferSizeNew() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvh_calculateSerializeBufferSizeNew_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvh) Serialize__SWIG_1(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btQuantizedBvh_serialize__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (p SwigcptrBtQuantizedBvh) Serialize(a ...interface{}) interface{} { + argc := len(a) + if argc == 2 { + return p.Serialize__SWIG_1(a[0].(uintptr), a[1].(BtSerializer)) + } + if argc == 3 { + return p.Serialize__SWIG_0(a[0].(uintptr), a[1].(uint), a[2].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtQuantizedBvh) DeSerializeFloat(arg2 BtQuantizedBvhFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvh_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvh) DeSerializeDouble(arg2 BtQuantizedBvhDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvh_deSerializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvh) IsQuantized() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btQuantizedBvh_isQuantized_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +type BtQuantizedBvh interface { + Swigcptr() uintptr + SwigIsBtQuantizedBvh() + SetQuantizationValues(a ...interface{}) + GetLeafNodeArray() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_) + BuildInternal() + ReportAabbOverlappingNodex(arg2 BtNodeOverlapCallback, arg3 BtVector3, arg4 BtVector3) + ReportRayOverlappingNodex(arg2 BtNodeOverlapCallback, arg3 BtVector3, arg4 BtVector3) + ReportBoxCastOverlappingNodex(arg2 BtNodeOverlapCallback, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3) + Quantize(arg2 *uint16, arg3 BtVector3, arg4 int) + QuantizeWithClamp(arg2 *uint16, arg3 BtVector3, arg4 int) + UnQuantize(arg2 *uint16) (_swig_ret BtVector3) + SetTraversalMode(arg2 BtQuantizedBvhBtTraversalMode) + GetQuantizedNodeArray() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_) + GetSubtreeInfoArray() (_swig_ret BtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_) + CalculateSerializeBufferSize() (_swig_ret uint) + CalculateSerializeBufferSizeNew() (_swig_ret int) + Serialize(a ...interface{}) interface{} + DeSerializeFloat(arg2 BtQuantizedBvhFloatData) + DeSerializeDouble(arg2 BtQuantizedBvhDoubleData) + IsQuantized() (_swig_ret bool) +} + +type SwigcptrBtBvhSubtreeInfoData uintptr + +func (p SwigcptrBtBvhSubtreeInfoData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBvhSubtreeInfoData) SwigIsBtBvhSubtreeInfoData() { +} + +func (arg1 SwigcptrBtBvhSubtreeInfoData) SetM_rootNodeIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBvhSubtreeInfoData_m_rootNodeIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhSubtreeInfoData) GetM_rootNodeIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBvhSubtreeInfoData_m_rootNodeIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBvhSubtreeInfoData) SetM_subtreeSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBvhSubtreeInfoData_m_subtreeSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhSubtreeInfoData) GetM_subtreeSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBvhSubtreeInfoData_m_subtreeSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBvhSubtreeInfoData) SetM_quantizedAabbMin(arg2 *uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBvhSubtreeInfoData_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhSubtreeInfoData) GetM_quantizedAabbMin() (_swig_ret *uint16) { + var swig_r *uint16 + _swig_i_0 := arg1 + swig_r = (*uint16)(C._wrap_btBvhSubtreeInfoData_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBvhSubtreeInfoData) SetM_quantizedAabbMax(arg2 *uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBvhSubtreeInfoData_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhSubtreeInfoData) GetM_quantizedAabbMax() (_swig_ret *uint16) { + var swig_r *uint16 + _swig_i_0 := arg1 + swig_r = (*uint16)(C._wrap_btBvhSubtreeInfoData_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtBvhSubtreeInfoData() (_swig_ret BtBvhSubtreeInfoData) { + var swig_r BtBvhSubtreeInfoData + swig_r = (BtBvhSubtreeInfoData)(SwigcptrBtBvhSubtreeInfoData(C._wrap_new_btBvhSubtreeInfoData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtBvhSubtreeInfoData(arg1 BtBvhSubtreeInfoData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBvhSubtreeInfoData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtBvhSubtreeInfoData interface { + Swigcptr() uintptr + SwigIsBtBvhSubtreeInfoData() + SetM_rootNodeIndex(arg2 int) + GetM_rootNodeIndex() (_swig_ret int) + SetM_subtreeSize(arg2 int) + GetM_subtreeSize() (_swig_ret int) + SetM_quantizedAabbMin(arg2 *uint16) + GetM_quantizedAabbMin() (_swig_ret *uint16) + SetM_quantizedAabbMax(arg2 *uint16) + GetM_quantizedAabbMax() (_swig_ret *uint16) +} + +type SwigcptrBtOptimizedBvhNodeFloatData uintptr + +func (p SwigcptrBtOptimizedBvhNodeFloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtOptimizedBvhNodeFloatData) SwigIsBtOptimizedBvhNodeFloatData() { +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) SetM_aabbMinOrg(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOptimizedBvhNodeFloatData_m_aabbMinOrg_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) GetM_aabbMinOrg() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btOptimizedBvhNodeFloatData_m_aabbMinOrg_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) SetM_aabbMaxOrg(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOptimizedBvhNodeFloatData_m_aabbMaxOrg_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) GetM_aabbMaxOrg() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btOptimizedBvhNodeFloatData_m_aabbMaxOrg_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) SetM_escapeIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNodeFloatData_m_escapeIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) GetM_escapeIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btOptimizedBvhNodeFloatData_m_escapeIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) SetM_subPart(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNodeFloatData_m_subPart_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) GetM_subPart() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btOptimizedBvhNodeFloatData_m_subPart_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) SetM_triangleIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNodeFloatData_m_triangleIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) GetM_triangleIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btOptimizedBvhNodeFloatData_m_triangleIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) SetM_pad(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNodeFloatData_m_pad_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_122)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtOptimizedBvhNodeFloatData) GetM_pad() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btOptimizedBvhNodeFloatData_m_pad_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtOptimizedBvhNodeFloatData() (_swig_ret BtOptimizedBvhNodeFloatData) { + var swig_r BtOptimizedBvhNodeFloatData + swig_r = (BtOptimizedBvhNodeFloatData)(SwigcptrBtOptimizedBvhNodeFloatData(C._wrap_new_btOptimizedBvhNodeFloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtOptimizedBvhNodeFloatData(arg1 BtOptimizedBvhNodeFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btOptimizedBvhNodeFloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtOptimizedBvhNodeFloatData interface { + Swigcptr() uintptr + SwigIsBtOptimizedBvhNodeFloatData() + SetM_aabbMinOrg(arg2 BtVector3FloatData) + GetM_aabbMinOrg() (_swig_ret BtVector3FloatData) + SetM_aabbMaxOrg(arg2 BtVector3FloatData) + GetM_aabbMaxOrg() (_swig_ret BtVector3FloatData) + SetM_escapeIndex(arg2 int) + GetM_escapeIndex() (_swig_ret int) + SetM_subPart(arg2 int) + GetM_subPart() (_swig_ret int) + SetM_triangleIndex(arg2 int) + GetM_triangleIndex() (_swig_ret int) + SetM_pad(arg2 string) + GetM_pad() (_swig_ret string) +} + +type SwigcptrBtOptimizedBvhNodeDoubleData uintptr + +func (p SwigcptrBtOptimizedBvhNodeDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtOptimizedBvhNodeDoubleData) SwigIsBtOptimizedBvhNodeDoubleData() { +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) SetM_aabbMinOrg(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOptimizedBvhNodeDoubleData_m_aabbMinOrg_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) GetM_aabbMinOrg() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btOptimizedBvhNodeDoubleData_m_aabbMinOrg_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) SetM_aabbMaxOrg(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOptimizedBvhNodeDoubleData_m_aabbMaxOrg_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) GetM_aabbMaxOrg() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btOptimizedBvhNodeDoubleData_m_aabbMaxOrg_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) SetM_escapeIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNodeDoubleData_m_escapeIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) GetM_escapeIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btOptimizedBvhNodeDoubleData_m_escapeIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) SetM_subPart(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNodeDoubleData_m_subPart_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) GetM_subPart() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btOptimizedBvhNodeDoubleData_m_subPart_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) SetM_triangleIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNodeDoubleData_m_triangleIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) GetM_triangleIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btOptimizedBvhNodeDoubleData_m_triangleIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) SetM_pad(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btOptimizedBvhNodeDoubleData_m_pad_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_124)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtOptimizedBvhNodeDoubleData) GetM_pad() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btOptimizedBvhNodeDoubleData_m_pad_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtOptimizedBvhNodeDoubleData() (_swig_ret BtOptimizedBvhNodeDoubleData) { + var swig_r BtOptimizedBvhNodeDoubleData + swig_r = (BtOptimizedBvhNodeDoubleData)(SwigcptrBtOptimizedBvhNodeDoubleData(C._wrap_new_btOptimizedBvhNodeDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtOptimizedBvhNodeDoubleData(arg1 BtOptimizedBvhNodeDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btOptimizedBvhNodeDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtOptimizedBvhNodeDoubleData interface { + Swigcptr() uintptr + SwigIsBtOptimizedBvhNodeDoubleData() + SetM_aabbMinOrg(arg2 BtVector3DoubleData) + GetM_aabbMinOrg() (_swig_ret BtVector3DoubleData) + SetM_aabbMaxOrg(arg2 BtVector3DoubleData) + GetM_aabbMaxOrg() (_swig_ret BtVector3DoubleData) + SetM_escapeIndex(arg2 int) + GetM_escapeIndex() (_swig_ret int) + SetM_subPart(arg2 int) + GetM_subPart() (_swig_ret int) + SetM_triangleIndex(arg2 int) + GetM_triangleIndex() (_swig_ret int) + SetM_pad(arg2 string) + GetM_pad() (_swig_ret string) +} + +type SwigcptrBtQuantizedBvhNodeData uintptr + +func (p SwigcptrBtQuantizedBvhNodeData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtQuantizedBvhNodeData) SwigIsBtQuantizedBvhNodeData() { +} + +func (arg1 SwigcptrBtQuantizedBvhNodeData) SetM_quantizedAabbMin(arg2 *uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhNodeData_m_quantizedAabbMin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhNodeData) GetM_quantizedAabbMin() (_swig_ret *uint16) { + var swig_r *uint16 + _swig_i_0 := arg1 + swig_r = (*uint16)(C._wrap_btQuantizedBvhNodeData_m_quantizedAabbMin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhNodeData) SetM_quantizedAabbMax(arg2 *uint16) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhNodeData_m_quantizedAabbMax_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhNodeData) GetM_quantizedAabbMax() (_swig_ret *uint16) { + var swig_r *uint16 + _swig_i_0 := arg1 + swig_r = (*uint16)(C._wrap_btQuantizedBvhNodeData_m_quantizedAabbMax_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhNodeData) SetM_escapeIndexOrTriangleIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhNodeData_m_escapeIndexOrTriangleIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhNodeData) GetM_escapeIndexOrTriangleIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhNodeData_m_escapeIndexOrTriangleIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtQuantizedBvhNodeData() (_swig_ret BtQuantizedBvhNodeData) { + var swig_r BtQuantizedBvhNodeData + swig_r = (BtQuantizedBvhNodeData)(SwigcptrBtQuantizedBvhNodeData(C._wrap_new_btQuantizedBvhNodeData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtQuantizedBvhNodeData(arg1 BtQuantizedBvhNodeData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btQuantizedBvhNodeData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtQuantizedBvhNodeData interface { + Swigcptr() uintptr + SwigIsBtQuantizedBvhNodeData() + SetM_quantizedAabbMin(arg2 *uint16) + GetM_quantizedAabbMin() (_swig_ret *uint16) + SetM_quantizedAabbMax(arg2 *uint16) + GetM_quantizedAabbMax() (_swig_ret *uint16) + SetM_escapeIndexOrTriangleIndex(arg2 int) + GetM_escapeIndexOrTriangleIndex() (_swig_ret int) +} + +type SwigcptrBtQuantizedBvhFloatData uintptr + +func (p SwigcptrBtQuantizedBvhFloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtQuantizedBvhFloatData) SwigIsBtQuantizedBvhFloatData() { +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_bvhAabbMin(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhFloatData_m_bvhAabbMin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_bvhAabbMin() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btQuantizedBvhFloatData_m_bvhAabbMin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_bvhAabbMax(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhFloatData_m_bvhAabbMax_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_bvhAabbMax() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btQuantizedBvhFloatData_m_bvhAabbMax_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_bvhQuantization(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhFloatData_m_bvhQuantization_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_bvhQuantization() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btQuantizedBvhFloatData_m_bvhQuantization_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_curNodeIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhFloatData_m_curNodeIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_curNodeIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhFloatData_m_curNodeIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_useQuantization(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhFloatData_m_useQuantization_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_useQuantization() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhFloatData_m_useQuantization_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_numContiguousLeafNodes(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhFloatData_m_numContiguousLeafNodes_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_numContiguousLeafNodes() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhFloatData_m_numContiguousLeafNodes_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_numQuantizedContiguousNodes(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhFloatData_m_numQuantizedContiguousNodes_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_numQuantizedContiguousNodes() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhFloatData_m_numQuantizedContiguousNodes_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_contiguousNodesPtr(arg2 BtOptimizedBvhNodeFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhFloatData_m_contiguousNodesPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_contiguousNodesPtr() (_swig_ret BtOptimizedBvhNodeFloatData) { + var swig_r BtOptimizedBvhNodeFloatData + _swig_i_0 := arg1 + swig_r = (BtOptimizedBvhNodeFloatData)(SwigcptrBtOptimizedBvhNodeFloatData(C._wrap_btQuantizedBvhFloatData_m_contiguousNodesPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_quantizedContiguousNodesPtr(arg2 BtQuantizedBvhNodeData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhFloatData_m_quantizedContiguousNodesPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_quantizedContiguousNodesPtr() (_swig_ret BtQuantizedBvhNodeData) { + var swig_r BtQuantizedBvhNodeData + _swig_i_0 := arg1 + swig_r = (BtQuantizedBvhNodeData)(SwigcptrBtQuantizedBvhNodeData(C._wrap_btQuantizedBvhFloatData_m_quantizedContiguousNodesPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_subTreeInfoPtr(arg2 BtBvhSubtreeInfoData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhFloatData_m_subTreeInfoPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_subTreeInfoPtr() (_swig_ret BtBvhSubtreeInfoData) { + var swig_r BtBvhSubtreeInfoData + _swig_i_0 := arg1 + swig_r = (BtBvhSubtreeInfoData)(SwigcptrBtBvhSubtreeInfoData(C._wrap_btQuantizedBvhFloatData_m_subTreeInfoPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_traversalMode(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhFloatData_m_traversalMode_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_traversalMode() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhFloatData_m_traversalMode_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) SetM_numSubtreeHeaders(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhFloatData_m_numSubtreeHeaders_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhFloatData) GetM_numSubtreeHeaders() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhFloatData_m_numSubtreeHeaders_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtQuantizedBvhFloatData() (_swig_ret BtQuantizedBvhFloatData) { + var swig_r BtQuantizedBvhFloatData + swig_r = (BtQuantizedBvhFloatData)(SwigcptrBtQuantizedBvhFloatData(C._wrap_new_btQuantizedBvhFloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtQuantizedBvhFloatData(arg1 BtQuantizedBvhFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btQuantizedBvhFloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtQuantizedBvhFloatData interface { + Swigcptr() uintptr + SwigIsBtQuantizedBvhFloatData() + SetM_bvhAabbMin(arg2 BtVector3FloatData) + GetM_bvhAabbMin() (_swig_ret BtVector3FloatData) + SetM_bvhAabbMax(arg2 BtVector3FloatData) + GetM_bvhAabbMax() (_swig_ret BtVector3FloatData) + SetM_bvhQuantization(arg2 BtVector3FloatData) + GetM_bvhQuantization() (_swig_ret BtVector3FloatData) + SetM_curNodeIndex(arg2 int) + GetM_curNodeIndex() (_swig_ret int) + SetM_useQuantization(arg2 int) + GetM_useQuantization() (_swig_ret int) + SetM_numContiguousLeafNodes(arg2 int) + GetM_numContiguousLeafNodes() (_swig_ret int) + SetM_numQuantizedContiguousNodes(arg2 int) + GetM_numQuantizedContiguousNodes() (_swig_ret int) + SetM_contiguousNodesPtr(arg2 BtOptimizedBvhNodeFloatData) + GetM_contiguousNodesPtr() (_swig_ret BtOptimizedBvhNodeFloatData) + SetM_quantizedContiguousNodesPtr(arg2 BtQuantizedBvhNodeData) + GetM_quantizedContiguousNodesPtr() (_swig_ret BtQuantizedBvhNodeData) + SetM_subTreeInfoPtr(arg2 BtBvhSubtreeInfoData) + GetM_subTreeInfoPtr() (_swig_ret BtBvhSubtreeInfoData) + SetM_traversalMode(arg2 int) + GetM_traversalMode() (_swig_ret int) + SetM_numSubtreeHeaders(arg2 int) + GetM_numSubtreeHeaders() (_swig_ret int) +} + +type SwigcptrBtQuantizedBvhDoubleData uintptr + +func (p SwigcptrBtQuantizedBvhDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtQuantizedBvhDoubleData) SwigIsBtQuantizedBvhDoubleData() { +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_bvhAabbMin(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhDoubleData_m_bvhAabbMin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_bvhAabbMin() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btQuantizedBvhDoubleData_m_bvhAabbMin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_bvhAabbMax(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhDoubleData_m_bvhAabbMax_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_bvhAabbMax() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btQuantizedBvhDoubleData_m_bvhAabbMax_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_bvhQuantization(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhDoubleData_m_bvhQuantization_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_bvhQuantization() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btQuantizedBvhDoubleData_m_bvhQuantization_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_curNodeIndex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhDoubleData_m_curNodeIndex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_curNodeIndex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhDoubleData_m_curNodeIndex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_useQuantization(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhDoubleData_m_useQuantization_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_useQuantization() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhDoubleData_m_useQuantization_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_numContiguousLeafNodes(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhDoubleData_m_numContiguousLeafNodes_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_numContiguousLeafNodes() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhDoubleData_m_numContiguousLeafNodes_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_numQuantizedContiguousNodes(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhDoubleData_m_numQuantizedContiguousNodes_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_numQuantizedContiguousNodes() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhDoubleData_m_numQuantizedContiguousNodes_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_contiguousNodesPtr(arg2 BtOptimizedBvhNodeDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhDoubleData_m_contiguousNodesPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_contiguousNodesPtr() (_swig_ret BtOptimizedBvhNodeDoubleData) { + var swig_r BtOptimizedBvhNodeDoubleData + _swig_i_0 := arg1 + swig_r = (BtOptimizedBvhNodeDoubleData)(SwigcptrBtOptimizedBvhNodeDoubleData(C._wrap_btQuantizedBvhDoubleData_m_contiguousNodesPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_quantizedContiguousNodesPtr(arg2 BtQuantizedBvhNodeData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhDoubleData_m_quantizedContiguousNodesPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_quantizedContiguousNodesPtr() (_swig_ret BtQuantizedBvhNodeData) { + var swig_r BtQuantizedBvhNodeData + _swig_i_0 := arg1 + swig_r = (BtQuantizedBvhNodeData)(SwigcptrBtQuantizedBvhNodeData(C._wrap_btQuantizedBvhDoubleData_m_quantizedContiguousNodesPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_traversalMode(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhDoubleData_m_traversalMode_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_traversalMode() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhDoubleData_m_traversalMode_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_numSubtreeHeaders(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btQuantizedBvhDoubleData_m_numSubtreeHeaders_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_numSubtreeHeaders() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btQuantizedBvhDoubleData_m_numSubtreeHeaders_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) SetM_subTreeInfoPtr(arg2 BtBvhSubtreeInfoData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btQuantizedBvhDoubleData_m_subTreeInfoPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtQuantizedBvhDoubleData) GetM_subTreeInfoPtr() (_swig_ret BtBvhSubtreeInfoData) { + var swig_r BtBvhSubtreeInfoData + _swig_i_0 := arg1 + swig_r = (BtBvhSubtreeInfoData)(SwigcptrBtBvhSubtreeInfoData(C._wrap_btQuantizedBvhDoubleData_m_subTreeInfoPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtQuantizedBvhDoubleData() (_swig_ret BtQuantizedBvhDoubleData) { + var swig_r BtQuantizedBvhDoubleData + swig_r = (BtQuantizedBvhDoubleData)(SwigcptrBtQuantizedBvhDoubleData(C._wrap_new_btQuantizedBvhDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtQuantizedBvhDoubleData(arg1 BtQuantizedBvhDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btQuantizedBvhDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtQuantizedBvhDoubleData interface { + Swigcptr() uintptr + SwigIsBtQuantizedBvhDoubleData() + SetM_bvhAabbMin(arg2 BtVector3DoubleData) + GetM_bvhAabbMin() (_swig_ret BtVector3DoubleData) + SetM_bvhAabbMax(arg2 BtVector3DoubleData) + GetM_bvhAabbMax() (_swig_ret BtVector3DoubleData) + SetM_bvhQuantization(arg2 BtVector3DoubleData) + GetM_bvhQuantization() (_swig_ret BtVector3DoubleData) + SetM_curNodeIndex(arg2 int) + GetM_curNodeIndex() (_swig_ret int) + SetM_useQuantization(arg2 int) + GetM_useQuantization() (_swig_ret int) + SetM_numContiguousLeafNodes(arg2 int) + GetM_numContiguousLeafNodes() (_swig_ret int) + SetM_numQuantizedContiguousNodes(arg2 int) + GetM_numQuantizedContiguousNodes() (_swig_ret int) + SetM_contiguousNodesPtr(arg2 BtOptimizedBvhNodeDoubleData) + GetM_contiguousNodesPtr() (_swig_ret BtOptimizedBvhNodeDoubleData) + SetM_quantizedContiguousNodesPtr(arg2 BtQuantizedBvhNodeData) + GetM_quantizedContiguousNodesPtr() (_swig_ret BtQuantizedBvhNodeData) + SetM_traversalMode(arg2 int) + GetM_traversalMode() (_swig_ret int) + SetM_numSubtreeHeaders(arg2 int) + GetM_numSubtreeHeaders() (_swig_ret int) + SetM_subTreeInfoPtr(arg2 BtBvhSubtreeInfoData) + GetM_subTreeInfoPtr() (_swig_ret BtBvhSubtreeInfoData) +} + +type SwigcptrBtOptimizedBvh uintptr + +func (p SwigcptrBtOptimizedBvh) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtOptimizedBvh) SwigIsBtOptimizedBvh() { +} + +func NewBtOptimizedBvh() (_swig_ret BtOptimizedBvh) { + var swig_r BtOptimizedBvh + swig_r = (BtOptimizedBvh)(SwigcptrBtOptimizedBvh(C._wrap_new_btOptimizedBvh_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtOptimizedBvh(arg1 BtOptimizedBvh) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btOptimizedBvh_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtOptimizedBvh) Build(arg2 BtStridingMeshInterface, arg3 bool, arg4 BtVector3, arg5 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btOptimizedBvh_build_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C._Bool(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtOptimizedBvh) Refit(arg2 BtStridingMeshInterface, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btOptimizedBvh_refit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtOptimizedBvh) RefitPartial(arg2 BtStridingMeshInterface, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btOptimizedBvh_refitPartial_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtOptimizedBvh) UpdateBvhNodes(arg2 BtStridingMeshInterface, arg3 int, arg4 int, arg5 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btOptimizedBvh_updateBvhNodes_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.swig_intgo(_swig_i_4)) +} + +func (arg1 SwigcptrBtOptimizedBvh) SerializeInPlace(arg2 uintptr, arg3 uint, arg4 bool) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (bool)(C._wrap_btOptimizedBvh_serializeInPlace_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C._Bool(_swig_i_3))) + return swig_r +} + +func BtOptimizedBvhDeSerializeInPlace(arg1 uintptr, arg2 uint, arg3 bool) (_swig_ret BtOptimizedBvh) { + var swig_r BtOptimizedBvh + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtOptimizedBvh)(SwigcptrBtOptimizedBvh(C._wrap_btOptimizedBvh_deSerializeInPlace_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C._Bool(_swig_i_2)))) + return swig_r +} + +func (_swig_base SwigcptrBtOptimizedBvh) SetQuantizationValues__SWIG_0(arg1 BtVector3, arg2 BtVector3, arg3 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btOptimizedBvh_setQuantizationValues__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)) +} + +func (_swig_base SwigcptrBtOptimizedBvh) SetQuantizationValues__SWIG_1(arg1 BtVector3, arg2 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btOptimizedBvh_setQuantizationValues__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtOptimizedBvh) SetQuantizationValues(a ...interface{}) { + argc := len(a) + if argc == 2 { + p.SetQuantizationValues__SWIG_1(a[0].(BtVector3), a[1].(BtVector3)) + return + } + if argc == 3 { + p.SetQuantizationValues__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtOptimizedBvh) GetLeafNodeArray() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_ + swig_r = (BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_(C._wrap_btOptimizedBvh_getLeafNodeArray_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtOptimizedBvh) BuildInternal() { + C._wrap_btOptimizedBvh_buildInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtOptimizedBvh) ReportAabbOverlappingNodex(arg1 BtNodeOverlapCallback, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btOptimizedBvh_reportAabbOverlappingNodex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtOptimizedBvh) ReportRayOverlappingNodex(arg1 BtNodeOverlapCallback, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btOptimizedBvh_reportRayOverlappingNodex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtOptimizedBvh) ReportBoxCastOverlappingNodex(arg1 BtNodeOverlapCallback, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btOptimizedBvh_reportBoxCastOverlappingNodex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (_swig_base SwigcptrBtOptimizedBvh) Quantize(arg1 *uint16, arg2 BtVector3, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btOptimizedBvh_quantize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_voidp(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (_swig_base SwigcptrBtOptimizedBvh) QuantizeWithClamp(arg1 *uint16, arg2 BtVector3, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btOptimizedBvh_quantizeWithClamp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_voidp(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (_swig_base SwigcptrBtOptimizedBvh) UnQuantize(arg1 *uint16) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btOptimizedBvh_unQuantize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_voidp(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtOptimizedBvh) SetTraversalMode(arg1 BtQuantizedBvhBtTraversalMode) { + _swig_i_0 := arg1 + C._wrap_btOptimizedBvh_setTraversalMode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtOptimizedBvh) GetQuantizedNodeArray() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_ + swig_r = (BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_(C._wrap_btOptimizedBvh_getQuantizedNodeArray_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtOptimizedBvh) GetSubtreeInfoArray() (_swig_ret BtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_ + swig_r = (BtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_(C._wrap_btOptimizedBvh_getSubtreeInfoArray_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtOptimizedBvh) CalculateSerializeBufferSize() (_swig_ret uint) { + var swig_r uint + swig_r = (uint)(C._wrap_btOptimizedBvh_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtOptimizedBvh) Serialize__SWIG_0(arg1 uintptr, arg2 uint, arg3 bool) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (bool)(C._wrap_btOptimizedBvh_serialize__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C._Bool(_swig_i_2))) + return swig_r +} + +func (_swig_base SwigcptrBtOptimizedBvh) Serialize__SWIG_1(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btOptimizedBvh_serialize__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (p SwigcptrBtOptimizedBvh) Serialize(a ...interface{}) interface{} { + argc := len(a) + if argc == 2 { + return p.Serialize__SWIG_1(a[0].(uintptr), a[1].(BtSerializer)) + } + if argc == 3 { + return p.Serialize__SWIG_0(a[0].(uintptr), a[1].(uint), a[2].(bool)) + } + panic("No match for overloaded function call") +} + +func BtOptimizedBvhGetAlignmentSerializationPadding() (_swig_ret uint) { + var swig_r uint + swig_r = (uint)(C._wrap_btOptimizedBvh_getAlignmentSerializationPadding_mbt_e879218550ba2e2b()) + return swig_r +} + +func (_swig_base SwigcptrBtOptimizedBvh) CalculateSerializeBufferSizeNew() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btOptimizedBvh_calculateSerializeBufferSizeNew_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtOptimizedBvh) DeSerializeFloat(arg1 BtQuantizedBvhFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btOptimizedBvh_deSerializeFloat_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtOptimizedBvh) DeSerializeDouble(arg1 BtQuantizedBvhDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btOptimizedBvh_deSerializeDouble_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtOptimizedBvh) IsQuantized() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btOptimizedBvh_isQuantized_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtOptimizedBvh) SwigIsBtQuantizedBvh() { +} + +func (p SwigcptrBtOptimizedBvh) SwigGetBtQuantizedBvh() BtQuantizedBvh { + return SwigcptrBtQuantizedBvh(getSwigcptr(p)) +} + +type BtOptimizedBvh interface { + Swigcptr() uintptr + SwigIsBtOptimizedBvh() + Build(arg2 BtStridingMeshInterface, arg3 bool, arg4 BtVector3, arg5 BtVector3) + Refit(arg2 BtStridingMeshInterface, arg3 BtVector3, arg4 BtVector3) + RefitPartial(arg2 BtStridingMeshInterface, arg3 BtVector3, arg4 BtVector3) + UpdateBvhNodes(arg2 BtStridingMeshInterface, arg3 int, arg4 int, arg5 int) + SerializeInPlace(arg2 uintptr, arg3 uint, arg4 bool) (_swig_ret bool) + SetQuantizationValues(a ...interface{}) + GetLeafNodeArray() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_) + BuildInternal() + ReportAabbOverlappingNodex(arg1 BtNodeOverlapCallback, arg2 BtVector3, arg3 BtVector3) + ReportRayOverlappingNodex(arg1 BtNodeOverlapCallback, arg2 BtVector3, arg3 BtVector3) + ReportBoxCastOverlappingNodex(arg1 BtNodeOverlapCallback, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3) + Quantize(arg1 *uint16, arg2 BtVector3, arg3 int) + QuantizeWithClamp(arg1 *uint16, arg2 BtVector3, arg3 int) + UnQuantize(arg1 *uint16) (_swig_ret BtVector3) + SetTraversalMode(arg1 BtQuantizedBvhBtTraversalMode) + GetQuantizedNodeArray() (_swig_ret BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_) + GetSubtreeInfoArray() (_swig_ret BtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_) + CalculateSerializeBufferSize() (_swig_ret uint) + Serialize(a ...interface{}) interface{} + CalculateSerializeBufferSizeNew() (_swig_ret int) + DeSerializeFloat(arg1 BtQuantizedBvhFloatData) + DeSerializeDouble(arg1 BtQuantizedBvhDoubleData) + IsQuantized() (_swig_ret bool) + SwigIsBtQuantizedBvh() + SwigGetBtQuantizedBvh() BtQuantizedBvh +} + +const TRI_INFO_V0V1_CONVEX int = 1 +const TRI_INFO_V1V2_CONVEX int = 2 +const TRI_INFO_V2V0_CONVEX int = 4 +const TRI_INFO_V0V1_SWAP_NORMALB int = 8 +const TRI_INFO_V1V2_SWAP_NORMALB int = 16 +const TRI_INFO_V2V0_SWAP_NORMALB int = 32 + +type SwigcptrBtTriangleInfo uintptr + +func (p SwigcptrBtTriangleInfo) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTriangleInfo) SwigIsBtTriangleInfo() { +} + +func NewBtTriangleInfo() (_swig_ret BtTriangleInfo) { + var swig_r BtTriangleInfo + swig_r = (BtTriangleInfo)(SwigcptrBtTriangleInfo(C._wrap_new_btTriangleInfo_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfo) SetM_flags(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfo_m_flags_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfo) GetM_flags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTriangleInfo_m_flags_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfo) SetM_edgeV0V1Angle(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfo_m_edgeV0V1Angle_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfo) GetM_edgeV0V1Angle() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfo_m_edgeV0V1Angle_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfo) SetM_edgeV1V2Angle(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfo_m_edgeV1V2Angle_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfo) GetM_edgeV1V2Angle() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfo_m_edgeV1V2Angle_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfo) SetM_edgeV2V0Angle(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfo_m_edgeV2V0Angle_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfo) GetM_edgeV2V0Angle() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfo_m_edgeV2V0Angle_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtTriangleInfo(arg1 BtTriangleInfo) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTriangleInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTriangleInfo interface { + Swigcptr() uintptr + SwigIsBtTriangleInfo() + SetM_flags(arg2 int) + GetM_flags() (_swig_ret int) + SetM_edgeV0V1Angle(arg2 float32) + GetM_edgeV0V1Angle() (_swig_ret float32) + SetM_edgeV1V2Angle(arg2 float32) + GetM_edgeV1V2Angle() (_swig_ret float32) + SetM_edgeV2V0Angle(arg2 float32) + GetM_edgeV2V0Angle() (_swig_ret float32) +} + +type SwigcptrBtTriangleInfoMap uintptr + +func (p SwigcptrBtTriangleInfoMap) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTriangleInfoMap) SwigIsBtTriangleInfoMap() { +} + +func (arg1 SwigcptrBtTriangleInfoMap) SetM_convexEpsilon(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMap_m_convexEpsilon_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMap) GetM_convexEpsilon() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMap_m_convexEpsilon_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMap) SetM_planarEpsilon(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMap_m_planarEpsilon_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMap) GetM_planarEpsilon() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMap_m_planarEpsilon_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMap) SetM_equalVertexThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMap_m_equalVertexThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMap) GetM_equalVertexThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMap_m_equalVertexThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMap) SetM_edgeDistanceThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMap_m_edgeDistanceThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMap) GetM_edgeDistanceThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMap_m_edgeDistanceThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMap) SetM_maxEdgeAngleThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMap_m_maxEdgeAngleThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMap) GetM_maxEdgeAngleThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMap_m_maxEdgeAngleThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMap) SetM_zeroAreaThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMap_m_zeroAreaThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMap) GetM_zeroAreaThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMap_m_zeroAreaThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtTriangleInfoMap() (_swig_ret BtTriangleInfoMap) { + var swig_r BtTriangleInfoMap + swig_r = (BtTriangleInfoMap)(SwigcptrBtTriangleInfoMap(C._wrap_new_btTriangleInfoMap_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtTriangleInfoMap(arg1 BtTriangleInfoMap) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTriangleInfoMap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtTriangleInfoMap) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTriangleInfoMap_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMap) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btTriangleInfoMap_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtTriangleInfoMap) DeSerialize(arg2 BtTriangleInfoMapData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleInfoMap_deSerialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +type BtTriangleInfoMap interface { + Swigcptr() uintptr + SwigIsBtTriangleInfoMap() + SetM_convexEpsilon(arg2 float32) + GetM_convexEpsilon() (_swig_ret float32) + SetM_planarEpsilon(arg2 float32) + GetM_planarEpsilon() (_swig_ret float32) + SetM_equalVertexThreshold(arg2 float32) + GetM_equalVertexThreshold() (_swig_ret float32) + SetM_edgeDistanceThreshold(arg2 float32) + GetM_edgeDistanceThreshold() (_swig_ret float32) + SetM_maxEdgeAngleThreshold(arg2 float32) + GetM_maxEdgeAngleThreshold() (_swig_ret float32) + SetM_zeroAreaThreshold(arg2 float32) + GetM_zeroAreaThreshold() (_swig_ret float32) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + DeSerialize(arg2 BtTriangleInfoMapData) +} + +type SwigcptrBtTriangleInfoData uintptr + +func (p SwigcptrBtTriangleInfoData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTriangleInfoData) SwigIsBtTriangleInfoData() { +} + +func (arg1 SwigcptrBtTriangleInfoData) SetM_flags(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoData_m_flags_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoData) GetM_flags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTriangleInfoData_m_flags_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoData) SetM_edgeV0V1Angle(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoData_m_edgeV0V1Angle_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoData) GetM_edgeV0V1Angle() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoData_m_edgeV0V1Angle_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoData) SetM_edgeV1V2Angle(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoData_m_edgeV1V2Angle_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoData) GetM_edgeV1V2Angle() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoData_m_edgeV1V2Angle_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoData) SetM_edgeV2V0Angle(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoData_m_edgeV2V0Angle_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoData) GetM_edgeV2V0Angle() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoData_m_edgeV2V0Angle_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtTriangleInfoData() (_swig_ret BtTriangleInfoData) { + var swig_r BtTriangleInfoData + swig_r = (BtTriangleInfoData)(SwigcptrBtTriangleInfoData(C._wrap_new_btTriangleInfoData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtTriangleInfoData(arg1 BtTriangleInfoData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTriangleInfoData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTriangleInfoData interface { + Swigcptr() uintptr + SwigIsBtTriangleInfoData() + SetM_flags(arg2 int) + GetM_flags() (_swig_ret int) + SetM_edgeV0V1Angle(arg2 float32) + GetM_edgeV0V1Angle() (_swig_ret float32) + SetM_edgeV1V2Angle(arg2 float32) + GetM_edgeV1V2Angle() (_swig_ret float32) + SetM_edgeV2V0Angle(arg2 float32) + GetM_edgeV2V0Angle() (_swig_ret float32) +} + +type SwigcptrBtTriangleInfoMapData uintptr + +func (p SwigcptrBtTriangleInfoMapData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTriangleInfoMapData) SwigIsBtTriangleInfoMapData() { +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_hashTablePtr(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_hashTablePtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_hashTablePtr() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btTriangleInfoMapData_m_hashTablePtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_nextPtr(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_nextPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_nextPtr() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btTriangleInfoMapData_m_nextPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_valueArrayPtr(arg2 BtTriangleInfoData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleInfoMapData_m_valueArrayPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_valueArrayPtr() (_swig_ret BtTriangleInfoData) { + var swig_r BtTriangleInfoData + _swig_i_0 := arg1 + swig_r = (BtTriangleInfoData)(SwigcptrBtTriangleInfoData(C._wrap_btTriangleInfoMapData_m_valueArrayPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_keyArrayPtr(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_keyArrayPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_keyArrayPtr() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btTriangleInfoMapData_m_keyArrayPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_convexEpsilon(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_convexEpsilon_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_convexEpsilon() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMapData_m_convexEpsilon_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_planarEpsilon(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_planarEpsilon_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_planarEpsilon() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMapData_m_planarEpsilon_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_equalVertexThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_equalVertexThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_equalVertexThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMapData_m_equalVertexThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_edgeDistanceThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_edgeDistanceThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_edgeDistanceThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMapData_m_edgeDistanceThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_zeroAreaThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_zeroAreaThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_zeroAreaThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleInfoMapData_m_zeroAreaThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_nextSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_nextSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_nextSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTriangleInfoMapData_m_nextSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_hashTableSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_hashTableSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_hashTableSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTriangleInfoMapData_m_hashTableSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_numValues(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_numValues_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_numValues() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTriangleInfoMapData_m_numValues_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_numKeys(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_numKeys_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_numKeys() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btTriangleInfoMapData_m_numKeys_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleInfoMapData) SetM_padding(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleInfoMapData_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_128)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtTriangleInfoMapData) GetM_padding() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btTriangleInfoMapData_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtTriangleInfoMapData() (_swig_ret BtTriangleInfoMapData) { + var swig_r BtTriangleInfoMapData + swig_r = (BtTriangleInfoMapData)(SwigcptrBtTriangleInfoMapData(C._wrap_new_btTriangleInfoMapData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtTriangleInfoMapData(arg1 BtTriangleInfoMapData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTriangleInfoMapData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTriangleInfoMapData interface { + Swigcptr() uintptr + SwigIsBtTriangleInfoMapData() + SetM_hashTablePtr(arg2 *int) + GetM_hashTablePtr() (_swig_ret *int) + SetM_nextPtr(arg2 *int) + GetM_nextPtr() (_swig_ret *int) + SetM_valueArrayPtr(arg2 BtTriangleInfoData) + GetM_valueArrayPtr() (_swig_ret BtTriangleInfoData) + SetM_keyArrayPtr(arg2 *int) + GetM_keyArrayPtr() (_swig_ret *int) + SetM_convexEpsilon(arg2 float32) + GetM_convexEpsilon() (_swig_ret float32) + SetM_planarEpsilon(arg2 float32) + GetM_planarEpsilon() (_swig_ret float32) + SetM_equalVertexThreshold(arg2 float32) + GetM_equalVertexThreshold() (_swig_ret float32) + SetM_edgeDistanceThreshold(arg2 float32) + GetM_edgeDistanceThreshold() (_swig_ret float32) + SetM_zeroAreaThreshold(arg2 float32) + GetM_zeroAreaThreshold() (_swig_ret float32) + SetM_nextSize(arg2 int) + GetM_nextSize() (_swig_ret int) + SetM_hashTableSize(arg2 int) + GetM_hashTableSize() (_swig_ret int) + SetM_numValues(arg2 int) + GetM_numValues() (_swig_ret int) + SetM_numKeys(arg2 int) + GetM_numKeys() (_swig_ret int) + SetM_padding(arg2 string) + GetM_padding() (_swig_ret string) +} + +type SwigcptrBtBvhTriangleMeshShape uintptr + +func (p SwigcptrBtBvhTriangleMeshShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBvhTriangleMeshShape) SwigIsBtBvhTriangleMeshShape() { +} + +func NewBtBvhTriangleMeshShape__SWIG_0(arg1 BtStridingMeshInterface, arg2 bool, arg3 bool) (_swig_ret BtBvhTriangleMeshShape) { + var swig_r BtBvhTriangleMeshShape + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtBvhTriangleMeshShape)(SwigcptrBtBvhTriangleMeshShape(C._wrap_new_btBvhTriangleMeshShape__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1), C._Bool(_swig_i_2)))) + return swig_r +} + +func NewBtBvhTriangleMeshShape__SWIG_1(arg1 BtStridingMeshInterface, arg2 bool) (_swig_ret BtBvhTriangleMeshShape) { + var swig_r BtBvhTriangleMeshShape + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtBvhTriangleMeshShape)(SwigcptrBtBvhTriangleMeshShape(C._wrap_new_btBvhTriangleMeshShape__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)))) + return swig_r +} + +func NewBtBvhTriangleMeshShape__SWIG_2(arg1 BtStridingMeshInterface, arg2 bool, arg3 BtVector3, arg4 BtVector3, arg5 bool) (_swig_ret BtBvhTriangleMeshShape) { + var swig_r BtBvhTriangleMeshShape + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (BtBvhTriangleMeshShape)(SwigcptrBtBvhTriangleMeshShape(C._wrap_new_btBvhTriangleMeshShape__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4)))) + return swig_r +} + +func NewBtBvhTriangleMeshShape__SWIG_3(arg1 BtStridingMeshInterface, arg2 bool, arg3 BtVector3, arg4 BtVector3) (_swig_ret BtBvhTriangleMeshShape) { + var swig_r BtBvhTriangleMeshShape + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtBvhTriangleMeshShape)(SwigcptrBtBvhTriangleMeshShape(C._wrap_new_btBvhTriangleMeshShape__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func NewBtBvhTriangleMeshShape(a ...interface{}) BtBvhTriangleMeshShape { + argc := len(a) + if argc == 2 { + return NewBtBvhTriangleMeshShape__SWIG_1(a[0].(BtStridingMeshInterface), a[1].(bool)) + } + if argc == 3 { + return NewBtBvhTriangleMeshShape__SWIG_0(a[0].(BtStridingMeshInterface), a[1].(bool), a[2].(bool)) + } + if argc == 4 { + return NewBtBvhTriangleMeshShape__SWIG_3(a[0].(BtStridingMeshInterface), a[1].(bool), a[2].(BtVector3), a[3].(BtVector3)) + } + if argc == 5 { + return NewBtBvhTriangleMeshShape__SWIG_2(a[0].(BtStridingMeshInterface), a[1].(bool), a[2].(BtVector3), a[3].(BtVector3), a[4].(bool)) + } + panic("No match for overloaded function call") +} + +func DeleteBtBvhTriangleMeshShape(arg1 BtBvhTriangleMeshShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBvhTriangleMeshShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) GetOwnsBvh() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBvhTriangleMeshShape_getOwnsBvh_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) PerformRaycast(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btBvhTriangleMeshShape_performRaycast_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) PerformConvexcast(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btBvhTriangleMeshShape_performConvexcast_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btBvhTriangleMeshShape_processAllTriangles_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) RefitTree(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBvhTriangleMeshShape_refitTree_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) PartialRefitTree(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBvhTriangleMeshShape_partialRefitTree_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btBvhTriangleMeshShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBvhTriangleMeshShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) GetOptimizedBvh() (_swig_ret BtOptimizedBvh) { + var swig_r BtOptimizedBvh + _swig_i_0 := arg1 + swig_r = (BtOptimizedBvh)(SwigcptrBtOptimizedBvh(C._wrap_btBvhTriangleMeshShape_getOptimizedBvh_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) SetOptimizedBvh__SWIG_0(arg2 BtOptimizedBvh, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBvhTriangleMeshShape_setOptimizedBvh__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) SetOptimizedBvh__SWIG_1(arg2 BtOptimizedBvh) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBvhTriangleMeshShape_setOptimizedBvh__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtBvhTriangleMeshShape) SetOptimizedBvh(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.SetOptimizedBvh__SWIG_1(a[0].(BtOptimizedBvh)) + return + } + if argc == 2 { + p.SetOptimizedBvh__SWIG_0(a[0].(BtOptimizedBvh), a[1].(BtVector3)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) BuildOptimizedBvh() { + _swig_i_0 := arg1 + C._wrap_btBvhTriangleMeshShape_buildOptimizedBvh_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) UsesQuantizedAabbCompression() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btBvhTriangleMeshShape_usesQuantizedAabbCompression_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) SetTriangleInfoMap(arg2 BtTriangleInfoMap) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBvhTriangleMeshShape_setTriangleInfoMap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) GetTriangleInfoMap__SWIG_0() (_swig_ret BtTriangleInfoMap) { + var swig_r BtTriangleInfoMap + _swig_i_0 := arg1 + swig_r = (BtTriangleInfoMap)(SwigcptrBtTriangleInfoMap(C._wrap_btBvhTriangleMeshShape_getTriangleInfoMap__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) GetTriangleInfoMap__SWIG_1() (_swig_ret BtTriangleInfoMap) { + var swig_r BtTriangleInfoMap + _swig_i_0 := arg1 + swig_r = (BtTriangleInfoMap)(SwigcptrBtTriangleInfoMap(C._wrap_btBvhTriangleMeshShape_getTriangleInfoMap__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtBvhTriangleMeshShape) GetTriangleInfoMap(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetTriangleInfoMap__SWIG_0() + } + if argc == 0 { + return p.GetTriangleInfoMap__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btBvhTriangleMeshShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btBvhTriangleMeshShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) SerializeSingleBvh(arg2 BtSerializer) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBvhTriangleMeshShape_serializeSingleBvh_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBvhTriangleMeshShape) SerializeSingleTriangleInfoMap(arg2 BtSerializer) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBvhTriangleMeshShape_serializeSingleTriangleInfoMap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBvhTriangleMeshShape_localGetSupportingVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBvhTriangleMeshShape_localGetSupportingVertexWithoutMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) RecalcLocalAabb() { + C._wrap_btBvhTriangleMeshShape_recalcLocalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btBvhTriangleMeshShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) CalculateLocalInertia(arg1 float32, arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBvhTriangleMeshShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBvhTriangleMeshShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetMeshInterface__SWIG_0() (_swig_ret BtStridingMeshInterface) { + var swig_r BtStridingMeshInterface + swig_r = (BtStridingMeshInterface)(SwigcptrBtStridingMeshInterface(C._wrap_btBvhTriangleMeshShape_getMeshInterface__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetMeshInterface__SWIG_1() (_swig_ret BtStridingMeshInterface) { + var swig_r BtStridingMeshInterface + swig_r = (BtStridingMeshInterface)(SwigcptrBtStridingMeshInterface(C._wrap_btBvhTriangleMeshShape_getMeshInterface__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtBvhTriangleMeshShape) GetMeshInterface(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetMeshInterface__SWIG_0() + } + if argc == 0 { + return p.GetMeshInterface__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetLocalAabbMin() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBvhTriangleMeshShape_getLocalAabbMin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetLocalAabbMax() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBvhTriangleMeshShape_getLocalAabbMax_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btBvhTriangleMeshShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) SetMargin(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btBvhTriangleMeshShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btBvhTriangleMeshShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btBvhTriangleMeshShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btBvhTriangleMeshShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btBvhTriangleMeshShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBvhTriangleMeshShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBvhTriangleMeshShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBvhTriangleMeshShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBvhTriangleMeshShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBvhTriangleMeshShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBvhTriangleMeshShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBvhTriangleMeshShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btBvhTriangleMeshShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btBvhTriangleMeshShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btBvhTriangleMeshShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btBvhTriangleMeshShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btBvhTriangleMeshShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btBvhTriangleMeshShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btBvhTriangleMeshShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btBvhTriangleMeshShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btBvhTriangleMeshShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtBvhTriangleMeshShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btBvhTriangleMeshShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtBvhTriangleMeshShape) SwigIsBtTriangleMeshShape() { +} + +func (p SwigcptrBtBvhTriangleMeshShape) SwigGetBtTriangleMeshShape() BtTriangleMeshShape { + return SwigcptrBtTriangleMeshShape(getSwigcptr(p)) +} + +func (p SwigcptrBtBvhTriangleMeshShape) SwigIsBtConcaveShape() { +} + +func (p SwigcptrBtBvhTriangleMeshShape) SwigGetBtConcaveShape() BtConcaveShape { + return SwigcptrBtConcaveShape(getSwigcptr(p)) +} + +func (p SwigcptrBtBvhTriangleMeshShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtBvhTriangleMeshShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtBvhTriangleMeshShape interface { + Swigcptr() uintptr + SwigIsBtBvhTriangleMeshShape() + GetOwnsBvh() (_swig_ret bool) + PerformRaycast(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) + PerformConvexcast(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3) + ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) + RefitTree(arg2 BtVector3, arg3 BtVector3) + PartialRefitTree(arg2 BtVector3, arg3 BtVector3) + GetName() (_swig_ret string) + SetLocalScaling(arg2 BtVector3) + GetOptimizedBvh() (_swig_ret BtOptimizedBvh) + SetOptimizedBvh(a ...interface{}) + BuildOptimizedBvh() + UsesQuantizedAabbCompression() (_swig_ret bool) + SetTriangleInfoMap(arg2 BtTriangleInfoMap) + GetTriangleInfoMap(a ...interface{}) interface{} + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + SerializeSingleBvh(arg2 BtSerializer) + SerializeSingleTriangleInfoMap(arg2 BtSerializer) + LocalGetSupportingVertex(arg1 BtVector3) (_swig_ret BtVector3) + LocalGetSupportingVertexWithoutMargin(arg1 BtVector3) (_swig_ret BtVector3) + RecalcLocalAabb() + GetAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3) + CalculateLocalInertia(arg1 float32, arg2 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetMeshInterface(a ...interface{}) interface{} + GetLocalAabbMin() (_swig_ret BtVector3) + GetLocalAabbMax() (_swig_ret BtVector3) + GetMargin() (_swig_ret float32) + SetMargin(arg1 float32) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtTriangleMeshShape() + SwigGetBtTriangleMeshShape() BtTriangleMeshShape + SwigIsBtConcaveShape() + SwigGetBtConcaveShape() BtConcaveShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtTriangleMeshShapeData uintptr + +func (p SwigcptrBtTriangleMeshShapeData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTriangleMeshShapeData) SwigIsBtTriangleMeshShapeData() { +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) SetM_collisionShapeData(arg2 BtCollisionShapeData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleMeshShapeData_m_collisionShapeData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) GetM_collisionShapeData() (_swig_ret BtCollisionShapeData) { + var swig_r BtCollisionShapeData + _swig_i_0 := arg1 + swig_r = (BtCollisionShapeData)(SwigcptrBtCollisionShapeData(C._wrap_btTriangleMeshShapeData_m_collisionShapeData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) SetM_meshInterface(arg2 BtStridingMeshInterfaceData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleMeshShapeData_m_meshInterface_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) GetM_meshInterface() (_swig_ret BtStridingMeshInterfaceData) { + var swig_r BtStridingMeshInterfaceData + _swig_i_0 := arg1 + swig_r = (BtStridingMeshInterfaceData)(SwigcptrBtStridingMeshInterfaceData(C._wrap_btTriangleMeshShapeData_m_meshInterface_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) SetM_quantizedFloatBvh(arg2 BtQuantizedBvhFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleMeshShapeData_m_quantizedFloatBvh_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) GetM_quantizedFloatBvh() (_swig_ret BtQuantizedBvhFloatData) { + var swig_r BtQuantizedBvhFloatData + _swig_i_0 := arg1 + swig_r = (BtQuantizedBvhFloatData)(SwigcptrBtQuantizedBvhFloatData(C._wrap_btTriangleMeshShapeData_m_quantizedFloatBvh_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) SetM_quantizedDoubleBvh(arg2 BtQuantizedBvhDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleMeshShapeData_m_quantizedDoubleBvh_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) GetM_quantizedDoubleBvh() (_swig_ret BtQuantizedBvhDoubleData) { + var swig_r BtQuantizedBvhDoubleData + _swig_i_0 := arg1 + swig_r = (BtQuantizedBvhDoubleData)(SwigcptrBtQuantizedBvhDoubleData(C._wrap_btTriangleMeshShapeData_m_quantizedDoubleBvh_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) SetM_triangleInfoMap(arg2 BtTriangleInfoMapData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleMeshShapeData_m_triangleInfoMap_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) GetM_triangleInfoMap() (_swig_ret BtTriangleInfoMapData) { + var swig_r BtTriangleInfoMapData + _swig_i_0 := arg1 + swig_r = (BtTriangleInfoMapData)(SwigcptrBtTriangleInfoMapData(C._wrap_btTriangleMeshShapeData_m_triangleInfoMap_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) SetM_collisionMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleMeshShapeData_m_collisionMargin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) GetM_collisionMargin() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleMeshShapeData_m_collisionMargin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) SetM_pad3(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleMeshShapeData_m_pad3_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_132)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtTriangleMeshShapeData) GetM_pad3() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btTriangleMeshShapeData_m_pad3_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtTriangleMeshShapeData() (_swig_ret BtTriangleMeshShapeData) { + var swig_r BtTriangleMeshShapeData + swig_r = (BtTriangleMeshShapeData)(SwigcptrBtTriangleMeshShapeData(C._wrap_new_btTriangleMeshShapeData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtTriangleMeshShapeData(arg1 BtTriangleMeshShapeData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTriangleMeshShapeData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTriangleMeshShapeData interface { + Swigcptr() uintptr + SwigIsBtTriangleMeshShapeData() + SetM_collisionShapeData(arg2 BtCollisionShapeData) + GetM_collisionShapeData() (_swig_ret BtCollisionShapeData) + SetM_meshInterface(arg2 BtStridingMeshInterfaceData) + GetM_meshInterface() (_swig_ret BtStridingMeshInterfaceData) + SetM_quantizedFloatBvh(arg2 BtQuantizedBvhFloatData) + GetM_quantizedFloatBvh() (_swig_ret BtQuantizedBvhFloatData) + SetM_quantizedDoubleBvh(arg2 BtQuantizedBvhDoubleData) + GetM_quantizedDoubleBvh() (_swig_ret BtQuantizedBvhDoubleData) + SetM_triangleInfoMap(arg2 BtTriangleInfoMapData) + GetM_triangleInfoMap() (_swig_ret BtTriangleInfoMapData) + SetM_collisionMargin(arg2 float32) + GetM_collisionMargin() (_swig_ret float32) + SetM_pad3(arg2 string) + GetM_pad3() (_swig_ret string) +} + +type SwigcptrBtHeightfieldTerrainShape uintptr + +func (p SwigcptrBtHeightfieldTerrainShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtHeightfieldTerrainShape) SwigIsBtHeightfieldTerrainShape() { +} + +func NewBtHeightfieldTerrainShape__SWIG_0(arg1 int, arg2 int, arg3 *float32, arg4 float32, arg5 float32, arg6 int, arg7 bool) (_swig_ret BtHeightfieldTerrainShape) { + var swig_r BtHeightfieldTerrainShape + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + swig_r = (BtHeightfieldTerrainShape)(SwigcptrBtHeightfieldTerrainShape(C._wrap_new_btHeightfieldTerrainShape__SWIG_0_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_voidp(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4), C.swig_intgo(_swig_i_5), C._Bool(_swig_i_6)))) + return swig_r +} + +func NewBtHeightfieldTerrainShape__SWIG_1(arg1 int, arg2 int, arg3 *float64, arg4 float32, arg5 float32, arg6 int, arg7 bool) (_swig_ret BtHeightfieldTerrainShape) { + var swig_r BtHeightfieldTerrainShape + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + swig_r = (BtHeightfieldTerrainShape)(SwigcptrBtHeightfieldTerrainShape(C._wrap_new_btHeightfieldTerrainShape__SWIG_1_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_voidp(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4), C.swig_intgo(_swig_i_5), C._Bool(_swig_i_6)))) + return swig_r +} + +func NewBtHeightfieldTerrainShape__SWIG_2(arg1 int, arg2 int, arg3 *int16, arg4 float32, arg5 float32, arg6 float32, arg7 int, arg8 bool) (_swig_ret BtHeightfieldTerrainShape) { + var swig_r BtHeightfieldTerrainShape + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + swig_r = (BtHeightfieldTerrainShape)(SwigcptrBtHeightfieldTerrainShape(C._wrap_new_btHeightfieldTerrainShape__SWIG_2_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_voidp(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.swig_intgo(_swig_i_6), C._Bool(_swig_i_7)))) + return swig_r +} + +func NewBtHeightfieldTerrainShape__SWIG_3(arg1 int, arg2 int, arg3 *byte, arg4 float32, arg5 float32, arg6 float32, arg7 int, arg8 bool) (_swig_ret BtHeightfieldTerrainShape) { + var swig_r BtHeightfieldTerrainShape + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + swig_r = (BtHeightfieldTerrainShape)(SwigcptrBtHeightfieldTerrainShape(C._wrap_new_btHeightfieldTerrainShape__SWIG_3_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_voidp(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.swig_intgo(_swig_i_6), C._Bool(_swig_i_7)))) + return swig_r +} + +func NewBtHeightfieldTerrainShape__SWIG_4(arg1 int, arg2 int, arg3 uintptr, arg4 float32, arg5 float32, arg6 float32, arg7 int, arg8 PHY_ScalarType, arg9 bool) (_swig_ret BtHeightfieldTerrainShape) { + var swig_r BtHeightfieldTerrainShape + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + swig_r = (BtHeightfieldTerrainShape)(SwigcptrBtHeightfieldTerrainShape(C._wrap_new_btHeightfieldTerrainShape__SWIG_4_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.swig_intgo(_swig_i_6), C.swig_intgo(_swig_i_7), C._Bool(_swig_i_8)))) + return swig_r +} + +func NewBtHeightfieldTerrainShape__SWIG_5(arg1 int, arg2 int, arg3 uintptr, arg4 float32, arg5 int, arg6 bool, arg7 bool) (_swig_ret BtHeightfieldTerrainShape) { + var swig_r BtHeightfieldTerrainShape + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + swig_r = (BtHeightfieldTerrainShape)(SwigcptrBtHeightfieldTerrainShape(C._wrap_new_btHeightfieldTerrainShape__SWIG_5_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.swig_intgo(_swig_i_4), C._Bool(_swig_i_5), C._Bool(_swig_i_6)))) + return swig_r +} + +func NewBtHeightfieldTerrainShape(a ...interface{}) BtHeightfieldTerrainShape { + argc := len(a) + if argc == 7 { + if _, ok := a[2].(*float32); !ok { + goto check_1 + } + if _, ok := a[4].(float32); !ok { + goto check_1 + } + if _, ok := a[5].(int); !ok { + goto check_1 + } + return NewBtHeightfieldTerrainShape__SWIG_0(a[0].(int), a[1].(int), a[2].(*float32), a[3].(float32), a[4].(float32), a[5].(int), a[6].(bool)) + } +check_1: + if argc == 7 { + if _, ok := a[2].(*float64); !ok { + goto check_2 + } + if _, ok := a[4].(float32); !ok { + goto check_2 + } + if _, ok := a[5].(int); !ok { + goto check_2 + } + return NewBtHeightfieldTerrainShape__SWIG_1(a[0].(int), a[1].(int), a[2].(*float64), a[3].(float32), a[4].(float32), a[5].(int), a[6].(bool)) + } +check_2: + if argc == 7 { + return NewBtHeightfieldTerrainShape__SWIG_5(a[0].(int), a[1].(int), a[2].(uintptr), a[3].(float32), a[4].(int), a[5].(bool), a[6].(bool)) + } + if argc == 8 { + if _, ok := a[2].(*int16); !ok { + goto check_4 + } + return NewBtHeightfieldTerrainShape__SWIG_2(a[0].(int), a[1].(int), a[2].(*int16), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(int), a[7].(bool)) + } +check_4: + if argc == 8 { + return NewBtHeightfieldTerrainShape__SWIG_3(a[0].(int), a[1].(int), a[2].(*byte), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(int), a[7].(bool)) + } + if argc == 9 { + return NewBtHeightfieldTerrainShape__SWIG_4(a[0].(int), a[1].(int), a[2].(uintptr), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(int), a[7].(PHY_ScalarType), a[8].(bool)) + } + panic("No match for overloaded function call") +} + +func DeleteBtHeightfieldTerrainShape(arg1 BtHeightfieldTerrainShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btHeightfieldTerrainShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) SetUseDiamondSubdivision__SWIG_0(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btHeightfieldTerrainShape_setUseDiamondSubdivision__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) SetUseDiamondSubdivision__SWIG_1() { + _swig_i_0 := arg1 + C._wrap_btHeightfieldTerrainShape_setUseDiamondSubdivision__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtHeightfieldTerrainShape) SetUseDiamondSubdivision(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.SetUseDiamondSubdivision__SWIG_1() + return + } + if argc == 1 { + p.SetUseDiamondSubdivision__SWIG_0(a[0].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) SetUseZigzagSubdivision__SWIG_0(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btHeightfieldTerrainShape_setUseZigzagSubdivision__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) SetUseZigzagSubdivision__SWIG_1() { + _swig_i_0 := arg1 + C._wrap_btHeightfieldTerrainShape_setUseZigzagSubdivision__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtHeightfieldTerrainShape) SetUseZigzagSubdivision(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.SetUseZigzagSubdivision__SWIG_1() + return + } + if argc == 1 { + p.SetUseZigzagSubdivision__SWIG_0(a[0].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) SetFlipTriangleWinding(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btHeightfieldTerrainShape_setFlipTriangleWinding_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btHeightfieldTerrainShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btHeightfieldTerrainShape_processAllTriangles_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) CalculateLocalInertia(arg2 float32, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btHeightfieldTerrainShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btHeightfieldTerrainShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btHeightfieldTerrainShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) GetVertex(arg2 int, arg3 int, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btHeightfieldTerrainShape_getVertex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) PerformRaycast(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btHeightfieldTerrainShape_performRaycast_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) BuildAccelerator__SWIG_0(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btHeightfieldTerrainShape_buildAccelerator__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) BuildAccelerator__SWIG_1() { + _swig_i_0 := arg1 + C._wrap_btHeightfieldTerrainShape_buildAccelerator__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtHeightfieldTerrainShape) BuildAccelerator(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.BuildAccelerator__SWIG_1() + return + } + if argc == 1 { + p.BuildAccelerator__SWIG_0(a[0].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) ClearAccelerator() { + _swig_i_0 := arg1 + C._wrap_btHeightfieldTerrainShape_clearAccelerator_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) GetUpAxis() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btHeightfieldTerrainShape_getUpAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btHeightfieldTerrainShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) SetUserValue3(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btHeightfieldTerrainShape_setUserValue3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) GetUserValue3() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btHeightfieldTerrainShape_getUserValue3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) GetTriangleInfoMap__SWIG_0() (_swig_ret BtTriangleInfoMap) { + var swig_r BtTriangleInfoMap + _swig_i_0 := arg1 + swig_r = (BtTriangleInfoMap)(SwigcptrBtTriangleInfoMap(C._wrap_btHeightfieldTerrainShape_getTriangleInfoMap__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) GetTriangleInfoMap__SWIG_1() (_swig_ret BtTriangleInfoMap) { + var swig_r BtTriangleInfoMap + _swig_i_0 := arg1 + swig_r = (BtTriangleInfoMap)(SwigcptrBtTriangleInfoMap(C._wrap_btHeightfieldTerrainShape_getTriangleInfoMap__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtHeightfieldTerrainShape) GetTriangleInfoMap(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetTriangleInfoMap__SWIG_0() + } + if argc == 0 { + return p.GetTriangleInfoMap__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) SetTriangleInfoMap(arg2 BtTriangleInfoMap) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btHeightfieldTerrainShape_setTriangleInfoMap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtHeightfieldTerrainShape) GetHeightfieldRawData() (_swig_ret *byte) { + var swig_r *byte + _swig_i_0 := arg1 + swig_r = (*byte)(C._wrap_btHeightfieldTerrainShape_getHeightfieldRawData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btHeightfieldTerrainShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) SetMargin(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btHeightfieldTerrainShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btHeightfieldTerrainShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btHeightfieldTerrainShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btHeightfieldTerrainShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btHeightfieldTerrainShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btHeightfieldTerrainShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btHeightfieldTerrainShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btHeightfieldTerrainShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btHeightfieldTerrainShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btHeightfieldTerrainShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btHeightfieldTerrainShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btHeightfieldTerrainShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btHeightfieldTerrainShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btHeightfieldTerrainShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btHeightfieldTerrainShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btHeightfieldTerrainShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btHeightfieldTerrainShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btHeightfieldTerrainShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btHeightfieldTerrainShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btHeightfieldTerrainShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btHeightfieldTerrainShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btHeightfieldTerrainShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btHeightfieldTerrainShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtHeightfieldTerrainShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btHeightfieldTerrainShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtHeightfieldTerrainShape) SwigIsBtConcaveShape() { +} + +func (p SwigcptrBtHeightfieldTerrainShape) SwigGetBtConcaveShape() BtConcaveShape { + return SwigcptrBtConcaveShape(getSwigcptr(p)) +} + +func (p SwigcptrBtHeightfieldTerrainShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtHeightfieldTerrainShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtHeightfieldTerrainShape interface { + Swigcptr() uintptr + SwigIsBtHeightfieldTerrainShape() + SetUseDiamondSubdivision(a ...interface{}) + SetUseZigzagSubdivision(a ...interface{}) + SetFlipTriangleWinding(arg2 bool) + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) + CalculateLocalInertia(arg2 float32, arg3 BtVector3) + SetLocalScaling(arg2 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetVertex(arg2 int, arg3 int, arg4 BtVector3) + PerformRaycast(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) + BuildAccelerator(a ...interface{}) + ClearAccelerator() + GetUpAxis() (_swig_ret int) + GetName() (_swig_ret string) + SetUserValue3(arg2 float32) + GetUserValue3() (_swig_ret float32) + GetTriangleInfoMap(a ...interface{}) interface{} + SetTriangleInfoMap(arg2 BtTriangleInfoMap) + GetHeightfieldRawData() (_swig_ret *byte) + GetMargin() (_swig_ret float32) + SetMargin(arg1 float32) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtConcaveShape() + SwigGetBtConcaveShape() BtConcaveShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtTriangleRaycastCallback uintptr + +func (p SwigcptrBtTriangleRaycastCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTriangleRaycastCallback) SwigIsBtTriangleRaycastCallback() { +} + +func (arg1 SwigcptrBtTriangleRaycastCallback) SetM_from(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleRaycastCallback_m_from_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleRaycastCallback) GetM_from() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTriangleRaycastCallback_m_from_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleRaycastCallback) SetM_to(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleRaycastCallback_m_to_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleRaycastCallback) GetM_to() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTriangleRaycastCallback_m_to_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +type BtTriangleRaycastCallbackEFlags int + +func _swig_getbtTriangleRaycastCallback_kF_None_btTriangleRaycastCallback() (_swig_ret BtTriangleRaycastCallbackEFlags) { + var swig_r BtTriangleRaycastCallbackEFlags + swig_r = (BtTriangleRaycastCallbackEFlags)(C._wrap_kF_None_btTriangleRaycastCallback_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtTriangleRaycastCallbackKF_None BtTriangleRaycastCallbackEFlags = _swig_getbtTriangleRaycastCallback_kF_None_btTriangleRaycastCallback() + +func _swig_getbtTriangleRaycastCallback_kF_FilterBackfaces_btTriangleRaycastCallback() (_swig_ret BtTriangleRaycastCallbackEFlags) { + var swig_r BtTriangleRaycastCallbackEFlags + swig_r = (BtTriangleRaycastCallbackEFlags)(C._wrap_kF_FilterBackfaces_btTriangleRaycastCallback_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtTriangleRaycastCallbackKF_FilterBackfaces BtTriangleRaycastCallbackEFlags = _swig_getbtTriangleRaycastCallback_kF_FilterBackfaces_btTriangleRaycastCallback() + +func _swig_getbtTriangleRaycastCallback_kF_KeepUnflippedNormal_btTriangleRaycastCallback() (_swig_ret BtTriangleRaycastCallbackEFlags) { + var swig_r BtTriangleRaycastCallbackEFlags + swig_r = (BtTriangleRaycastCallbackEFlags)(C._wrap_kF_KeepUnflippedNormal_btTriangleRaycastCallback_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtTriangleRaycastCallbackKF_KeepUnflippedNormal BtTriangleRaycastCallbackEFlags = _swig_getbtTriangleRaycastCallback_kF_KeepUnflippedNormal_btTriangleRaycastCallback() + +func _swig_getbtTriangleRaycastCallback_kF_UseSubSimplexConvexCastRaytest_btTriangleRaycastCallback() (_swig_ret BtTriangleRaycastCallbackEFlags) { + var swig_r BtTriangleRaycastCallbackEFlags + swig_r = (BtTriangleRaycastCallbackEFlags)(C._wrap_kF_UseSubSimplexConvexCastRaytest_btTriangleRaycastCallback_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtTriangleRaycastCallbackKF_UseSubSimplexConvexCastRaytest BtTriangleRaycastCallbackEFlags = _swig_getbtTriangleRaycastCallback_kF_UseSubSimplexConvexCastRaytest_btTriangleRaycastCallback() + +func _swig_getbtTriangleRaycastCallback_kF_UseGjkConvexCastRaytest_btTriangleRaycastCallback() (_swig_ret BtTriangleRaycastCallbackEFlags) { + var swig_r BtTriangleRaycastCallbackEFlags + swig_r = (BtTriangleRaycastCallbackEFlags)(C._wrap_kF_UseGjkConvexCastRaytest_btTriangleRaycastCallback_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtTriangleRaycastCallbackKF_UseGjkConvexCastRaytest BtTriangleRaycastCallbackEFlags = _swig_getbtTriangleRaycastCallback_kF_UseGjkConvexCastRaytest_btTriangleRaycastCallback() + +func _swig_getbtTriangleRaycastCallback_kF_DisableHeightfieldAccelerator_btTriangleRaycastCallback() (_swig_ret BtTriangleRaycastCallbackEFlags) { + var swig_r BtTriangleRaycastCallbackEFlags + swig_r = (BtTriangleRaycastCallbackEFlags)(C._wrap_kF_DisableHeightfieldAccelerator_btTriangleRaycastCallback_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtTriangleRaycastCallbackKF_DisableHeightfieldAccelerator BtTriangleRaycastCallbackEFlags = _swig_getbtTriangleRaycastCallback_kF_DisableHeightfieldAccelerator_btTriangleRaycastCallback() + +func _swig_getbtTriangleRaycastCallback_kF_Terminator_btTriangleRaycastCallback() (_swig_ret BtTriangleRaycastCallbackEFlags) { + var swig_r BtTriangleRaycastCallbackEFlags + swig_r = (BtTriangleRaycastCallbackEFlags)(C._wrap_kF_Terminator_btTriangleRaycastCallback_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtTriangleRaycastCallbackKF_Terminator BtTriangleRaycastCallbackEFlags = _swig_getbtTriangleRaycastCallback_kF_Terminator_btTriangleRaycastCallback() + +func (arg1 SwigcptrBtTriangleRaycastCallback) SetM_flags(arg2 uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleRaycastCallback_m_flags_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleRaycastCallback) GetM_flags() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_btTriangleRaycastCallback_m_flags_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleRaycastCallback) SetM_hitFraction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleRaycastCallback_m_hitFraction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleRaycastCallback) GetM_hitFraction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleRaycastCallback_m_hitFraction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleRaycastCallback) ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btTriangleRaycastCallback_processTriangle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtTriangleRaycastCallback) ReportHit(arg2 BtVector3, arg3 float32, arg4 int, arg5 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + swig_r = (float32)(C._wrap_btTriangleRaycastCallback_reportHit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3), C.swig_intgo(_swig_i_4))) + return swig_r +} + +func DeleteBtTriangleRaycastCallback(arg1 BtTriangleRaycastCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTriangleRaycastCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtTriangleRaycastCallback) SwigIsBtTriangleCallback() { +} + +func (p SwigcptrBtTriangleRaycastCallback) SwigGetBtTriangleCallback() BtTriangleCallback { + return SwigcptrBtTriangleCallback(getSwigcptr(p)) +} + +type BtTriangleRaycastCallback interface { + Swigcptr() uintptr + SwigIsBtTriangleRaycastCallback() + SetM_from(arg2 BtVector3) + GetM_from() (_swig_ret BtVector3) + SetM_to(arg2 BtVector3) + GetM_to() (_swig_ret BtVector3) + SetM_flags(arg2 uint) + GetM_flags() (_swig_ret uint) + SetM_hitFraction(arg2 float32) + GetM_hitFraction() (_swig_ret float32) + ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) + ReportHit(arg2 BtVector3, arg3 float32, arg4 int, arg5 int) (_swig_ret float32) + SwigIsBtTriangleCallback() + SwigGetBtTriangleCallback() BtTriangleCallback +} + +type SwigcptrBtTriangleConvexcastCallback uintptr + +func (p SwigcptrBtTriangleConvexcastCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTriangleConvexcastCallback) SwigIsBtTriangleConvexcastCallback() { +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) SetM_convexShape(arg2 BtConvexShape) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleConvexcastCallback_m_convexShape_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) GetM_convexShape() (_swig_ret BtConvexShape) { + var swig_r BtConvexShape + _swig_i_0 := arg1 + swig_r = (BtConvexShape)(SwigcptrBtConvexShape(C._wrap_btTriangleConvexcastCallback_m_convexShape_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) SetM_convexShapeFrom(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleConvexcastCallback_m_convexShapeFrom_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) GetM_convexShapeFrom() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btTriangleConvexcastCallback_m_convexShapeFrom_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) SetM_convexShapeTo(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleConvexcastCallback_m_convexShapeTo_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) GetM_convexShapeTo() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btTriangleConvexcastCallback_m_convexShapeTo_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) SetM_triangleToWorld(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTriangleConvexcastCallback_m_triangleToWorld_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) GetM_triangleToWorld() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btTriangleConvexcastCallback_m_triangleToWorld_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) SetM_hitFraction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleConvexcastCallback_m_hitFraction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) GetM_hitFraction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleConvexcastCallback_m_hitFraction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) SetM_triangleCollisionMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleConvexcastCallback_m_triangleCollisionMargin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) GetM_triangleCollisionMargin() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleConvexcastCallback_m_triangleCollisionMargin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) SetM_allowedPenetration(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTriangleConvexcastCallback_m_allowedPenetration_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) GetM_allowedPenetration() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTriangleConvexcastCallback_m_allowedPenetration_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btTriangleConvexcastCallback_processTriangle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtTriangleConvexcastCallback) ReportHit(arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 int, arg6 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + swig_r = (float32)(C._wrap_btTriangleConvexcastCallback_reportHit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.swig_intgo(_swig_i_4), C.swig_intgo(_swig_i_5))) + return swig_r +} + +func DeleteBtTriangleConvexcastCallback(arg1 BtTriangleConvexcastCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTriangleConvexcastCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtTriangleConvexcastCallback) SwigIsBtTriangleCallback() { +} + +func (p SwigcptrBtTriangleConvexcastCallback) SwigGetBtTriangleCallback() BtTriangleCallback { + return SwigcptrBtTriangleCallback(getSwigcptr(p)) +} + +type BtTriangleConvexcastCallback interface { + Swigcptr() uintptr + SwigIsBtTriangleConvexcastCallback() + SetM_convexShape(arg2 BtConvexShape) + GetM_convexShape() (_swig_ret BtConvexShape) + SetM_convexShapeFrom(arg2 BtTransform) + GetM_convexShapeFrom() (_swig_ret BtTransform) + SetM_convexShapeTo(arg2 BtTransform) + GetM_convexShapeTo() (_swig_ret BtTransform) + SetM_triangleToWorld(arg2 BtTransform) + GetM_triangleToWorld() (_swig_ret BtTransform) + SetM_hitFraction(arg2 float32) + GetM_hitFraction() (_swig_ret float32) + SetM_triangleCollisionMargin(arg2 float32) + GetM_triangleCollisionMargin() (_swig_ret float32) + SetM_allowedPenetration(arg2 float32) + GetM_allowedPenetration() (_swig_ret float32) + ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) + ReportHit(arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 int, arg6 int) (_swig_ret float32) + SwigIsBtTriangleCallback() + SwigGetBtTriangleCallback() BtTriangleCallback +} + +type SwigcptrBtIDebugDraw uintptr + +func (p SwigcptrBtIDebugDraw) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtIDebugDraw) SwigIsBtIDebugDraw() { +} + +type BtIDebugDrawDebugDrawModes int + +func _swig_getbtIDebugDraw_DBG_NoDebug_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_NoDebug_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_NoDebug BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_NoDebug_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_DrawWireframe_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_DrawWireframe_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_DrawWireframe BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_DrawWireframe_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_DrawAabb_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_DrawAabb_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_DrawAabb BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_DrawAabb_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_DrawFeaturesText_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_DrawFeaturesText_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_DrawFeaturesText BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_DrawFeaturesText_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_DrawContactPoints_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_DrawContactPoints_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_DrawContactPoints BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_DrawContactPoints_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_NoDeactivation_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_NoDeactivation_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_NoDeactivation BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_NoDeactivation_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_NoHelpText_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_NoHelpText_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_NoHelpText BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_NoHelpText_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_DrawText_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_DrawText_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_DrawText BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_DrawText_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_ProfileTimings_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_ProfileTimings_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_ProfileTimings BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_ProfileTimings_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_EnableSatComparison_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_EnableSatComparison_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_EnableSatComparison BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_EnableSatComparison_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_DisableBulletLCP_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_DisableBulletLCP_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_DisableBulletLCP BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_DisableBulletLCP_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_EnableCCD_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_EnableCCD_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_EnableCCD BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_EnableCCD_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_DrawConstraints_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_DrawConstraints_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_DrawConstraints BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_DrawConstraints_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_DrawConstraintLimits_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_DrawConstraintLimits_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_DrawConstraintLimits BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_DrawConstraintLimits_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_FastWireframe_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_FastWireframe_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_FastWireframe BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_FastWireframe_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_DrawNormals_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_DrawNormals_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_DrawNormals BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_DrawNormals_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_DrawFrames_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_DrawFrames_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_DrawFrames BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_DrawFrames_btIDebugDraw() + +func _swig_getbtIDebugDraw_DBG_MAX_DEBUG_DRAW_MODE_btIDebugDraw() (_swig_ret BtIDebugDrawDebugDrawModes) { + var swig_r BtIDebugDrawDebugDrawModes + swig_r = (BtIDebugDrawDebugDrawModes)(C._wrap_DBG_MAX_DEBUG_DRAW_MODE_btIDebugDraw_mbt_e879218550ba2e2b()) + return swig_r +} + +var BtIDebugDrawDBG_MAX_DEBUG_DRAW_MODE BtIDebugDrawDebugDrawModes = _swig_getbtIDebugDraw_DBG_MAX_DEBUG_DRAW_MODE_btIDebugDraw() + +func DeleteBtIDebugDraw(arg1 BtIDebugDraw) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btIDebugDraw_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtIDebugDraw) GetDefaultColors() (_swig_ret BtIDebugDraw_DefaultColors) { + var swig_r BtIDebugDraw_DefaultColors + _swig_i_0 := arg1 + swig_r = (BtIDebugDraw_DefaultColors)(SwigcptrBtIDebugDraw_DefaultColors(C._wrap_btIDebugDraw_getDefaultColors_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtIDebugDraw) SetDefaultColors(arg2 BtIDebugDraw_DefaultColors) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btIDebugDraw_setDefaultColors_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawLine__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btIDebugDraw_drawLine__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawLine__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btIDebugDraw_drawLine__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (p SwigcptrBtIDebugDraw) DrawLine(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.DrawLine__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3)) + return + } + if argc == 4 { + p.DrawLine__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(BtVector3)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtIDebugDraw) DrawSphere__SWIG_0(arg2 float32, arg3 BtTransform, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btIDebugDraw_drawSphere__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawSphere__SWIG_1(arg2 BtVector3, arg3 float32, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btIDebugDraw_drawSphere__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtIDebugDraw) DrawSphere(a ...interface{}) { + argc := len(a) + if argc == 3 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + if _, ok := a[1].(float32); !ok { + goto check_1 + } + p.DrawSphere__SWIG_1(a[0].(BtVector3), a[1].(float32), a[2].(BtVector3)) + return + } +check_1: + if argc == 3 { + p.DrawSphere__SWIG_0(a[0].(float32), a[1].(BtTransform), a[2].(BtVector3)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtIDebugDraw) DrawTriangle__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3, arg8 BtVector3, arg9 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := arg9 + C._wrap_btIDebugDraw_drawTriangle__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7), C.float(_swig_i_8)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawTriangle__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + C._wrap_btIDebugDraw_drawTriangle__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.float(_swig_i_5)) +} + +func (p SwigcptrBtIDebugDraw) DrawTriangle(a ...interface{}) { + argc := len(a) + if argc == 5 { + p.DrawTriangle__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(BtVector3), a[4].(float32)) + return + } + if argc == 8 { + p.DrawTriangle__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(BtVector3), a[4].(BtVector3), a[5].(BtVector3), a[6].(BtVector3), a[7].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtIDebugDraw) DrawContactPoint(arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 int, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btIDebugDraw_drawContactPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.swig_intgo(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtIDebugDraw) ReportErrorWarning(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btIDebugDraw_reportErrorWarning_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_136)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtIDebugDraw) Draw3dText(arg2 BtVector3, arg3 string) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btIDebugDraw_draw3dText_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), *(*C.swig_type_137)(unsafe.Pointer(&_swig_i_2))) + if Swig_escape_always_false { + Swig_escape_val = arg3 + } +} + +func (arg1 SwigcptrBtIDebugDraw) SetDebugMode(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btIDebugDraw_setDebugMode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtIDebugDraw) GetDebugMode() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btIDebugDraw_getDebugMode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtIDebugDraw) DrawAabb(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btIDebugDraw_drawAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawTransform(arg2 BtTransform, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btIDebugDraw_drawTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawArc__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 BtVector3, arg10 bool, arg11 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := arg10 + _swig_i_10 := arg11 + C._wrap_btIDebugDraw_drawArc__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.uintptr_t(_swig_i_8), C._Bool(_swig_i_9), C.float(_swig_i_10)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawArc__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 BtVector3, arg10 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := arg10 + C._wrap_btIDebugDraw_drawArc__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.uintptr_t(_swig_i_8), C._Bool(_swig_i_9)) +} + +func (p SwigcptrBtIDebugDraw) DrawArc(a ...interface{}) { + argc := len(a) + if argc == 9 { + p.DrawArc__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(BtVector3), a[8].(bool)) + return + } + if argc == 10 { + p.DrawArc__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(BtVector3), a[8].(bool), a[9].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtIDebugDraw) DrawSpherePatch__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 float32, arg10 BtVector3, arg11 float32, arg12 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + _swig_i_9 := getSwigcptr(arg10) + _swig_i_10 := arg11 + _swig_i_11 := arg12 + C._wrap_btIDebugDraw_drawSpherePatch__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.float(_swig_i_8), C.uintptr_t(_swig_i_9), C.float(_swig_i_10), C._Bool(_swig_i_11)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawSpherePatch__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 float32, arg10 BtVector3, arg11 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + _swig_i_9 := getSwigcptr(arg10) + _swig_i_10 := arg11 + C._wrap_btIDebugDraw_drawSpherePatch__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.float(_swig_i_8), C.uintptr_t(_swig_i_9), C.float(_swig_i_10)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawSpherePatch__SWIG_2(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 float32, arg10 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + _swig_i_9 := getSwigcptr(arg10) + C._wrap_btIDebugDraw_drawSpherePatch__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.float(_swig_i_8), C.uintptr_t(_swig_i_9)) +} + +func (p SwigcptrBtIDebugDraw) DrawSpherePatch(a ...interface{}) { + argc := len(a) + if argc == 9 { + p.DrawSpherePatch__SWIG_2(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(float32), a[8].(BtVector3)) + return + } + if argc == 10 { + p.DrawSpherePatch__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(float32), a[8].(BtVector3), a[9].(float32)) + return + } + if argc == 11 { + p.DrawSpherePatch__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(float32), a[8].(BtVector3), a[9].(float32), a[10].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtIDebugDraw) DrawBox__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btIDebugDraw_drawBox__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawBox__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtTransform, arg5 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btIDebugDraw_drawBox__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (p SwigcptrBtIDebugDraw) DrawBox(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.DrawBox__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3)) + return + } + if argc == 4 { + p.DrawBox__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtTransform), a[3].(BtVector3)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtIDebugDraw) DrawCapsule(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btIDebugDraw_drawCapsule_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawCylinder(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btIDebugDraw_drawCylinder_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawCone(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btIDebugDraw_drawCone_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtIDebugDraw) DrawPlane(arg2 BtVector3, arg3 float32, arg4 BtTransform, arg5 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btIDebugDraw_drawPlane_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtIDebugDraw) ClearLines() { + _swig_i_0 := arg1 + C._wrap_btIDebugDraw_clearLines_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtIDebugDraw) FlushLines() { + _swig_i_0 := arg1 + C._wrap_btIDebugDraw_flushLines_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtIDebugDraw interface { + Swigcptr() uintptr + SwigIsBtIDebugDraw() + GetDefaultColors() (_swig_ret BtIDebugDraw_DefaultColors) + SetDefaultColors(arg2 BtIDebugDraw_DefaultColors) + DrawLine(a ...interface{}) + DrawSphere(a ...interface{}) + DrawTriangle(a ...interface{}) + DrawContactPoint(arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 int, arg6 BtVector3) + ReportErrorWarning(arg2 string) + Draw3dText(arg2 BtVector3, arg3 string) + SetDebugMode(arg2 int) + GetDebugMode() (_swig_ret int) + DrawAabb(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) + DrawTransform(arg2 BtTransform, arg3 float32) + DrawArc(a ...interface{}) + DrawSpherePatch(a ...interface{}) + DrawBox(a ...interface{}) + DrawCapsule(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) + DrawCylinder(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) + DrawCone(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) + DrawPlane(arg2 BtVector3, arg3 float32, arg4 BtTransform, arg5 BtVector3) + ClearLines() + FlushLines() +} + +const MAX_CONVEX_CAST_ITERATIONS int = 32 + +type SwigcptrBtConvexCast uintptr + +func (p SwigcptrBtConvexCast) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexCast) SwigIsBtConvexCast() { +} + +func DeleteBtConvexCast(arg1 BtConvexCast) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexCast_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexCast) CalcTimeOfImpact(arg2 BtTransform, arg3 BtTransform, arg4 BtTransform, arg5 BtTransform, arg6 BtConvexCast_CastResult) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_btConvexCast_calcTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +type BtConvexCast interface { + Swigcptr() uintptr + SwigIsBtConvexCast() + CalcTimeOfImpact(arg2 BtTransform, arg3 BtTransform, arg4 BtTransform, arg5 BtTransform, arg6 BtConvexCast_CastResult) (_swig_ret bool) +} + +type SwigcptrBtSubsimplexConvexCast uintptr + +func (p SwigcptrBtSubsimplexConvexCast) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSubsimplexConvexCast) SwigIsBtSubsimplexConvexCast() { +} + +func NewBtSubsimplexConvexCast(arg1 BtConvexShape, arg2 BtConvexShape, arg3 BtVoronoiSimplexSolver) (_swig_ret BtSubsimplexConvexCast) { + var swig_r BtSubsimplexConvexCast + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtSubsimplexConvexCast)(SwigcptrBtSubsimplexConvexCast(C._wrap_new_btSubsimplexConvexCast_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtSubsimplexConvexCast) CalcTimeOfImpact(arg2 BtTransform, arg3 BtTransform, arg4 BtTransform, arg5 BtTransform, arg6 BtConvexCast_CastResult) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_btSubsimplexConvexCast_calcTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func DeleteBtSubsimplexConvexCast(arg1 BtSubsimplexConvexCast) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSubsimplexConvexCast_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtSubsimplexConvexCast) SwigIsBtConvexCast() { +} + +func (p SwigcptrBtSubsimplexConvexCast) SwigGetBtConvexCast() BtConvexCast { + return SwigcptrBtConvexCast(getSwigcptr(p)) +} + +type BtSubsimplexConvexCast interface { + Swigcptr() uintptr + SwigIsBtSubsimplexConvexCast() + CalcTimeOfImpact(arg2 BtTransform, arg3 BtTransform, arg4 BtTransform, arg5 BtTransform, arg6 BtConvexCast_CastResult) (_swig_ret bool) + SwigIsBtConvexCast() + SwigGetBtConvexCast() BtConvexCast +} + +type SwigcptrBtGjkConvexCast uintptr + +func (p SwigcptrBtGjkConvexCast) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGjkConvexCast) SwigIsBtGjkConvexCast() { +} + +func NewBtGjkConvexCast(arg1 BtConvexShape, arg2 BtConvexShape, arg3 BtVoronoiSimplexSolver) (_swig_ret BtGjkConvexCast) { + var swig_r BtGjkConvexCast + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtGjkConvexCast)(SwigcptrBtGjkConvexCast(C._wrap_new_btGjkConvexCast_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtGjkConvexCast) CalcTimeOfImpact(arg2 BtTransform, arg3 BtTransform, arg4 BtTransform, arg5 BtTransform, arg6 BtConvexCast_CastResult) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_btGjkConvexCast_calcTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func DeleteBtGjkConvexCast(arg1 BtGjkConvexCast) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGjkConvexCast_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtGjkConvexCast) SwigIsBtConvexCast() { +} + +func (p SwigcptrBtGjkConvexCast) SwigGetBtConvexCast() BtConvexCast { + return SwigcptrBtConvexCast(getSwigcptr(p)) +} + +type BtGjkConvexCast interface { + Swigcptr() uintptr + SwigIsBtGjkConvexCast() + CalcTimeOfImpact(arg2 BtTransform, arg3 BtTransform, arg4 BtTransform, arg5 BtTransform, arg6 BtConvexCast_CastResult) (_swig_ret bool) + SwigIsBtConvexCast() + SwigGetBtConvexCast() BtConvexCast +} + +type SwigcptrBtContinuousConvexCollision uintptr + +func (p SwigcptrBtContinuousConvexCollision) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtContinuousConvexCollision) SwigIsBtContinuousConvexCollision() { +} + +func NewBtContinuousConvexCollision__SWIG_0(arg1 BtConvexShape, arg2 BtConvexShape, arg3 BtVoronoiSimplexSolver, arg4 BtConvexPenetrationDepthSolver) (_swig_ret BtContinuousConvexCollision) { + var swig_r BtContinuousConvexCollision + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtContinuousConvexCollision)(SwigcptrBtContinuousConvexCollision(C._wrap_new_btContinuousConvexCollision__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func NewBtContinuousConvexCollision__SWIG_1(arg1 BtConvexShape, arg2 BtStaticPlaneShape) (_swig_ret BtContinuousConvexCollision) { + var swig_r BtContinuousConvexCollision + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtContinuousConvexCollision)(SwigcptrBtContinuousConvexCollision(C._wrap_new_btContinuousConvexCollision__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func NewBtContinuousConvexCollision(a ...interface{}) BtContinuousConvexCollision { + argc := len(a) + if argc == 2 { + return NewBtContinuousConvexCollision__SWIG_1(a[0].(BtConvexShape), a[1].(BtStaticPlaneShape)) + } + if argc == 4 { + return NewBtContinuousConvexCollision__SWIG_0(a[0].(BtConvexShape), a[1].(BtConvexShape), a[2].(BtVoronoiSimplexSolver), a[3].(BtConvexPenetrationDepthSolver)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtContinuousConvexCollision) CalcTimeOfImpact(arg2 BtTransform, arg3 BtTransform, arg4 BtTransform, arg5 BtTransform, arg6 BtConvexCast_CastResult) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_btContinuousConvexCollision_calcTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func DeleteBtContinuousConvexCollision(arg1 BtContinuousConvexCollision) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btContinuousConvexCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtContinuousConvexCollision) SwigIsBtConvexCast() { +} + +func (p SwigcptrBtContinuousConvexCollision) SwigGetBtConvexCast() BtConvexCast { + return SwigcptrBtConvexCast(getSwigcptr(p)) +} + +type BtContinuousConvexCollision interface { + Swigcptr() uintptr + SwigIsBtContinuousConvexCollision() + CalcTimeOfImpact(arg2 BtTransform, arg3 BtTransform, arg4 BtTransform, arg5 BtTransform, arg6 BtConvexCast_CastResult) (_swig_ret bool) + SwigIsBtConvexCast() + SwigGetBtConvexCast() BtConvexCast +} + +type SwigcptrBtSingleRayCallback uintptr + +func (p SwigcptrBtSingleRayCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSingleRayCallback) SwigIsBtSingleRayCallback() { +} + +func (arg1 SwigcptrBtSingleRayCallback) SetM_rayFromWorld(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleRayCallback_m_rayFromWorld_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleRayCallback) GetM_rayFromWorld() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSingleRayCallback_m_rayFromWorld_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleRayCallback) SetM_rayToWorld(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleRayCallback_m_rayToWorld_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleRayCallback) GetM_rayToWorld() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSingleRayCallback_m_rayToWorld_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleRayCallback) SetM_rayFromTrans(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleRayCallback_m_rayFromTrans_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleRayCallback) GetM_rayFromTrans() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btSingleRayCallback_m_rayFromTrans_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleRayCallback) SetM_rayToTrans(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleRayCallback_m_rayToTrans_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleRayCallback) GetM_rayToTrans() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btSingleRayCallback_m_rayToTrans_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleRayCallback) SetM_hitNormal(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleRayCallback_m_hitNormal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleRayCallback) GetM_hitNormal() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSingleRayCallback_m_hitNormal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleRayCallback) SetM_world(arg2 BtCollisionWorld) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleRayCallback_m_world_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleRayCallback) GetM_world() (_swig_ret BtCollisionWorld) { + var swig_r BtCollisionWorld + _swig_i_0 := arg1 + swig_r = (BtCollisionWorld)(SwigcptrBtCollisionWorld(C._wrap_btSingleRayCallback_m_world_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleRayCallback) SetM_resultCallback(arg2 BtCollisionWorld_RayResultCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleRayCallback_m_resultCallback_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleRayCallback) GetM_resultCallback() (_swig_ret BtCollisionWorld_RayResultCallback) { + var swig_r BtCollisionWorld_RayResultCallback + _swig_i_0 := arg1 + swig_r = (BtCollisionWorld_RayResultCallback)(SwigcptrBtCollisionWorld_RayResultCallback(C._wrap_btSingleRayCallback_m_resultCallback_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtSingleRayCallback(arg1 BtVector3, arg2 BtVector3, arg3 BtCollisionWorld, arg4 BtCollisionWorld_RayResultCallback) (_swig_ret BtSingleRayCallback) { + var swig_r BtSingleRayCallback + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtSingleRayCallback)(SwigcptrBtSingleRayCallback(C._wrap_new_btSingleRayCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleRayCallback) Process(arg2 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btSingleRayCallback_process_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func DeleteBtSingleRayCallback(arg1 BtSingleRayCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSingleRayCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSingleRayCallback) SetM_rayDirectionInverse(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_SetbtSingleRayCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSingleRayCallback) GetM_rayDirectionInverse() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GetbtSingleRayCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtSingleRayCallback) SetM_signs(arg1 *uint) { + _swig_i_0 := arg1 + C._wrap_SetbtSingleRayCallback_M_signs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_voidp(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSingleRayCallback) GetM_signs() (_swig_ret *uint) { + var swig_r *uint + swig_r = (*uint)(C._wrap_GetbtSingleRayCallback_M_signs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSingleRayCallback) SetM_lambda_max(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtSingleRayCallback_M_lambda_max_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSingleRayCallback) GetM_lambda_max() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtSingleRayCallback_M_lambda_max_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtSingleRayCallback) SwigIsBtBroadphaseRayCallback() { +} + +func (p SwigcptrBtSingleRayCallback) SwigGetBtBroadphaseRayCallback() BtBroadphaseRayCallback { + return SwigcptrBtBroadphaseRayCallback(getSwigcptr(p)) +} + +func (p SwigcptrBtSingleRayCallback) SwigIsBtBroadphaseAabbCallback() { +} + +func (p SwigcptrBtSingleRayCallback) SwigGetBtBroadphaseAabbCallback() BtBroadphaseAabbCallback { + return SwigcptrBtBroadphaseAabbCallback(getSwigcptr(p)) +} + +type BtSingleRayCallback interface { + Swigcptr() uintptr + SwigIsBtSingleRayCallback() + SetM_rayFromWorld(arg2 BtVector3) + GetM_rayFromWorld() (_swig_ret BtVector3) + SetM_rayToWorld(arg2 BtVector3) + GetM_rayToWorld() (_swig_ret BtVector3) + SetM_rayFromTrans(arg2 BtTransform) + GetM_rayFromTrans() (_swig_ret BtTransform) + SetM_rayToTrans(arg2 BtTransform) + GetM_rayToTrans() (_swig_ret BtTransform) + SetM_hitNormal(arg2 BtVector3) + GetM_hitNormal() (_swig_ret BtVector3) + SetM_world(arg2 BtCollisionWorld) + GetM_world() (_swig_ret BtCollisionWorld) + SetM_resultCallback(arg2 BtCollisionWorld_RayResultCallback) + GetM_resultCallback() (_swig_ret BtCollisionWorld_RayResultCallback) + Process(arg2 BtBroadphaseProxy) (_swig_ret bool) + SetM_rayDirectionInverse(arg1 BtVector3) + GetM_rayDirectionInverse() (_swig_ret BtVector3) + SetM_signs(arg1 *uint) + GetM_signs() (_swig_ret *uint) + SetM_lambda_max(arg1 float32) + GetM_lambda_max() (_swig_ret float32) + SwigIsBtBroadphaseRayCallback() + SwigGetBtBroadphaseRayCallback() BtBroadphaseRayCallback + SwigIsBtBroadphaseAabbCallback() + SwigGetBtBroadphaseAabbCallback() BtBroadphaseAabbCallback +} + +type SwigcptrBtSingleSweepCallback uintptr + +func (p SwigcptrBtSingleSweepCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSingleSweepCallback) SwigIsBtSingleSweepCallback() { +} + +func (arg1 SwigcptrBtSingleSweepCallback) SetM_convexFromTrans(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleSweepCallback_m_convexFromTrans_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleSweepCallback) GetM_convexFromTrans() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btSingleSweepCallback_m_convexFromTrans_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleSweepCallback) SetM_convexToTrans(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleSweepCallback_m_convexToTrans_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleSweepCallback) GetM_convexToTrans() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btSingleSweepCallback_m_convexToTrans_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleSweepCallback) SetM_hitNormal(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleSweepCallback_m_hitNormal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleSweepCallback) GetM_hitNormal() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSingleSweepCallback_m_hitNormal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleSweepCallback) SetM_world(arg2 BtCollisionWorld) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleSweepCallback_m_world_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleSweepCallback) GetM_world() (_swig_ret BtCollisionWorld) { + var swig_r BtCollisionWorld + _swig_i_0 := arg1 + swig_r = (BtCollisionWorld)(SwigcptrBtCollisionWorld(C._wrap_btSingleSweepCallback_m_world_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleSweepCallback) SetM_resultCallback(arg2 BtCollisionWorld_ConvexResultCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleSweepCallback_m_resultCallback_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleSweepCallback) GetM_resultCallback() (_swig_ret BtCollisionWorld_ConvexResultCallback) { + var swig_r BtCollisionWorld_ConvexResultCallback + _swig_i_0 := arg1 + swig_r = (BtCollisionWorld_ConvexResultCallback)(SwigcptrBtCollisionWorld_ConvexResultCallback(C._wrap_btSingleSweepCallback_m_resultCallback_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleSweepCallback) SetM_allowedCcdPenetration(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSingleSweepCallback_m_allowedCcdPenetration_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleSweepCallback) GetM_allowedCcdPenetration() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSingleSweepCallback_m_allowedCcdPenetration_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSingleSweepCallback) SetM_castShape(arg2 BtConvexShape) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleSweepCallback_m_castShape_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleSweepCallback) GetM_castShape() (_swig_ret BtConvexShape) { + var swig_r BtConvexShape + _swig_i_0 := arg1 + swig_r = (BtConvexShape)(SwigcptrBtConvexShape(C._wrap_btSingleSweepCallback_m_castShape_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtSingleSweepCallback(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionWorld, arg5 BtCollisionWorld_ConvexResultCallback, arg6 float32) (_swig_ret BtSingleSweepCallback) { + var swig_r BtSingleSweepCallback + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + swig_r = (BtSingleSweepCallback)(SwigcptrBtSingleSweepCallback(C._wrap_new_btSingleSweepCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.float(_swig_i_5)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleSweepCallback) Process(arg2 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btSingleSweepCallback_process_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func DeleteBtSingleSweepCallback(arg1 BtSingleSweepCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSingleSweepCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSingleSweepCallback) SetM_rayDirectionInverse(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_SetbtSingleSweepCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSingleSweepCallback) GetM_rayDirectionInverse() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GetbtSingleSweepCallback_M_rayDirectionInverse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtSingleSweepCallback) SetM_signs(arg1 *uint) { + _swig_i_0 := arg1 + C._wrap_SetbtSingleSweepCallback_M_signs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_voidp(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSingleSweepCallback) GetM_signs() (_swig_ret *uint) { + var swig_r *uint + swig_r = (*uint)(C._wrap_GetbtSingleSweepCallback_M_signs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSingleSweepCallback) SetM_lambda_max(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtSingleSweepCallback_M_lambda_max_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSingleSweepCallback) GetM_lambda_max() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtSingleSweepCallback_M_lambda_max_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtSingleSweepCallback) SwigIsBtBroadphaseRayCallback() { +} + +func (p SwigcptrBtSingleSweepCallback) SwigGetBtBroadphaseRayCallback() BtBroadphaseRayCallback { + return SwigcptrBtBroadphaseRayCallback(getSwigcptr(p)) +} + +func (p SwigcptrBtSingleSweepCallback) SwigIsBtBroadphaseAabbCallback() { +} + +func (p SwigcptrBtSingleSweepCallback) SwigGetBtBroadphaseAabbCallback() BtBroadphaseAabbCallback { + return SwigcptrBtBroadphaseAabbCallback(getSwigcptr(p)) +} + +type BtSingleSweepCallback interface { + Swigcptr() uintptr + SwigIsBtSingleSweepCallback() + SetM_convexFromTrans(arg2 BtTransform) + GetM_convexFromTrans() (_swig_ret BtTransform) + SetM_convexToTrans(arg2 BtTransform) + GetM_convexToTrans() (_swig_ret BtTransform) + SetM_hitNormal(arg2 BtVector3) + GetM_hitNormal() (_swig_ret BtVector3) + SetM_world(arg2 BtCollisionWorld) + GetM_world() (_swig_ret BtCollisionWorld) + SetM_resultCallback(arg2 BtCollisionWorld_ConvexResultCallback) + GetM_resultCallback() (_swig_ret BtCollisionWorld_ConvexResultCallback) + SetM_allowedCcdPenetration(arg2 float32) + GetM_allowedCcdPenetration() (_swig_ret float32) + SetM_castShape(arg2 BtConvexShape) + GetM_castShape() (_swig_ret BtConvexShape) + Process(arg2 BtBroadphaseProxy) (_swig_ret bool) + SetM_rayDirectionInverse(arg1 BtVector3) + GetM_rayDirectionInverse() (_swig_ret BtVector3) + SetM_signs(arg1 *uint) + GetM_signs() (_swig_ret *uint) + SetM_lambda_max(arg1 float32) + GetM_lambda_max() (_swig_ret float32) + SwigIsBtBroadphaseRayCallback() + SwigGetBtBroadphaseRayCallback() BtBroadphaseRayCallback + SwigIsBtBroadphaseAabbCallback() + SwigGetBtBroadphaseAabbCallback() BtBroadphaseAabbCallback +} + +type SwigcptrBtBridgedManifoldResult uintptr + +func (p SwigcptrBtBridgedManifoldResult) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBridgedManifoldResult) SwigIsBtBridgedManifoldResult() { +} + +func (arg1 SwigcptrBtBridgedManifoldResult) SetM_resultCallback(arg2 BtCollisionWorld_ContactResultCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBridgedManifoldResult_m_resultCallback_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBridgedManifoldResult) GetM_resultCallback() (_swig_ret BtCollisionWorld_ContactResultCallback) { + var swig_r BtCollisionWorld_ContactResultCallback + _swig_i_0 := arg1 + swig_r = (BtCollisionWorld_ContactResultCallback)(SwigcptrBtCollisionWorld_ContactResultCallback(C._wrap_btBridgedManifoldResult_m_resultCallback_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtBridgedManifoldResult(arg1 BtCollisionObjectWrapper, arg2 BtCollisionObjectWrapper, arg3 BtCollisionWorld_ContactResultCallback) (_swig_ret BtBridgedManifoldResult) { + var swig_r BtBridgedManifoldResult + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtBridgedManifoldResult)(SwigcptrBtBridgedManifoldResult(C._wrap_new_btBridgedManifoldResult_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtBridgedManifoldResult) AddContactPoint(arg2 BtVector3, arg3 BtVector3, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btBridgedManifoldResult_addContactPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +func DeleteBtBridgedManifoldResult(arg1 BtBridgedManifoldResult) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBridgedManifoldResult_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) SetPersistentManifold(arg1 BtPersistentManifold) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btBridgedManifoldResult_setPersistentManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) GetPersistentManifold__SWIG_0() (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btBridgedManifoldResult_getPersistentManifold__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) GetPersistentManifold__SWIG_1() (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btBridgedManifoldResult_getPersistentManifold__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtBridgedManifoldResult) GetPersistentManifold(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetPersistentManifold__SWIG_0() + } + if argc == 0 { + return p.GetPersistentManifold__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) SetShapeIdentifiersA(arg1 int, arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBridgedManifoldResult_setShapeIdentifiersA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) SetShapeIdentifiersB(arg1 int, arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btBridgedManifoldResult_setShapeIdentifiersB_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) RefreshContactPoints() { + C._wrap_btBridgedManifoldResult_refreshContactPoints_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) GetBody0Wrap() (_swig_ret BtCollisionObjectWrapper) { + var swig_r BtCollisionObjectWrapper + swig_r = (BtCollisionObjectWrapper)(SwigcptrBtCollisionObjectWrapper(C._wrap_btBridgedManifoldResult_getBody0Wrap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) GetBody1Wrap() (_swig_ret BtCollisionObjectWrapper) { + var swig_r BtCollisionObjectWrapper + swig_r = (BtCollisionObjectWrapper)(SwigcptrBtCollisionObjectWrapper(C._wrap_btBridgedManifoldResult_getBody1Wrap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) SetBody0Wrap(arg1 BtCollisionObjectWrapper) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btBridgedManifoldResult_setBody0Wrap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) SetBody1Wrap(arg1 BtCollisionObjectWrapper) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btBridgedManifoldResult_setBody1Wrap_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) GetBody0Internal() (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_btBridgedManifoldResult_getBody0Internal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) GetBody1Internal() (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_btBridgedManifoldResult_getBody1Internal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) SetM_closestPointDistanceThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtBridgedManifoldResult_M_closestPointDistanceThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtBridgedManifoldResult) GetM_closestPointDistanceThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtBridgedManifoldResult_M_closestPointDistanceThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func BtBridgedManifoldResultCalculateCombinedRestitution(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btBridgedManifoldResult_calculateCombinedRestitution_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtBridgedManifoldResultCalculateCombinedFriction(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btBridgedManifoldResult_calculateCombinedFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtBridgedManifoldResultCalculateCombinedRollingFriction(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btBridgedManifoldResult_calculateCombinedRollingFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtBridgedManifoldResultCalculateCombinedSpinningFriction(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btBridgedManifoldResult_calculateCombinedSpinningFriction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtBridgedManifoldResultCalculateCombinedContactDamping(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btBridgedManifoldResult_calculateCombinedContactDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func BtBridgedManifoldResultCalculateCombinedContactStiffness(arg1 BtCollisionObject, arg2 BtCollisionObject) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (float32)(C._wrap_btBridgedManifoldResult_calculateCombinedContactStiffness_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (p SwigcptrBtBridgedManifoldResult) SwigIsBtManifoldResult() { +} + +func (p SwigcptrBtBridgedManifoldResult) SwigGetBtManifoldResult() BtManifoldResult { + return SwigcptrBtManifoldResult(getSwigcptr(p)) +} + +type BtBridgedManifoldResult interface { + Swigcptr() uintptr + SwigIsBtBridgedManifoldResult() + SetM_resultCallback(arg2 BtCollisionWorld_ContactResultCallback) + GetM_resultCallback() (_swig_ret BtCollisionWorld_ContactResultCallback) + AddContactPoint(arg2 BtVector3, arg3 BtVector3, arg4 float32) + SetPersistentManifold(arg1 BtPersistentManifold) + GetPersistentManifold(a ...interface{}) interface{} + SetShapeIdentifiersA(arg1 int, arg2 int) + SetShapeIdentifiersB(arg1 int, arg2 int) + RefreshContactPoints() + GetBody0Wrap() (_swig_ret BtCollisionObjectWrapper) + GetBody1Wrap() (_swig_ret BtCollisionObjectWrapper) + SetBody0Wrap(arg1 BtCollisionObjectWrapper) + SetBody1Wrap(arg1 BtCollisionObjectWrapper) + GetBody0Internal() (_swig_ret BtCollisionObject) + GetBody1Internal() (_swig_ret BtCollisionObject) + SetM_closestPointDistanceThreshold(arg1 float32) + GetM_closestPointDistanceThreshold() (_swig_ret float32) + SwigIsBtManifoldResult() + SwigGetBtManifoldResult() BtManifoldResult +} + +type SwigcptrBtSingleContactCallback uintptr + +func (p SwigcptrBtSingleContactCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSingleContactCallback) SwigIsBtSingleContactCallback() { +} + +func (arg1 SwigcptrBtSingleContactCallback) SetM_collisionObject(arg2 BtCollisionObject) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleContactCallback_m_collisionObject_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleContactCallback) GetM_collisionObject() (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + _swig_i_0 := arg1 + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_btSingleContactCallback_m_collisionObject_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleContactCallback) SetM_world(arg2 BtCollisionWorld) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleContactCallback_m_world_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleContactCallback) GetM_world() (_swig_ret BtCollisionWorld) { + var swig_r BtCollisionWorld + _swig_i_0 := arg1 + swig_r = (BtCollisionWorld)(SwigcptrBtCollisionWorld(C._wrap_btSingleContactCallback_m_world_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleContactCallback) SetM_resultCallback(arg2 BtCollisionWorld_ContactResultCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSingleContactCallback_m_resultCallback_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSingleContactCallback) GetM_resultCallback() (_swig_ret BtCollisionWorld_ContactResultCallback) { + var swig_r BtCollisionWorld_ContactResultCallback + _swig_i_0 := arg1 + swig_r = (BtCollisionWorld_ContactResultCallback)(SwigcptrBtCollisionWorld_ContactResultCallback(C._wrap_btSingleContactCallback_m_resultCallback_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtSingleContactCallback(arg1 BtCollisionObject, arg2 BtCollisionWorld, arg3 BtCollisionWorld_ContactResultCallback) (_swig_ret BtSingleContactCallback) { + var swig_r BtSingleContactCallback + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtSingleContactCallback)(SwigcptrBtSingleContactCallback(C._wrap_new_btSingleContactCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtSingleContactCallback) Process(arg2 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btSingleContactCallback_process_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func DeleteBtSingleContactCallback(arg1 BtSingleContactCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSingleContactCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtSingleContactCallback) SwigIsBtBroadphaseAabbCallback() { +} + +func (p SwigcptrBtSingleContactCallback) SwigGetBtBroadphaseAabbCallback() BtBroadphaseAabbCallback { + return SwigcptrBtBroadphaseAabbCallback(getSwigcptr(p)) +} + +type BtSingleContactCallback interface { + Swigcptr() uintptr + SwigIsBtSingleContactCallback() + SetM_collisionObject(arg2 BtCollisionObject) + GetM_collisionObject() (_swig_ret BtCollisionObject) + SetM_world(arg2 BtCollisionWorld) + GetM_world() (_swig_ret BtCollisionWorld) + SetM_resultCallback(arg2 BtCollisionWorld_ContactResultCallback) + GetM_resultCallback() (_swig_ret BtCollisionWorld_ContactResultCallback) + Process(arg2 BtBroadphaseProxy) (_swig_ret bool) + SwigIsBtBroadphaseAabbCallback() + SwigGetBtBroadphaseAabbCallback() BtBroadphaseAabbCallback +} + +type SwigcptrDebugDrawcallback uintptr + +func (p SwigcptrDebugDrawcallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrDebugDrawcallback) SwigIsDebugDrawcallback() { +} + +func NewDebugDrawcallback(arg1 BtIDebugDraw, arg2 BtTransform, arg3 BtVector3) (_swig_ret DebugDrawcallback) { + var swig_r DebugDrawcallback + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (DebugDrawcallback)(SwigcptrDebugDrawcallback(C._wrap_new_DebugDrawcallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrDebugDrawcallback) InternalProcessTriangleIndex(arg2 BtVector3, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_DebugDrawcallback_internalProcessTriangleIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrDebugDrawcallback) ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_DebugDrawcallback_processTriangle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func DeleteDebugDrawcallback(arg1 DebugDrawcallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_DebugDrawcallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrDebugDrawcallback) SwigIsBtTriangleCallback() { +} + +func (p SwigcptrDebugDrawcallback) SwigGetBtTriangleCallback() BtTriangleCallback { + return SwigcptrBtTriangleCallback(getSwigcptr(p)) +} + +func (arg1 SwigcptrDebugDrawcallback) SwigGetBtInternalTriangleIndexCallback() (_swig_ret BtInternalTriangleIndexCallback) { + var swig_r BtInternalTriangleIndexCallback + _swig_i_0 := arg1 + swig_r = (BtInternalTriangleIndexCallback)(SwigcptrBtInternalTriangleIndexCallback(C._wrap_DebugDrawcallback_SwigGetBtInternalTriangleIndexCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +type DebugDrawcallback interface { + Swigcptr() uintptr + SwigIsDebugDrawcallback() + InternalProcessTriangleIndex(arg2 BtVector3, arg3 int, arg4 int) + ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) + SwigIsBtTriangleCallback() + SwigGetBtTriangleCallback() BtTriangleCallback + SwigGetBtInternalTriangleIndexCallback() (_swig_ret BtInternalTriangleIndexCallback) +} + +type BtSolverMode int + +func _swig_getSOLVER_RANDMIZE_ORDER() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_RANDMIZE_ORDER_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_RANDMIZE_ORDER BtSolverMode = _swig_getSOLVER_RANDMIZE_ORDER() + +func _swig_getSOLVER_FRICTION_SEPARATE() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_FRICTION_SEPARATE_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_FRICTION_SEPARATE BtSolverMode = _swig_getSOLVER_FRICTION_SEPARATE() + +func _swig_getSOLVER_USE_WARMSTARTING() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_USE_WARMSTARTING_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_USE_WARMSTARTING BtSolverMode = _swig_getSOLVER_USE_WARMSTARTING() + +func _swig_getSOLVER_USE_2_FRICTION_DIRECTIONS() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_USE_2_FRICTION_DIRECTIONS_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_USE_2_FRICTION_DIRECTIONS BtSolverMode = _swig_getSOLVER_USE_2_FRICTION_DIRECTIONS() + +func _swig_getSOLVER_ENABLE_FRICTION_DIRECTION_CACHING() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_ENABLE_FRICTION_DIRECTION_CACHING_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_ENABLE_FRICTION_DIRECTION_CACHING BtSolverMode = _swig_getSOLVER_ENABLE_FRICTION_DIRECTION_CACHING() + +func _swig_getSOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION BtSolverMode = _swig_getSOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION() + +func _swig_getSOLVER_CACHE_FRIENDLY() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_CACHE_FRIENDLY_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_CACHE_FRIENDLY BtSolverMode = _swig_getSOLVER_CACHE_FRIENDLY() + +func _swig_getSOLVER_SIMD() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_SIMD_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_SIMD BtSolverMode = _swig_getSOLVER_SIMD() + +func _swig_getSOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS BtSolverMode = _swig_getSOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS() + +func _swig_getSOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS BtSolverMode = _swig_getSOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS() + +func _swig_getSOLVER_DISABLE_IMPLICIT_CONE_FRICTION() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_DISABLE_IMPLICIT_CONE_FRICTION_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_DISABLE_IMPLICIT_CONE_FRICTION BtSolverMode = _swig_getSOLVER_DISABLE_IMPLICIT_CONE_FRICTION() + +func _swig_getSOLVER_USE_ARTICULATED_WARMSTARTING() (_swig_ret BtSolverMode) { + var swig_r BtSolverMode + swig_r = (BtSolverMode)(C._wrap_SOLVER_USE_ARTICULATED_WARMSTARTING_mbt_e879218550ba2e2b()) + return swig_r +} + +var SOLVER_USE_ARTICULATED_WARMSTARTING BtSolverMode = _swig_getSOLVER_USE_ARTICULATED_WARMSTARTING() + +type SwigcptrBtContactSolverInfoData uintptr + +func (p SwigcptrBtContactSolverInfoData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtContactSolverInfoData) SwigIsBtContactSolverInfoData() { +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_tau(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_tau_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_tau() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_tau_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_damping(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_damping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_damping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_damping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_friction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_friction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_friction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_friction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_timeStep(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_timeStep_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_timeStep() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_timeStep_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_restitution(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_restitution_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_restitution() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_restitution_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_numIterations(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_numIterations_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_numIterations() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoData_m_numIterations_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_maxErrorReduction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_maxErrorReduction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_maxErrorReduction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_maxErrorReduction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_sor(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_sor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_sor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_sor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_erp(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_erp_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_erp() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_erp_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_erp2(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_erp2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_erp2() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_erp2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_deformable_erp(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_deformable_erp_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_deformable_erp() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_deformable_erp_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_deformable_cfm(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_deformable_cfm_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_deformable_cfm() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_deformable_cfm_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_deformable_maxErrorReduction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_deformable_maxErrorReduction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_deformable_maxErrorReduction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_deformable_maxErrorReduction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_globalCfm(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_globalCfm_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_globalCfm() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_globalCfm_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_frictionERP(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_frictionERP_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_frictionERP() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_frictionERP_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_frictionCFM(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_frictionCFM_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_frictionCFM() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_frictionCFM_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_splitImpulse(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_splitImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_splitImpulse() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoData_m_splitImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_splitImpulsePenetrationThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_splitImpulsePenetrationThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_splitImpulsePenetrationThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_splitImpulsePenetrationThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_splitImpulseTurnErp(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_splitImpulseTurnErp_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_splitImpulseTurnErp() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_splitImpulseTurnErp_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_linearSlop(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_linearSlop_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_linearSlop() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_linearSlop_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_warmstartingFactor(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_warmstartingFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_warmstartingFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_warmstartingFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_articulatedWarmstartingFactor(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_articulatedWarmstartingFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_articulatedWarmstartingFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_articulatedWarmstartingFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_solverMode(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_solverMode_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_solverMode() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoData_m_solverMode_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_restingContactRestitutionThreshold(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_restingContactRestitutionThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_restingContactRestitutionThreshold() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoData_m_restingContactRestitutionThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_minimumSolverBatchSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_minimumSolverBatchSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_minimumSolverBatchSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoData_m_minimumSolverBatchSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_maxGyroscopicForce(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_maxGyroscopicForce_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_maxGyroscopicForce() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_maxGyroscopicForce_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_singleAxisRollingFrictionThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_singleAxisRollingFrictionThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_singleAxisRollingFrictionThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_singleAxisRollingFrictionThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_leastSquaresResidualThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_leastSquaresResidualThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_leastSquaresResidualThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_leastSquaresResidualThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_restitutionVelocityThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_restitutionVelocityThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_restitutionVelocityThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoData_m_restitutionVelocityThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_jointFeedbackInWorldSpace(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_jointFeedbackInWorldSpace_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_jointFeedbackInWorldSpace() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btContactSolverInfoData_m_jointFeedbackInWorldSpace_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_jointFeedbackInJointFrame(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_jointFeedbackInJointFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_jointFeedbackInJointFrame() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btContactSolverInfoData_m_jointFeedbackInJointFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_reportSolverAnalytics(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_reportSolverAnalytics_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_reportSolverAnalytics() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoData_m_reportSolverAnalytics_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoData) SetM_numNonContactInnerIterations(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoData_m_numNonContactInnerIterations_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoData) GetM_numNonContactInnerIterations() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoData_m_numNonContactInnerIterations_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtContactSolverInfoData() (_swig_ret BtContactSolverInfoData) { + var swig_r BtContactSolverInfoData + swig_r = (BtContactSolverInfoData)(SwigcptrBtContactSolverInfoData(C._wrap_new_btContactSolverInfoData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtContactSolverInfoData(arg1 BtContactSolverInfoData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btContactSolverInfoData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtContactSolverInfoData interface { + Swigcptr() uintptr + SwigIsBtContactSolverInfoData() + SetM_tau(arg2 float32) + GetM_tau() (_swig_ret float32) + SetM_damping(arg2 float32) + GetM_damping() (_swig_ret float32) + SetM_friction(arg2 float32) + GetM_friction() (_swig_ret float32) + SetM_timeStep(arg2 float32) + GetM_timeStep() (_swig_ret float32) + SetM_restitution(arg2 float32) + GetM_restitution() (_swig_ret float32) + SetM_numIterations(arg2 int) + GetM_numIterations() (_swig_ret int) + SetM_maxErrorReduction(arg2 float32) + GetM_maxErrorReduction() (_swig_ret float32) + SetM_sor(arg2 float32) + GetM_sor() (_swig_ret float32) + SetM_erp(arg2 float32) + GetM_erp() (_swig_ret float32) + SetM_erp2(arg2 float32) + GetM_erp2() (_swig_ret float32) + SetM_deformable_erp(arg2 float32) + GetM_deformable_erp() (_swig_ret float32) + SetM_deformable_cfm(arg2 float32) + GetM_deformable_cfm() (_swig_ret float32) + SetM_deformable_maxErrorReduction(arg2 float32) + GetM_deformable_maxErrorReduction() (_swig_ret float32) + SetM_globalCfm(arg2 float32) + GetM_globalCfm() (_swig_ret float32) + SetM_frictionERP(arg2 float32) + GetM_frictionERP() (_swig_ret float32) + SetM_frictionCFM(arg2 float32) + GetM_frictionCFM() (_swig_ret float32) + SetM_splitImpulse(arg2 int) + GetM_splitImpulse() (_swig_ret int) + SetM_splitImpulsePenetrationThreshold(arg2 float32) + GetM_splitImpulsePenetrationThreshold() (_swig_ret float32) + SetM_splitImpulseTurnErp(arg2 float32) + GetM_splitImpulseTurnErp() (_swig_ret float32) + SetM_linearSlop(arg2 float32) + GetM_linearSlop() (_swig_ret float32) + SetM_warmstartingFactor(arg2 float32) + GetM_warmstartingFactor() (_swig_ret float32) + SetM_articulatedWarmstartingFactor(arg2 float32) + GetM_articulatedWarmstartingFactor() (_swig_ret float32) + SetM_solverMode(arg2 int) + GetM_solverMode() (_swig_ret int) + SetM_restingContactRestitutionThreshold(arg2 int) + GetM_restingContactRestitutionThreshold() (_swig_ret int) + SetM_minimumSolverBatchSize(arg2 int) + GetM_minimumSolverBatchSize() (_swig_ret int) + SetM_maxGyroscopicForce(arg2 float32) + GetM_maxGyroscopicForce() (_swig_ret float32) + SetM_singleAxisRollingFrictionThreshold(arg2 float32) + GetM_singleAxisRollingFrictionThreshold() (_swig_ret float32) + SetM_leastSquaresResidualThreshold(arg2 float32) + GetM_leastSquaresResidualThreshold() (_swig_ret float32) + SetM_restitutionVelocityThreshold(arg2 float32) + GetM_restitutionVelocityThreshold() (_swig_ret float32) + SetM_jointFeedbackInWorldSpace(arg2 bool) + GetM_jointFeedbackInWorldSpace() (_swig_ret bool) + SetM_jointFeedbackInJointFrame(arg2 bool) + GetM_jointFeedbackInJointFrame() (_swig_ret bool) + SetM_reportSolverAnalytics(arg2 int) + GetM_reportSolverAnalytics() (_swig_ret int) + SetM_numNonContactInnerIterations(arg2 int) + GetM_numNonContactInnerIterations() (_swig_ret int) +} + +type SwigcptrBtContactSolverInfo uintptr + +func (p SwigcptrBtContactSolverInfo) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtContactSolverInfo) SwigIsBtContactSolverInfo() { +} + +func NewBtContactSolverInfo() (_swig_ret BtContactSolverInfo) { + var swig_r BtContactSolverInfo + swig_r = (BtContactSolverInfo)(SwigcptrBtContactSolverInfo(C._wrap_new_btContactSolverInfo_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtContactSolverInfo(arg1 BtContactSolverInfo) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btContactSolverInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_tau(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_tau_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_tau() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_tau_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_damping(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_damping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_damping() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_damping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_friction(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_friction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_friction() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_friction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_timeStep(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_timeStep_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_timeStep() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_timeStep_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_restitution(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_restitution_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_restitution() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_restitution_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_numIterations(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_numIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_numIterations() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtContactSolverInfo_M_numIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_maxErrorReduction(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_maxErrorReduction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_maxErrorReduction() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_maxErrorReduction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_sor(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_sor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_sor() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_sor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_erp(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_erp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_erp() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_erp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_erp2(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_erp2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_erp2() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_erp2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_deformable_erp(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_deformable_erp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_deformable_erp() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_deformable_erp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_deformable_cfm(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_deformable_cfm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_deformable_cfm() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_deformable_cfm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_deformable_maxErrorReduction(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_deformable_maxErrorReduction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_deformable_maxErrorReduction() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_deformable_maxErrorReduction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_globalCfm(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_globalCfm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_globalCfm() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_globalCfm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_frictionERP(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_frictionERP_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_frictionERP() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_frictionERP_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_frictionCFM(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_frictionCFM_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_frictionCFM() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_frictionCFM_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_splitImpulse(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_splitImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_splitImpulse() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtContactSolverInfo_M_splitImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_splitImpulsePenetrationThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_splitImpulsePenetrationThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_splitImpulsePenetrationThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_splitImpulsePenetrationThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_splitImpulseTurnErp(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_splitImpulseTurnErp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_splitImpulseTurnErp() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_splitImpulseTurnErp_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_linearSlop(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_linearSlop_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_linearSlop() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_linearSlop_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_warmstartingFactor(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_warmstartingFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_warmstartingFactor() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_warmstartingFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_articulatedWarmstartingFactor(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_articulatedWarmstartingFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_articulatedWarmstartingFactor() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_articulatedWarmstartingFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_solverMode(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_solverMode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_solverMode() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtContactSolverInfo_M_solverMode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_restingContactRestitutionThreshold(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_restingContactRestitutionThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_restingContactRestitutionThreshold() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtContactSolverInfo_M_restingContactRestitutionThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_minimumSolverBatchSize(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_minimumSolverBatchSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_minimumSolverBatchSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtContactSolverInfo_M_minimumSolverBatchSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_maxGyroscopicForce(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_maxGyroscopicForce_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_maxGyroscopicForce() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_maxGyroscopicForce_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_singleAxisRollingFrictionThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_singleAxisRollingFrictionThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_singleAxisRollingFrictionThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_singleAxisRollingFrictionThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_leastSquaresResidualThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_leastSquaresResidualThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_leastSquaresResidualThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_leastSquaresResidualThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_restitutionVelocityThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_restitutionVelocityThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_restitutionVelocityThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_GetbtContactSolverInfo_M_restitutionVelocityThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_jointFeedbackInWorldSpace(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_jointFeedbackInWorldSpace_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_jointFeedbackInWorldSpace() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_GetbtContactSolverInfo_M_jointFeedbackInWorldSpace_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_jointFeedbackInJointFrame(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_jointFeedbackInJointFrame_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_jointFeedbackInJointFrame() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_GetbtContactSolverInfo_M_jointFeedbackInJointFrame_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_reportSolverAnalytics(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_reportSolverAnalytics_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_reportSolverAnalytics() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtContactSolverInfo_M_reportSolverAnalytics_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtContactSolverInfo) SetM_numNonContactInnerIterations(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtContactSolverInfo_M_numNonContactInnerIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtContactSolverInfo) GetM_numNonContactInnerIterations() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtContactSolverInfo_M_numNonContactInnerIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtContactSolverInfo) SwigIsBtContactSolverInfoData() { +} + +func (p SwigcptrBtContactSolverInfo) SwigGetBtContactSolverInfoData() BtContactSolverInfoData { + return SwigcptrBtContactSolverInfoData(getSwigcptr(p)) +} + +type BtContactSolverInfo interface { + Swigcptr() uintptr + SwigIsBtContactSolverInfo() + SetM_tau(arg1 float32) + GetM_tau() (_swig_ret float32) + SetM_damping(arg1 float32) + GetM_damping() (_swig_ret float32) + SetM_friction(arg1 float32) + GetM_friction() (_swig_ret float32) + SetM_timeStep(arg1 float32) + GetM_timeStep() (_swig_ret float32) + SetM_restitution(arg1 float32) + GetM_restitution() (_swig_ret float32) + SetM_numIterations(arg1 int) + GetM_numIterations() (_swig_ret int) + SetM_maxErrorReduction(arg1 float32) + GetM_maxErrorReduction() (_swig_ret float32) + SetM_sor(arg1 float32) + GetM_sor() (_swig_ret float32) + SetM_erp(arg1 float32) + GetM_erp() (_swig_ret float32) + SetM_erp2(arg1 float32) + GetM_erp2() (_swig_ret float32) + SetM_deformable_erp(arg1 float32) + GetM_deformable_erp() (_swig_ret float32) + SetM_deformable_cfm(arg1 float32) + GetM_deformable_cfm() (_swig_ret float32) + SetM_deformable_maxErrorReduction(arg1 float32) + GetM_deformable_maxErrorReduction() (_swig_ret float32) + SetM_globalCfm(arg1 float32) + GetM_globalCfm() (_swig_ret float32) + SetM_frictionERP(arg1 float32) + GetM_frictionERP() (_swig_ret float32) + SetM_frictionCFM(arg1 float32) + GetM_frictionCFM() (_swig_ret float32) + SetM_splitImpulse(arg1 int) + GetM_splitImpulse() (_swig_ret int) + SetM_splitImpulsePenetrationThreshold(arg1 float32) + GetM_splitImpulsePenetrationThreshold() (_swig_ret float32) + SetM_splitImpulseTurnErp(arg1 float32) + GetM_splitImpulseTurnErp() (_swig_ret float32) + SetM_linearSlop(arg1 float32) + GetM_linearSlop() (_swig_ret float32) + SetM_warmstartingFactor(arg1 float32) + GetM_warmstartingFactor() (_swig_ret float32) + SetM_articulatedWarmstartingFactor(arg1 float32) + GetM_articulatedWarmstartingFactor() (_swig_ret float32) + SetM_solverMode(arg1 int) + GetM_solverMode() (_swig_ret int) + SetM_restingContactRestitutionThreshold(arg1 int) + GetM_restingContactRestitutionThreshold() (_swig_ret int) + SetM_minimumSolverBatchSize(arg1 int) + GetM_minimumSolverBatchSize() (_swig_ret int) + SetM_maxGyroscopicForce(arg1 float32) + GetM_maxGyroscopicForce() (_swig_ret float32) + SetM_singleAxisRollingFrictionThreshold(arg1 float32) + GetM_singleAxisRollingFrictionThreshold() (_swig_ret float32) + SetM_leastSquaresResidualThreshold(arg1 float32) + GetM_leastSquaresResidualThreshold() (_swig_ret float32) + SetM_restitutionVelocityThreshold(arg1 float32) + GetM_restitutionVelocityThreshold() (_swig_ret float32) + SetM_jointFeedbackInWorldSpace(arg1 bool) + GetM_jointFeedbackInWorldSpace() (_swig_ret bool) + SetM_jointFeedbackInJointFrame(arg1 bool) + GetM_jointFeedbackInJointFrame() (_swig_ret bool) + SetM_reportSolverAnalytics(arg1 int) + GetM_reportSolverAnalytics() (_swig_ret int) + SetM_numNonContactInnerIterations(arg1 int) + GetM_numNonContactInnerIterations() (_swig_ret int) + SwigIsBtContactSolverInfoData() + SwigGetBtContactSolverInfoData() BtContactSolverInfoData +} + +type SwigcptrBtContactSolverInfoDoubleData uintptr + +func (p SwigcptrBtContactSolverInfoDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtContactSolverInfoDoubleData) SwigIsBtContactSolverInfoDoubleData() { +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_tau(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_tau_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_tau() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_tau_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_damping(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_damping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_damping() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_damping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_friction(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_friction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_friction() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_friction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_timeStep(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_timeStep_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_timeStep() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_timeStep_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_restitution(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_restitution_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_restitution() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_restitution_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_maxErrorReduction(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_maxErrorReduction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_maxErrorReduction() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_maxErrorReduction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_sor(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_sor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_sor() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_sor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_erp(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_erp_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_erp() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_erp_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_erp2(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_erp2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_erp2() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_erp2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_globalCfm(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_globalCfm_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_globalCfm() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_globalCfm_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_splitImpulsePenetrationThreshold(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_splitImpulsePenetrationThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_splitImpulsePenetrationThreshold() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_splitImpulsePenetrationThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_splitImpulseTurnErp(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_splitImpulseTurnErp_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_splitImpulseTurnErp() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_splitImpulseTurnErp_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_linearSlop(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_linearSlop_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_linearSlop() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_linearSlop_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_warmstartingFactor(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_warmstartingFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_warmstartingFactor() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_warmstartingFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_articulatedWarmstartingFactor(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_articulatedWarmstartingFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_articulatedWarmstartingFactor() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_articulatedWarmstartingFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_maxGyroscopicForce(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_maxGyroscopicForce_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_maxGyroscopicForce() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_maxGyroscopicForce_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_singleAxisRollingFrictionThreshold(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_singleAxisRollingFrictionThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_singleAxisRollingFrictionThreshold() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btContactSolverInfoDoubleData_m_singleAxisRollingFrictionThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_numIterations(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_numIterations_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_numIterations() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoDoubleData_m_numIterations_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_solverMode(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_solverMode_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_solverMode() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoDoubleData_m_solverMode_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_restingContactRestitutionThreshold(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_restingContactRestitutionThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_restingContactRestitutionThreshold() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoDoubleData_m_restingContactRestitutionThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_minimumSolverBatchSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_minimumSolverBatchSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_minimumSolverBatchSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoDoubleData_m_minimumSolverBatchSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_splitImpulse(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_splitImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_splitImpulse() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoDoubleData_m_splitImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) SetM_padding(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoDoubleData_m_padding_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_138)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtContactSolverInfoDoubleData) GetM_padding() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btContactSolverInfoDoubleData_m_padding_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtContactSolverInfoDoubleData() (_swig_ret BtContactSolverInfoDoubleData) { + var swig_r BtContactSolverInfoDoubleData + swig_r = (BtContactSolverInfoDoubleData)(SwigcptrBtContactSolverInfoDoubleData(C._wrap_new_btContactSolverInfoDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtContactSolverInfoDoubleData(arg1 BtContactSolverInfoDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btContactSolverInfoDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtContactSolverInfoDoubleData interface { + Swigcptr() uintptr + SwigIsBtContactSolverInfoDoubleData() + SetM_tau(arg2 float64) + GetM_tau() (_swig_ret float64) + SetM_damping(arg2 float64) + GetM_damping() (_swig_ret float64) + SetM_friction(arg2 float64) + GetM_friction() (_swig_ret float64) + SetM_timeStep(arg2 float64) + GetM_timeStep() (_swig_ret float64) + SetM_restitution(arg2 float64) + GetM_restitution() (_swig_ret float64) + SetM_maxErrorReduction(arg2 float64) + GetM_maxErrorReduction() (_swig_ret float64) + SetM_sor(arg2 float64) + GetM_sor() (_swig_ret float64) + SetM_erp(arg2 float64) + GetM_erp() (_swig_ret float64) + SetM_erp2(arg2 float64) + GetM_erp2() (_swig_ret float64) + SetM_globalCfm(arg2 float64) + GetM_globalCfm() (_swig_ret float64) + SetM_splitImpulsePenetrationThreshold(arg2 float64) + GetM_splitImpulsePenetrationThreshold() (_swig_ret float64) + SetM_splitImpulseTurnErp(arg2 float64) + GetM_splitImpulseTurnErp() (_swig_ret float64) + SetM_linearSlop(arg2 float64) + GetM_linearSlop() (_swig_ret float64) + SetM_warmstartingFactor(arg2 float64) + GetM_warmstartingFactor() (_swig_ret float64) + SetM_articulatedWarmstartingFactor(arg2 float64) + GetM_articulatedWarmstartingFactor() (_swig_ret float64) + SetM_maxGyroscopicForce(arg2 float64) + GetM_maxGyroscopicForce() (_swig_ret float64) + SetM_singleAxisRollingFrictionThreshold(arg2 float64) + GetM_singleAxisRollingFrictionThreshold() (_swig_ret float64) + SetM_numIterations(arg2 int) + GetM_numIterations() (_swig_ret int) + SetM_solverMode(arg2 int) + GetM_solverMode() (_swig_ret int) + SetM_restingContactRestitutionThreshold(arg2 int) + GetM_restingContactRestitutionThreshold() (_swig_ret int) + SetM_minimumSolverBatchSize(arg2 int) + GetM_minimumSolverBatchSize() (_swig_ret int) + SetM_splitImpulse(arg2 int) + GetM_splitImpulse() (_swig_ret int) + SetM_padding(arg2 string) + GetM_padding() (_swig_ret string) +} + +type SwigcptrBtContactSolverInfoFloatData uintptr + +func (p SwigcptrBtContactSolverInfoFloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtContactSolverInfoFloatData) SwigIsBtContactSolverInfoFloatData() { +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_tau(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_tau_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_tau() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_tau_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_damping(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_damping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_damping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_damping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_friction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_friction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_friction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_friction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_timeStep(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_timeStep_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_timeStep() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_timeStep_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_restitution(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_restitution_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_restitution() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_restitution_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_maxErrorReduction(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_maxErrorReduction_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_maxErrorReduction() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_maxErrorReduction_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_sor(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_sor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_sor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_sor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_erp(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_erp_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_erp() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_erp_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_erp2(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_erp2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_erp2() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_erp2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_globalCfm(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_globalCfm_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_globalCfm() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_globalCfm_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_splitImpulsePenetrationThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_splitImpulsePenetrationThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_splitImpulsePenetrationThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_splitImpulsePenetrationThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_splitImpulseTurnErp(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_splitImpulseTurnErp_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_splitImpulseTurnErp() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_splitImpulseTurnErp_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_linearSlop(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_linearSlop_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_linearSlop() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_linearSlop_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_warmstartingFactor(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_warmstartingFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_warmstartingFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_warmstartingFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_articulatedWarmstartingFactor(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_articulatedWarmstartingFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_articulatedWarmstartingFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_articulatedWarmstartingFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_maxGyroscopicForce(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_maxGyroscopicForce_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_maxGyroscopicForce() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_maxGyroscopicForce_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_singleAxisRollingFrictionThreshold(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_singleAxisRollingFrictionThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_singleAxisRollingFrictionThreshold() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btContactSolverInfoFloatData_m_singleAxisRollingFrictionThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_numIterations(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_numIterations_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_numIterations() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoFloatData_m_numIterations_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_solverMode(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_solverMode_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_solverMode() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoFloatData_m_solverMode_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_restingContactRestitutionThreshold(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_restingContactRestitutionThreshold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_restingContactRestitutionThreshold() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoFloatData_m_restingContactRestitutionThreshold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_minimumSolverBatchSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_minimumSolverBatchSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_minimumSolverBatchSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoFloatData_m_minimumSolverBatchSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) SetM_splitImpulse(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btContactSolverInfoFloatData_m_splitImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtContactSolverInfoFloatData) GetM_splitImpulse() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btContactSolverInfoFloatData_m_splitImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtContactSolverInfoFloatData() (_swig_ret BtContactSolverInfoFloatData) { + var swig_r BtContactSolverInfoFloatData + swig_r = (BtContactSolverInfoFloatData)(SwigcptrBtContactSolverInfoFloatData(C._wrap_new_btContactSolverInfoFloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtContactSolverInfoFloatData(arg1 BtContactSolverInfoFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btContactSolverInfoFloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtContactSolverInfoFloatData interface { + Swigcptr() uintptr + SwigIsBtContactSolverInfoFloatData() + SetM_tau(arg2 float32) + GetM_tau() (_swig_ret float32) + SetM_damping(arg2 float32) + GetM_damping() (_swig_ret float32) + SetM_friction(arg2 float32) + GetM_friction() (_swig_ret float32) + SetM_timeStep(arg2 float32) + GetM_timeStep() (_swig_ret float32) + SetM_restitution(arg2 float32) + GetM_restitution() (_swig_ret float32) + SetM_maxErrorReduction(arg2 float32) + GetM_maxErrorReduction() (_swig_ret float32) + SetM_sor(arg2 float32) + GetM_sor() (_swig_ret float32) + SetM_erp(arg2 float32) + GetM_erp() (_swig_ret float32) + SetM_erp2(arg2 float32) + GetM_erp2() (_swig_ret float32) + SetM_globalCfm(arg2 float32) + GetM_globalCfm() (_swig_ret float32) + SetM_splitImpulsePenetrationThreshold(arg2 float32) + GetM_splitImpulsePenetrationThreshold() (_swig_ret float32) + SetM_splitImpulseTurnErp(arg2 float32) + GetM_splitImpulseTurnErp() (_swig_ret float32) + SetM_linearSlop(arg2 float32) + GetM_linearSlop() (_swig_ret float32) + SetM_warmstartingFactor(arg2 float32) + GetM_warmstartingFactor() (_swig_ret float32) + SetM_articulatedWarmstartingFactor(arg2 float32) + GetM_articulatedWarmstartingFactor() (_swig_ret float32) + SetM_maxGyroscopicForce(arg2 float32) + GetM_maxGyroscopicForce() (_swig_ret float32) + SetM_singleAxisRollingFrictionThreshold(arg2 float32) + GetM_singleAxisRollingFrictionThreshold() (_swig_ret float32) + SetM_numIterations(arg2 int) + GetM_numIterations() (_swig_ret int) + SetM_solverMode(arg2 int) + GetM_solverMode() (_swig_ret int) + SetM_restingContactRestitutionThreshold(arg2 int) + GetM_restingContactRestitutionThreshold() (_swig_ret int) + SetM_minimumSolverBatchSize(arg2 int) + GetM_minimumSolverBatchSize() (_swig_ret int) + SetM_splitImpulse(arg2 int) + GetM_splitImpulse() (_swig_ret int) +} + +type BtDynamicsWorldType int + +func _swig_getBT_SIMPLE_DYNAMICS_WORLD() (_swig_ret BtDynamicsWorldType) { + var swig_r BtDynamicsWorldType + swig_r = (BtDynamicsWorldType)(C._wrap_BT_SIMPLE_DYNAMICS_WORLD_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_SIMPLE_DYNAMICS_WORLD BtDynamicsWorldType = _swig_getBT_SIMPLE_DYNAMICS_WORLD() + +func _swig_getBT_DISCRETE_DYNAMICS_WORLD() (_swig_ret BtDynamicsWorldType) { + var swig_r BtDynamicsWorldType + swig_r = (BtDynamicsWorldType)(C._wrap_BT_DISCRETE_DYNAMICS_WORLD_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_DISCRETE_DYNAMICS_WORLD BtDynamicsWorldType = _swig_getBT_DISCRETE_DYNAMICS_WORLD() + +func _swig_getBT_CONTINUOUS_DYNAMICS_WORLD() (_swig_ret BtDynamicsWorldType) { + var swig_r BtDynamicsWorldType + swig_r = (BtDynamicsWorldType)(C._wrap_BT_CONTINUOUS_DYNAMICS_WORLD_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONTINUOUS_DYNAMICS_WORLD BtDynamicsWorldType = _swig_getBT_CONTINUOUS_DYNAMICS_WORLD() + +func _swig_getBT_SOFT_RIGID_DYNAMICS_WORLD() (_swig_ret BtDynamicsWorldType) { + var swig_r BtDynamicsWorldType + swig_r = (BtDynamicsWorldType)(C._wrap_BT_SOFT_RIGID_DYNAMICS_WORLD_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_SOFT_RIGID_DYNAMICS_WORLD BtDynamicsWorldType = _swig_getBT_SOFT_RIGID_DYNAMICS_WORLD() + +func _swig_getBT_GPU_DYNAMICS_WORLD() (_swig_ret BtDynamicsWorldType) { + var swig_r BtDynamicsWorldType + swig_r = (BtDynamicsWorldType)(C._wrap_BT_GPU_DYNAMICS_WORLD_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_GPU_DYNAMICS_WORLD BtDynamicsWorldType = _swig_getBT_GPU_DYNAMICS_WORLD() + +func _swig_getBT_SOFT_MULTIBODY_DYNAMICS_WORLD() (_swig_ret BtDynamicsWorldType) { + var swig_r BtDynamicsWorldType + swig_r = (BtDynamicsWorldType)(C._wrap_BT_SOFT_MULTIBODY_DYNAMICS_WORLD_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_SOFT_MULTIBODY_DYNAMICS_WORLD BtDynamicsWorldType = _swig_getBT_SOFT_MULTIBODY_DYNAMICS_WORLD() + +func _swig_getBT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD() (_swig_ret BtDynamicsWorldType) { + var swig_r BtDynamicsWorldType + swig_r = (BtDynamicsWorldType)(C._wrap_BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD BtDynamicsWorldType = _swig_getBT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD() + +type SwigcptrBtDynamicsWorld uintptr + +func (p SwigcptrBtDynamicsWorld) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDynamicsWorld) SwigIsBtDynamicsWorld() { +} + +func DeleteBtDynamicsWorld(arg1 BtDynamicsWorld) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDynamicsWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDynamicsWorld) StepSimulation__SWIG_0(arg2 float32, arg3 int, arg4 float32) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (int)(C._wrap_btDynamicsWorld_stepSimulation__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.swig_intgo(_swig_i_2), C.float(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorld) StepSimulation__SWIG_1(arg2 float32, arg3 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (int)(C._wrap_btDynamicsWorld_stepSimulation__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorld) StepSimulation__SWIG_2(arg2 float32) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (int)(C._wrap_btDynamicsWorld_stepSimulation__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +func (p SwigcptrBtDynamicsWorld) StepSimulation(a ...interface{}) int { + argc := len(a) + if argc == 1 { + return p.StepSimulation__SWIG_2(a[0].(float32)) + } + if argc == 2 { + return p.StepSimulation__SWIG_1(a[0].(float32), a[1].(int)) + } + if argc == 3 { + return p.StepSimulation__SWIG_0(a[0].(float32), a[1].(int), a[2].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDynamicsWorld) DebugDrawWorld() { + _swig_i_0 := arg1 + C._wrap_btDynamicsWorld_debugDrawWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDynamicsWorld) AddConstraint__SWIG_0(arg2 BtTypedConstraint, arg3 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btDynamicsWorld_addConstraint__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C._Bool(_swig_i_2)) +} + +func (arg1 SwigcptrBtDynamicsWorld) AddConstraint__SWIG_1(arg2 BtTypedConstraint) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_addConstraint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtDynamicsWorld) AddConstraint(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.AddConstraint__SWIG_1(a[0].(BtTypedConstraint)) + return + } + if argc == 2 { + p.AddConstraint__SWIG_0(a[0].(BtTypedConstraint), a[1].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDynamicsWorld) RemoveConstraint(arg2 BtTypedConstraint) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_removeConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) AddAction(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_addAction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) RemoveAction(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_removeAction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) SetGravity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_setGravity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) GetGravity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btDynamicsWorld_getGravity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorld) SynchronizeMotionStates() { + _swig_i_0 := arg1 + C._wrap_btDynamicsWorld_synchronizeMotionStates_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDynamicsWorld) AddRigidBody__SWIG_0(arg2 BtRigidBody) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_addRigidBody__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) AddRigidBody__SWIG_1(arg2 BtRigidBody, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btDynamicsWorld_addRigidBody__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (p SwigcptrBtDynamicsWorld) AddRigidBody(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.AddRigidBody__SWIG_0(a[0].(BtRigidBody)) + return + } + if argc == 3 { + p.AddRigidBody__SWIG_1(a[0].(BtRigidBody), a[1].(int), a[2].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDynamicsWorld) RemoveRigidBody(arg2 BtRigidBody) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_removeRigidBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) SetConstraintSolver(arg2 BtConstraintSolver) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_setConstraintSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) GetConstraintSolver() (_swig_ret BtConstraintSolver) { + var swig_r BtConstraintSolver + _swig_i_0 := arg1 + swig_r = (BtConstraintSolver)(SwigcptrBtConstraintSolver(C._wrap_btDynamicsWorld_getConstraintSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorld) GetNumConstraints() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDynamicsWorld_getNumConstraints_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorld) GetConstraint__SWIG_0(arg2 int) (_swig_ret BtTypedConstraint) { + var swig_r BtTypedConstraint + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtTypedConstraint)(SwigcptrBtTypedConstraint(C._wrap_btDynamicsWorld_getConstraint__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorld) GetConstraint__SWIG_1(arg2 int) (_swig_ret BtTypedConstraint) { + var swig_r BtTypedConstraint + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtTypedConstraint)(SwigcptrBtTypedConstraint(C._wrap_btDynamicsWorld_getConstraint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (p SwigcptrBtDynamicsWorld) GetConstraint(a ...interface{}) interface{} { + argc := len(a) + if argc == 1 { + return p.GetConstraint__SWIG_0(a[0].(int)) + } + if argc == 1 { + return p.GetConstraint__SWIG_1(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDynamicsWorld) GetWorldType() (_swig_ret BtDynamicsWorldType) { + var swig_r BtDynamicsWorldType + _swig_i_0 := arg1 + swig_r = (BtDynamicsWorldType)(C._wrap_btDynamicsWorld_getWorldType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorld) ClearForces() { + _swig_i_0 := arg1 + C._wrap_btDynamicsWorld_clearForces_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDynamicsWorld) SetInternalTickCallback__SWIG_0(arg2 _swig_fnptr, arg3 uintptr, arg4 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btDynamicsWorld_setInternalTickCallback__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_140(_swig_i_1), C.uintptr_t(_swig_i_2), C._Bool(_swig_i_3)) +} + +func (arg1 SwigcptrBtDynamicsWorld) SetInternalTickCallback__SWIG_1(arg2 _swig_fnptr, arg3 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btDynamicsWorld_setInternalTickCallback__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_141(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtDynamicsWorld) SetInternalTickCallback__SWIG_2(arg2 _swig_fnptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDynamicsWorld_setInternalTickCallback__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_142(_swig_i_1)) +} + +func (p SwigcptrBtDynamicsWorld) SetInternalTickCallback(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.SetInternalTickCallback__SWIG_2(a[0].(_swig_fnptr)) + return + } + if argc == 2 { + p.SetInternalTickCallback__SWIG_1(a[0].(_swig_fnptr), a[1].(uintptr)) + return + } + if argc == 3 { + p.SetInternalTickCallback__SWIG_0(a[0].(_swig_fnptr), a[1].(uintptr), a[2].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDynamicsWorld) SetWorldUserInfo(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDynamicsWorld_setWorldUserInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) GetWorldUserInfo() (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + swig_r = (uintptr)(C._wrap_btDynamicsWorld_getWorldUserInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorld) GetSolverInfo__SWIG_0() (_swig_ret BtContactSolverInfo) { + var swig_r BtContactSolverInfo + _swig_i_0 := arg1 + swig_r = (BtContactSolverInfo)(SwigcptrBtContactSolverInfo(C._wrap_btDynamicsWorld_getSolverInfo__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorld) GetSolverInfo__SWIG_1() (_swig_ret BtContactSolverInfo) { + var swig_r BtContactSolverInfo + _swig_i_0 := arg1 + swig_r = (BtContactSolverInfo)(SwigcptrBtContactSolverInfo(C._wrap_btDynamicsWorld_getSolverInfo__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtDynamicsWorld) GetSolverInfo(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetSolverInfo__SWIG_0() + } + if argc == 0 { + return p.GetSolverInfo__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDynamicsWorld) AddVehicle(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_addVehicle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) RemoveVehicle(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_removeVehicle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) AddCharacter(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_addCharacter_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorld) RemoveCharacter(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_removeCharacter_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) SetBroadphase(arg1 BtBroadphaseInterface) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDynamicsWorld_setBroadphase_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetBroadphase__SWIG_0() (_swig_ret BtBroadphaseInterface) { + var swig_r BtBroadphaseInterface + swig_r = (BtBroadphaseInterface)(SwigcptrBtBroadphaseInterface(C._wrap_btDynamicsWorld_getBroadphase__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetBroadphase__SWIG_1() (_swig_ret BtBroadphaseInterface) { + var swig_r BtBroadphaseInterface + swig_r = (BtBroadphaseInterface)(SwigcptrBtBroadphaseInterface(C._wrap_btDynamicsWorld_getBroadphase__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtDynamicsWorld) GetBroadphase(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetBroadphase__SWIG_0() + } + if argc == 0 { + return p.GetBroadphase__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetPairCache() (_swig_ret BtOverlappingPairCache) { + var swig_r BtOverlappingPairCache + swig_r = (BtOverlappingPairCache)(SwigcptrBtOverlappingPairCache(C._wrap_btDynamicsWorld_getPairCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetDispatcher__SWIG_0() (_swig_ret BtDispatcher) { + var swig_r BtDispatcher + swig_r = (BtDispatcher)(SwigcptrBtDispatcher(C._wrap_btDynamicsWorld_getDispatcher__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetDispatcher__SWIG_1() (_swig_ret BtDispatcher) { + var swig_r BtDispatcher + swig_r = (BtDispatcher)(SwigcptrBtDispatcher(C._wrap_btDynamicsWorld_getDispatcher__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtDynamicsWorld) GetDispatcher(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetDispatcher__SWIG_0() + } + if argc == 0 { + return p.GetDispatcher__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDynamicsWorld) UpdateSingleAabb(arg1 BtCollisionObject) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDynamicsWorld_updateSingleAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) UpdateAabbs() { + C._wrap_btDynamicsWorld_updateAabbs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) ComputeOverlappingPairs() { + C._wrap_btDynamicsWorld_computeOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) SetDebugDrawer(arg1 BtIDebugDraw) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDynamicsWorld_setDebugDrawer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetDebugDrawer() (_swig_ret BtIDebugDraw) { + var swig_r BtIDebugDraw + swig_r = (BtIDebugDraw)(SwigcptrBtIDebugDraw(C._wrap_btDynamicsWorld_getDebugDrawer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDynamicsWorld) DebugDrawObject(arg1 BtTransform, arg2 BtCollisionShape, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDynamicsWorld_debugDrawObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetNumCollisionObjects() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btDynamicsWorld_getNumCollisionObjects_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtDynamicsWorld) RayTest(arg1 BtVector3, arg2 BtVector3, arg3 BtCollisionWorld_RayResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDynamicsWorld_rayTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) ConvexSweepTest__SWIG_0(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionWorld_ConvexResultCallback, arg5 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + C._wrap_btDynamicsWorld_convexSweepTest__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) ConvexSweepTest__SWIG_1(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionWorld_ConvexResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDynamicsWorld_convexSweepTest__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtDynamicsWorld) ConvexSweepTest(a ...interface{}) { + argc := len(a) + if argc == 4 { + p.ConvexSweepTest__SWIG_1(a[0].(BtConvexShape), a[1].(BtTransform), a[2].(BtTransform), a[3].(BtCollisionWorld_ConvexResultCallback)) + return + } + if argc == 5 { + p.ConvexSweepTest__SWIG_0(a[0].(BtConvexShape), a[1].(BtTransform), a[2].(BtTransform), a[3].(BtCollisionWorld_ConvexResultCallback), a[4].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDynamicsWorld) ContactTest(arg1 BtCollisionObject, arg2 BtCollisionWorld_ContactResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorld_contactTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) ContactPairTest(arg1 BtCollisionObject, arg2 BtCollisionObject, arg3 BtCollisionWorld_ContactResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDynamicsWorld_contactPairTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func BtDynamicsWorldRayTestSingle(arg1 BtTransform, arg2 BtTransform, arg3 BtCollisionObject, arg4 BtCollisionShape, arg5 BtTransform, arg6 BtCollisionWorld_RayResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btDynamicsWorld_rayTestSingle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func BtDynamicsWorldRayTestSingleInternal(arg1 BtTransform, arg2 BtTransform, arg3 BtCollisionObjectWrapper, arg4 BtCollisionWorld_RayResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDynamicsWorld_rayTestSingleInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func BtDynamicsWorldObjectQuerySingle(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionObject, arg5 BtCollisionShape, arg6 BtTransform, arg7 BtCollisionWorld_ConvexResultCallback, arg8 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := arg8 + C._wrap_btDynamicsWorld_objectQuerySingle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.float(_swig_i_7)) +} + +func BtDynamicsWorldObjectQuerySingleInternal(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionObjectWrapper, arg5 BtCollisionWorld_ConvexResultCallback, arg6 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + C._wrap_btDynamicsWorld_objectQuerySingleInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.float(_swig_i_5)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) AddCollisionObject__SWIG_0(arg1 BtCollisionObject, arg2 int, arg3 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btDynamicsWorld_addCollisionObject__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) AddCollisionObject__SWIG_1(arg1 BtCollisionObject, arg2 int) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btDynamicsWorld_addCollisionObject__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) AddCollisionObject__SWIG_2(arg1 BtCollisionObject) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDynamicsWorld_addCollisionObject__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtDynamicsWorld) AddCollisionObject(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.AddCollisionObject__SWIG_2(a[0].(BtCollisionObject)) + return + } + if argc == 2 { + p.AddCollisionObject__SWIG_1(a[0].(BtCollisionObject), a[1].(int)) + return + } + if argc == 3 { + p.AddCollisionObject__SWIG_0(a[0].(BtCollisionObject), a[1].(int), a[2].(int)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDynamicsWorld) RefreshBroadphaseProxy(arg1 BtCollisionObject) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDynamicsWorld_refreshBroadphaseProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetCollisionObjectArray__SWIG_0() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_ + swig_r = (BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_(C._wrap_btDynamicsWorld_getCollisionObjectArray__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetCollisionObjectArray__SWIG_1() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_ + swig_r = (BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_(C._wrap_btDynamicsWorld_getCollisionObjectArray__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtDynamicsWorld) GetCollisionObjectArray(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetCollisionObjectArray__SWIG_0() + } + if argc == 0 { + return p.GetCollisionObjectArray__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDynamicsWorld) RemoveCollisionObject(arg1 BtCollisionObject) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDynamicsWorld_removeCollisionObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) PerformDiscreteCollisionDetection() { + C._wrap_btDynamicsWorld_performDiscreteCollisionDetection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetDispatchInfo__SWIG_0() (_swig_ret BtDispatcherInfo) { + var swig_r BtDispatcherInfo + swig_r = (BtDispatcherInfo)(SwigcptrBtDispatcherInfo(C._wrap_btDynamicsWorld_getDispatchInfo__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetDispatchInfo__SWIG_1() (_swig_ret BtDispatcherInfo) { + var swig_r BtDispatcherInfo + swig_r = (BtDispatcherInfo)(SwigcptrBtDispatcherInfo(C._wrap_btDynamicsWorld_getDispatchInfo__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtDynamicsWorld) GetDispatchInfo(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetDispatchInfo__SWIG_0() + } + if argc == 0 { + return p.GetDispatchInfo__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDynamicsWorld) GetForceUpdateAllAabbs() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btDynamicsWorld_getForceUpdateAllAabbs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtDynamicsWorld) SetForceUpdateAllAabbs(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btDynamicsWorld_setForceUpdateAllAabbs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDynamicsWorld) Serialize(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDynamicsWorld_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtDynamicsWorld) SwigIsBtCollisionWorld() { +} + +func (p SwigcptrBtDynamicsWorld) SwigGetBtCollisionWorld() BtCollisionWorld { + return SwigcptrBtCollisionWorld(getSwigcptr(p)) +} + +type BtDynamicsWorld interface { + Swigcptr() uintptr + SwigIsBtDynamicsWorld() + StepSimulation(a ...interface{}) int + DebugDrawWorld() + AddConstraint(a ...interface{}) + RemoveConstraint(arg2 BtTypedConstraint) + AddAction(arg2 BtActionInterface) + RemoveAction(arg2 BtActionInterface) + SetGravity(arg2 BtVector3) + GetGravity() (_swig_ret BtVector3) + SynchronizeMotionStates() + AddRigidBody(a ...interface{}) + RemoveRigidBody(arg2 BtRigidBody) + SetConstraintSolver(arg2 BtConstraintSolver) + GetConstraintSolver() (_swig_ret BtConstraintSolver) + GetNumConstraints() (_swig_ret int) + GetConstraint(a ...interface{}) interface{} + GetWorldType() (_swig_ret BtDynamicsWorldType) + ClearForces() + SetInternalTickCallback(a ...interface{}) + SetWorldUserInfo(arg2 uintptr) + GetWorldUserInfo() (_swig_ret uintptr) + GetSolverInfo(a ...interface{}) interface{} + AddVehicle(arg2 BtActionInterface) + RemoveVehicle(arg2 BtActionInterface) + AddCharacter(arg2 BtActionInterface) + RemoveCharacter(arg2 BtActionInterface) + SetBroadphase(arg1 BtBroadphaseInterface) + GetBroadphase(a ...interface{}) interface{} + GetPairCache() (_swig_ret BtOverlappingPairCache) + GetDispatcher(a ...interface{}) interface{} + UpdateSingleAabb(arg1 BtCollisionObject) + UpdateAabbs() + ComputeOverlappingPairs() + SetDebugDrawer(arg1 BtIDebugDraw) + GetDebugDrawer() (_swig_ret BtIDebugDraw) + DebugDrawObject(arg1 BtTransform, arg2 BtCollisionShape, arg3 BtVector3) + GetNumCollisionObjects() (_swig_ret int) + RayTest(arg1 BtVector3, arg2 BtVector3, arg3 BtCollisionWorld_RayResultCallback) + ConvexSweepTest(a ...interface{}) + ContactTest(arg1 BtCollisionObject, arg2 BtCollisionWorld_ContactResultCallback) + ContactPairTest(arg1 BtCollisionObject, arg2 BtCollisionObject, arg3 BtCollisionWorld_ContactResultCallback) + AddCollisionObject(a ...interface{}) + RefreshBroadphaseProxy(arg1 BtCollisionObject) + GetCollisionObjectArray(a ...interface{}) interface{} + RemoveCollisionObject(arg1 BtCollisionObject) + PerformDiscreteCollisionDetection() + GetDispatchInfo(a ...interface{}) interface{} + GetForceUpdateAllAabbs() (_swig_ret bool) + SetForceUpdateAllAabbs(arg1 bool) + Serialize(arg1 BtSerializer) + SwigIsBtCollisionWorld() + SwigGetBtCollisionWorld() BtCollisionWorld +} + +type SwigcptrBtDynamicsWorldDoubleData uintptr + +func (p SwigcptrBtDynamicsWorldDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDynamicsWorldDoubleData) SwigIsBtDynamicsWorldDoubleData() { +} + +func (arg1 SwigcptrBtDynamicsWorldDoubleData) SetM_solverInfo(arg2 BtContactSolverInfoDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorldDoubleData_m_solverInfo_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorldDoubleData) GetM_solverInfo() (_swig_ret BtContactSolverInfoDoubleData) { + var swig_r BtContactSolverInfoDoubleData + _swig_i_0 := arg1 + swig_r = (BtContactSolverInfoDoubleData)(SwigcptrBtContactSolverInfoDoubleData(C._wrap_btDynamicsWorldDoubleData_m_solverInfo_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorldDoubleData) SetM_gravity(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorldDoubleData_m_gravity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorldDoubleData) GetM_gravity() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btDynamicsWorldDoubleData_m_gravity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtDynamicsWorldDoubleData() (_swig_ret BtDynamicsWorldDoubleData) { + var swig_r BtDynamicsWorldDoubleData + swig_r = (BtDynamicsWorldDoubleData)(SwigcptrBtDynamicsWorldDoubleData(C._wrap_new_btDynamicsWorldDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtDynamicsWorldDoubleData(arg1 BtDynamicsWorldDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDynamicsWorldDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtDynamicsWorldDoubleData interface { + Swigcptr() uintptr + SwigIsBtDynamicsWorldDoubleData() + SetM_solverInfo(arg2 BtContactSolverInfoDoubleData) + GetM_solverInfo() (_swig_ret BtContactSolverInfoDoubleData) + SetM_gravity(arg2 BtVector3DoubleData) + GetM_gravity() (_swig_ret BtVector3DoubleData) +} + +type SwigcptrBtDynamicsWorldFloatData uintptr + +func (p SwigcptrBtDynamicsWorldFloatData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDynamicsWorldFloatData) SwigIsBtDynamicsWorldFloatData() { +} + +func (arg1 SwigcptrBtDynamicsWorldFloatData) SetM_solverInfo(arg2 BtContactSolverInfoFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorldFloatData_m_solverInfo_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorldFloatData) GetM_solverInfo() (_swig_ret BtContactSolverInfoFloatData) { + var swig_r BtContactSolverInfoFloatData + _swig_i_0 := arg1 + swig_r = (BtContactSolverInfoFloatData)(SwigcptrBtContactSolverInfoFloatData(C._wrap_btDynamicsWorldFloatData_m_solverInfo_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDynamicsWorldFloatData) SetM_gravity(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDynamicsWorldFloatData_m_gravity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDynamicsWorldFloatData) GetM_gravity() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btDynamicsWorldFloatData_m_gravity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtDynamicsWorldFloatData() (_swig_ret BtDynamicsWorldFloatData) { + var swig_r BtDynamicsWorldFloatData + swig_r = (BtDynamicsWorldFloatData)(SwigcptrBtDynamicsWorldFloatData(C._wrap_new_btDynamicsWorldFloatData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtDynamicsWorldFloatData(arg1 BtDynamicsWorldFloatData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDynamicsWorldFloatData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtDynamicsWorldFloatData interface { + Swigcptr() uintptr + SwigIsBtDynamicsWorldFloatData() + SetM_solverInfo(arg2 BtContactSolverInfoFloatData) + GetM_solverInfo() (_swig_ret BtContactSolverInfoFloatData) + SetM_gravity(arg2 BtVector3FloatData) + GetM_gravity() (_swig_ret BtVector3FloatData) +} + +type SwigcptrBtDiscreteDynamicsWorld uintptr + +func (p SwigcptrBtDiscreteDynamicsWorld) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDiscreteDynamicsWorld) SwigIsBtDiscreteDynamicsWorld() { +} + +func NewBtDiscreteDynamicsWorld(arg1 BtDispatcher, arg2 BtBroadphaseInterface, arg3 BtConstraintSolver, arg4 BtCollisionConfiguration) (_swig_ret BtDiscreteDynamicsWorld) { + var swig_r BtDiscreteDynamicsWorld + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtDiscreteDynamicsWorld)(SwigcptrBtDiscreteDynamicsWorld(C._wrap_new_btDiscreteDynamicsWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func DeleteBtDiscreteDynamicsWorld(arg1 BtDiscreteDynamicsWorld) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDiscreteDynamicsWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) StepSimulation__SWIG_0(arg2 float32, arg3 int, arg4 float32) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (int)(C._wrap_btDiscreteDynamicsWorld_stepSimulation__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.swig_intgo(_swig_i_2), C.float(_swig_i_3))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) StepSimulation__SWIG_1(arg2 float32, arg3 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (int)(C._wrap_btDiscreteDynamicsWorld_stepSimulation__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) StepSimulation__SWIG_2(arg2 float32) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (int)(C._wrap_btDiscreteDynamicsWorld_stepSimulation__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +func (p SwigcptrBtDiscreteDynamicsWorld) StepSimulation(a ...interface{}) int { + argc := len(a) + if argc == 1 { + return p.StepSimulation__SWIG_2(a[0].(float32)) + } + if argc == 2 { + return p.StepSimulation__SWIG_1(a[0].(float32), a[1].(int)) + } + if argc == 3 { + return p.StepSimulation__SWIG_0(a[0].(float32), a[1].(int), a[2].(float32)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) SolveConstraints(arg2 BtContactSolverInfo) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_solveConstraints_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) SynchronizeMotionStates() { + _swig_i_0 := arg1 + C._wrap_btDiscreteDynamicsWorld_synchronizeMotionStates_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) SynchronizeSingleMotionState(arg2 BtRigidBody) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_synchronizeSingleMotionState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) AddConstraint__SWIG_0(arg2 BtTypedConstraint, arg3 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btDiscreteDynamicsWorld_addConstraint__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C._Bool(_swig_i_2)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) AddConstraint__SWIG_1(arg2 BtTypedConstraint) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_addConstraint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtDiscreteDynamicsWorld) AddConstraint(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.AddConstraint__SWIG_1(a[0].(BtTypedConstraint)) + return + } + if argc == 2 { + p.AddConstraint__SWIG_0(a[0].(BtTypedConstraint), a[1].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) RemoveConstraint(arg2 BtTypedConstraint) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_removeConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) AddAction(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_addAction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) RemoveAction(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_removeAction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetSimulationIslandManager__SWIG_0() (_swig_ret BtSimulationIslandManager) { + var swig_r BtSimulationIslandManager + _swig_i_0 := arg1 + swig_r = (BtSimulationIslandManager)(SwigcptrBtSimulationIslandManager(C._wrap_btDiscreteDynamicsWorld_getSimulationIslandManager__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetSimulationIslandManager__SWIG_1() (_swig_ret BtSimulationIslandManager) { + var swig_r BtSimulationIslandManager + _swig_i_0 := arg1 + swig_r = (BtSimulationIslandManager)(SwigcptrBtSimulationIslandManager(C._wrap_btDiscreteDynamicsWorld_getSimulationIslandManager__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtDiscreteDynamicsWorld) GetSimulationIslandManager(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetSimulationIslandManager__SWIG_0() + } + if argc == 0 { + return p.GetSimulationIslandManager__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetCollisionWorld() (_swig_ret BtCollisionWorld) { + var swig_r BtCollisionWorld + _swig_i_0 := arg1 + swig_r = (BtCollisionWorld)(SwigcptrBtCollisionWorld(C._wrap_btDiscreteDynamicsWorld_getCollisionWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) SetGravity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_setGravity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetGravity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btDiscreteDynamicsWorld_getGravity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) AddCollisionObject__SWIG_0(arg2 BtCollisionObject, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btDiscreteDynamicsWorld_addCollisionObject__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) AddCollisionObject__SWIG_1(arg2 BtCollisionObject, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btDiscreteDynamicsWorld_addCollisionObject__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) AddCollisionObject__SWIG_2(arg2 BtCollisionObject) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_addCollisionObject__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtDiscreteDynamicsWorld) AddCollisionObject(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.AddCollisionObject__SWIG_2(a[0].(BtCollisionObject)) + return + } + if argc == 2 { + p.AddCollisionObject__SWIG_1(a[0].(BtCollisionObject), a[1].(int)) + return + } + if argc == 3 { + p.AddCollisionObject__SWIG_0(a[0].(BtCollisionObject), a[1].(int), a[2].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) AddRigidBody__SWIG_0(arg2 BtRigidBody) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_addRigidBody__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) AddRigidBody__SWIG_1(arg2 BtRigidBody, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btDiscreteDynamicsWorld_addRigidBody__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (p SwigcptrBtDiscreteDynamicsWorld) AddRigidBody(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.AddRigidBody__SWIG_0(a[0].(BtRigidBody)) + return + } + if argc == 3 { + p.AddRigidBody__SWIG_1(a[0].(BtRigidBody), a[1].(int), a[2].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) RemoveRigidBody(arg2 BtRigidBody) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_removeRigidBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) RemoveCollisionObject(arg2 BtCollisionObject) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_removeCollisionObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) DebugDrawConstraint(arg2 BtTypedConstraint) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_debugDrawConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) DebugDrawWorld() { + _swig_i_0 := arg1 + C._wrap_btDiscreteDynamicsWorld_debugDrawWorld_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) SetConstraintSolver(arg2 BtConstraintSolver) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_setConstraintSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetConstraintSolver() (_swig_ret BtConstraintSolver) { + var swig_r BtConstraintSolver + _swig_i_0 := arg1 + swig_r = (BtConstraintSolver)(SwigcptrBtConstraintSolver(C._wrap_btDiscreteDynamicsWorld_getConstraintSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetNumConstraints() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDiscreteDynamicsWorld_getNumConstraints_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetConstraint__SWIG_0(arg2 int) (_swig_ret BtTypedConstraint) { + var swig_r BtTypedConstraint + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtTypedConstraint)(SwigcptrBtTypedConstraint(C._wrap_btDiscreteDynamicsWorld_getConstraint__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetConstraint__SWIG_1(arg2 int) (_swig_ret BtTypedConstraint) { + var swig_r BtTypedConstraint + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtTypedConstraint)(SwigcptrBtTypedConstraint(C._wrap_btDiscreteDynamicsWorld_getConstraint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (p SwigcptrBtDiscreteDynamicsWorld) GetConstraint(a ...interface{}) interface{} { + argc := len(a) + if argc == 1 { + return p.GetConstraint__SWIG_0(a[0].(int)) + } + if argc == 1 { + return p.GetConstraint__SWIG_1(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetWorldType() (_swig_ret BtDynamicsWorldType) { + var swig_r BtDynamicsWorldType + _swig_i_0 := arg1 + swig_r = (BtDynamicsWorldType)(C._wrap_btDiscreteDynamicsWorld_getWorldType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) ClearForces() { + _swig_i_0 := arg1 + C._wrap_btDiscreteDynamicsWorld_clearForces_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) ApplyGravity() { + _swig_i_0 := arg1 + C._wrap_btDiscreteDynamicsWorld_applyGravity_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) SetNumTasks(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDiscreteDynamicsWorld_setNumTasks_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) UpdateVehicles(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDiscreteDynamicsWorld_updateVehicles_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) AddVehicle(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_addVehicle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) RemoveVehicle(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_removeVehicle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) AddCharacter(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_addCharacter_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) RemoveCharacter(arg2 BtActionInterface) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_removeCharacter_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) SetSynchronizeAllMotionStates(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDiscreteDynamicsWorld_setSynchronizeAllMotionStates_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetSynchronizeAllMotionStates() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDiscreteDynamicsWorld_getSynchronizeAllMotionStates_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) SetApplySpeculativeContactRestitution(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDiscreteDynamicsWorld_setApplySpeculativeContactRestitution_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetApplySpeculativeContactRestitution() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDiscreteDynamicsWorld_getApplySpeculativeContactRestitution_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) Serialize(arg2 BtSerializer) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) SetLatencyMotionStateInterpolation(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDiscreteDynamicsWorld_setLatencyMotionStateInterpolation_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetLatencyMotionStateInterpolation() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btDiscreteDynamicsWorld_getLatencyMotionStateInterpolation_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetNonStaticRigidBodies__SWIG_0() (_swig_ret BtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_(C._wrap_btDiscreteDynamicsWorld_getNonStaticRigidBodies__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDiscreteDynamicsWorld) GetNonStaticRigidBodies__SWIG_1() (_swig_ret BtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_(C._wrap_btDiscreteDynamicsWorld_getNonStaticRigidBodies__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtDiscreteDynamicsWorld) GetNonStaticRigidBodies(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetNonStaticRigidBodies__SWIG_0() + } + if argc == 0 { + return p.GetNonStaticRigidBodies__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) SetInternalTickCallback__SWIG_0(arg1 _swig_fnptr, arg2 uintptr, arg3 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btDiscreteDynamicsWorld_setInternalTickCallback__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_type_143(_swig_i_0), C.uintptr_t(_swig_i_1), C._Bool(_swig_i_2)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) SetInternalTickCallback__SWIG_1(arg1 _swig_fnptr, arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDiscreteDynamicsWorld_setInternalTickCallback__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_type_144(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) SetInternalTickCallback__SWIG_2(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_btDiscreteDynamicsWorld_setInternalTickCallback__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_type_145(_swig_i_0)) +} + +func (p SwigcptrBtDiscreteDynamicsWorld) SetInternalTickCallback(a ...interface{}) { + argc := len(a) + if argc == 1 { + p.SetInternalTickCallback__SWIG_2(a[0].(_swig_fnptr)) + return + } + if argc == 2 { + p.SetInternalTickCallback__SWIG_1(a[0].(_swig_fnptr), a[1].(uintptr)) + return + } + if argc == 3 { + p.SetInternalTickCallback__SWIG_0(a[0].(_swig_fnptr), a[1].(uintptr), a[2].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) SetWorldUserInfo(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btDiscreteDynamicsWorld_setWorldUserInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetWorldUserInfo() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btDiscreteDynamicsWorld_getWorldUserInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetSolverInfo__SWIG_0() (_swig_ret BtContactSolverInfo) { + var swig_r BtContactSolverInfo + swig_r = (BtContactSolverInfo)(SwigcptrBtContactSolverInfo(C._wrap_btDiscreteDynamicsWorld_getSolverInfo__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetSolverInfo__SWIG_1() (_swig_ret BtContactSolverInfo) { + var swig_r BtContactSolverInfo + swig_r = (BtContactSolverInfo)(SwigcptrBtContactSolverInfo(C._wrap_btDiscreteDynamicsWorld_getSolverInfo__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtDiscreteDynamicsWorld) GetSolverInfo(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetSolverInfo__SWIG_0() + } + if argc == 0 { + return p.GetSolverInfo__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) SetBroadphase(arg1 BtBroadphaseInterface) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDiscreteDynamicsWorld_setBroadphase_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetBroadphase__SWIG_0() (_swig_ret BtBroadphaseInterface) { + var swig_r BtBroadphaseInterface + swig_r = (BtBroadphaseInterface)(SwigcptrBtBroadphaseInterface(C._wrap_btDiscreteDynamicsWorld_getBroadphase__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetBroadphase__SWIG_1() (_swig_ret BtBroadphaseInterface) { + var swig_r BtBroadphaseInterface + swig_r = (BtBroadphaseInterface)(SwigcptrBtBroadphaseInterface(C._wrap_btDiscreteDynamicsWorld_getBroadphase__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtDiscreteDynamicsWorld) GetBroadphase(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetBroadphase__SWIG_0() + } + if argc == 0 { + return p.GetBroadphase__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetPairCache() (_swig_ret BtOverlappingPairCache) { + var swig_r BtOverlappingPairCache + swig_r = (BtOverlappingPairCache)(SwigcptrBtOverlappingPairCache(C._wrap_btDiscreteDynamicsWorld_getPairCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetDispatcher__SWIG_0() (_swig_ret BtDispatcher) { + var swig_r BtDispatcher + swig_r = (BtDispatcher)(SwigcptrBtDispatcher(C._wrap_btDiscreteDynamicsWorld_getDispatcher__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetDispatcher__SWIG_1() (_swig_ret BtDispatcher) { + var swig_r BtDispatcher + swig_r = (BtDispatcher)(SwigcptrBtDispatcher(C._wrap_btDiscreteDynamicsWorld_getDispatcher__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtDiscreteDynamicsWorld) GetDispatcher(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetDispatcher__SWIG_0() + } + if argc == 0 { + return p.GetDispatcher__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) UpdateSingleAabb(arg1 BtCollisionObject) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDiscreteDynamicsWorld_updateSingleAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) UpdateAabbs() { + C._wrap_btDiscreteDynamicsWorld_updateAabbs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) ComputeOverlappingPairs() { + C._wrap_btDiscreteDynamicsWorld_computeOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) SetDebugDrawer(arg1 BtIDebugDraw) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDiscreteDynamicsWorld_setDebugDrawer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetDebugDrawer() (_swig_ret BtIDebugDraw) { + var swig_r BtIDebugDraw + swig_r = (BtIDebugDraw)(SwigcptrBtIDebugDraw(C._wrap_btDiscreteDynamicsWorld_getDebugDrawer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) DebugDrawObject(arg1 BtTransform, arg2 BtCollisionShape, arg3 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDiscreteDynamicsWorld_debugDrawObject_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetNumCollisionObjects() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btDiscreteDynamicsWorld_getNumCollisionObjects_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) RayTest(arg1 BtVector3, arg2 BtVector3, arg3 BtCollisionWorld_RayResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDiscreteDynamicsWorld_rayTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) ConvexSweepTest__SWIG_0(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionWorld_ConvexResultCallback, arg5 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + C._wrap_btDiscreteDynamicsWorld_convexSweepTest__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) ConvexSweepTest__SWIG_1(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionWorld_ConvexResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDiscreteDynamicsWorld_convexSweepTest__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtDiscreteDynamicsWorld) ConvexSweepTest(a ...interface{}) { + argc := len(a) + if argc == 4 { + p.ConvexSweepTest__SWIG_1(a[0].(BtConvexShape), a[1].(BtTransform), a[2].(BtTransform), a[3].(BtCollisionWorld_ConvexResultCallback)) + return + } + if argc == 5 { + p.ConvexSweepTest__SWIG_0(a[0].(BtConvexShape), a[1].(BtTransform), a[2].(BtTransform), a[3].(BtCollisionWorld_ConvexResultCallback), a[4].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) ContactTest(arg1 BtCollisionObject, arg2 BtCollisionWorld_ContactResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDiscreteDynamicsWorld_contactTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) ContactPairTest(arg1 BtCollisionObject, arg2 BtCollisionObject, arg3 BtCollisionWorld_ContactResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btDiscreteDynamicsWorld_contactPairTest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func BtDiscreteDynamicsWorldRayTestSingle(arg1 BtTransform, arg2 BtTransform, arg3 BtCollisionObject, arg4 BtCollisionShape, arg5 BtTransform, arg6 BtCollisionWorld_RayResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btDiscreteDynamicsWorld_rayTestSingle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func BtDiscreteDynamicsWorldRayTestSingleInternal(arg1 BtTransform, arg2 BtTransform, arg3 BtCollisionObjectWrapper, arg4 BtCollisionWorld_RayResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btDiscreteDynamicsWorld_rayTestSingleInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func BtDiscreteDynamicsWorldObjectQuerySingle(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionObject, arg5 BtCollisionShape, arg6 BtTransform, arg7 BtCollisionWorld_ConvexResultCallback, arg8 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := arg8 + C._wrap_btDiscreteDynamicsWorld_objectQuerySingle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.float(_swig_i_7)) +} + +func BtDiscreteDynamicsWorldObjectQuerySingleInternal(arg1 BtConvexShape, arg2 BtTransform, arg3 BtTransform, arg4 BtCollisionObjectWrapper, arg5 BtCollisionWorld_ConvexResultCallback, arg6 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + C._wrap_btDiscreteDynamicsWorld_objectQuerySingleInternal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.float(_swig_i_5)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) RefreshBroadphaseProxy(arg1 BtCollisionObject) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btDiscreteDynamicsWorld_refreshBroadphaseProxy_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetCollisionObjectArray__SWIG_0() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_ + swig_r = (BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_(C._wrap_btDiscreteDynamicsWorld_getCollisionObjectArray__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetCollisionObjectArray__SWIG_1() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_ + swig_r = (BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_(C._wrap_btDiscreteDynamicsWorld_getCollisionObjectArray__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtDiscreteDynamicsWorld) GetCollisionObjectArray(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetCollisionObjectArray__SWIG_0() + } + if argc == 0 { + return p.GetCollisionObjectArray__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) PerformDiscreteCollisionDetection() { + C._wrap_btDiscreteDynamicsWorld_performDiscreteCollisionDetection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetDispatchInfo__SWIG_0() (_swig_ret BtDispatcherInfo) { + var swig_r BtDispatcherInfo + swig_r = (BtDispatcherInfo)(SwigcptrBtDispatcherInfo(C._wrap_btDiscreteDynamicsWorld_getDispatchInfo__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetDispatchInfo__SWIG_1() (_swig_ret BtDispatcherInfo) { + var swig_r BtDispatcherInfo + swig_r = (BtDispatcherInfo)(SwigcptrBtDispatcherInfo(C._wrap_btDiscreteDynamicsWorld_getDispatchInfo__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtDiscreteDynamicsWorld) GetDispatchInfo(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetDispatchInfo__SWIG_0() + } + if argc == 0 { + return p.GetDispatchInfo__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) GetForceUpdateAllAabbs() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btDiscreteDynamicsWorld_getForceUpdateAllAabbs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtDiscreteDynamicsWorld) SetForceUpdateAllAabbs(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btDiscreteDynamicsWorld_setForceUpdateAllAabbs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (p SwigcptrBtDiscreteDynamicsWorld) SwigIsBtDynamicsWorld() { +} + +func (p SwigcptrBtDiscreteDynamicsWorld) SwigGetBtDynamicsWorld() BtDynamicsWorld { + return SwigcptrBtDynamicsWorld(getSwigcptr(p)) +} + +func (p SwigcptrBtDiscreteDynamicsWorld) SwigIsBtCollisionWorld() { +} + +func (p SwigcptrBtDiscreteDynamicsWorld) SwigGetBtCollisionWorld() BtCollisionWorld { + return SwigcptrBtCollisionWorld(getSwigcptr(p)) +} + +type BtDiscreteDynamicsWorld interface { + Swigcptr() uintptr + SwigIsBtDiscreteDynamicsWorld() + StepSimulation(a ...interface{}) int + SolveConstraints(arg2 BtContactSolverInfo) + SynchronizeMotionStates() + SynchronizeSingleMotionState(arg2 BtRigidBody) + AddConstraint(a ...interface{}) + RemoveConstraint(arg2 BtTypedConstraint) + AddAction(arg2 BtActionInterface) + RemoveAction(arg2 BtActionInterface) + GetSimulationIslandManager(a ...interface{}) interface{} + GetCollisionWorld() (_swig_ret BtCollisionWorld) + SetGravity(arg2 BtVector3) + GetGravity() (_swig_ret BtVector3) + AddCollisionObject(a ...interface{}) + AddRigidBody(a ...interface{}) + RemoveRigidBody(arg2 BtRigidBody) + RemoveCollisionObject(arg2 BtCollisionObject) + DebugDrawConstraint(arg2 BtTypedConstraint) + DebugDrawWorld() + SetConstraintSolver(arg2 BtConstraintSolver) + GetConstraintSolver() (_swig_ret BtConstraintSolver) + GetNumConstraints() (_swig_ret int) + GetConstraint(a ...interface{}) interface{} + GetWorldType() (_swig_ret BtDynamicsWorldType) + ClearForces() + ApplyGravity() + SetNumTasks(arg2 int) + UpdateVehicles(arg2 float32) + AddVehicle(arg2 BtActionInterface) + RemoveVehicle(arg2 BtActionInterface) + AddCharacter(arg2 BtActionInterface) + RemoveCharacter(arg2 BtActionInterface) + SetSynchronizeAllMotionStates(arg2 bool) + GetSynchronizeAllMotionStates() (_swig_ret bool) + SetApplySpeculativeContactRestitution(arg2 bool) + GetApplySpeculativeContactRestitution() (_swig_ret bool) + Serialize(arg2 BtSerializer) + SetLatencyMotionStateInterpolation(arg2 bool) + GetLatencyMotionStateInterpolation() (_swig_ret bool) + GetNonStaticRigidBodies(a ...interface{}) interface{} + SetInternalTickCallback(a ...interface{}) + SetWorldUserInfo(arg1 uintptr) + GetWorldUserInfo() (_swig_ret uintptr) + GetSolverInfo(a ...interface{}) interface{} + SetBroadphase(arg1 BtBroadphaseInterface) + GetBroadphase(a ...interface{}) interface{} + GetPairCache() (_swig_ret BtOverlappingPairCache) + GetDispatcher(a ...interface{}) interface{} + UpdateSingleAabb(arg1 BtCollisionObject) + UpdateAabbs() + ComputeOverlappingPairs() + SetDebugDrawer(arg1 BtIDebugDraw) + GetDebugDrawer() (_swig_ret BtIDebugDraw) + DebugDrawObject(arg1 BtTransform, arg2 BtCollisionShape, arg3 BtVector3) + GetNumCollisionObjects() (_swig_ret int) + RayTest(arg1 BtVector3, arg2 BtVector3, arg3 BtCollisionWorld_RayResultCallback) + ConvexSweepTest(a ...interface{}) + ContactTest(arg1 BtCollisionObject, arg2 BtCollisionWorld_ContactResultCallback) + ContactPairTest(arg1 BtCollisionObject, arg2 BtCollisionObject, arg3 BtCollisionWorld_ContactResultCallback) + RefreshBroadphaseProxy(arg1 BtCollisionObject) + GetCollisionObjectArray(a ...interface{}) interface{} + PerformDiscreteCollisionDetection() + GetDispatchInfo(a ...interface{}) interface{} + GetForceUpdateAllAabbs() (_swig_ret bool) + SetForceUpdateAllAabbs(arg1 bool) + SwigIsBtDynamicsWorld() + SwigGetBtDynamicsWorld() BtDynamicsWorld + SwigIsBtCollisionWorld() + SwigGetBtCollisionWorld() BtCollisionWorld +} + +const USE_PATH_COMPRESSION int = 1 +const STATIC_SIMULATION_ISLAND_OPTIMIZATION int = 1 + +type SwigcptrBtElement uintptr + +func (p SwigcptrBtElement) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtElement) SwigIsBtElement() { +} + +func (arg1 SwigcptrBtElement) SetM_id(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btElement_m_id_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtElement) GetM_id() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btElement_m_id_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtElement) SetM_sz(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btElement_m_sz_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtElement) GetM_sz() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btElement_m_sz_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtElement() (_swig_ret BtElement) { + var swig_r BtElement + swig_r = (BtElement)(SwigcptrBtElement(C._wrap_new_btElement_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtElement(arg1 BtElement) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btElement_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtElement interface { + Swigcptr() uintptr + SwigIsBtElement() + SetM_id(arg2 int) + GetM_id() (_swig_ret int) + SetM_sz(arg2 int) + GetM_sz() (_swig_ret int) +} + +type SwigcptrBtUnionFind uintptr + +func (p SwigcptrBtUnionFind) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtUnionFind) SwigIsBtUnionFind() { +} + +func NewBtUnionFind() (_swig_ret BtUnionFind) { + var swig_r BtUnionFind + swig_r = (BtUnionFind)(SwigcptrBtUnionFind(C._wrap_new_btUnionFind_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtUnionFind(arg1 BtUnionFind) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btUnionFind_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtUnionFind) SortIslands() { + _swig_i_0 := arg1 + C._wrap_btUnionFind_sortIslands_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtUnionFind) Reset(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btUnionFind_reset_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtUnionFind) GetNumElements() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btUnionFind_getNumElements_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtUnionFind) IsRoot(arg2 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btUnionFind_isRoot_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtUnionFind) GetElement__SWIG_0(arg2 int) (_swig_ret BtElement) { + var swig_r BtElement + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtElement)(SwigcptrBtElement(C._wrap_btUnionFind_getElement__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtUnionFind) GetElement__SWIG_1(arg2 int) (_swig_ret BtElement) { + var swig_r BtElement + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtElement)(SwigcptrBtElement(C._wrap_btUnionFind_getElement__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (p SwigcptrBtUnionFind) GetElement(a ...interface{}) interface{} { + argc := len(a) + if argc == 1 { + return p.GetElement__SWIG_0(a[0].(int)) + } + if argc == 1 { + return p.GetElement__SWIG_1(a[0].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtUnionFind) Allocate(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btUnionFind_allocate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtUnionFind) Free() { + _swig_i_0 := arg1 + C._wrap_btUnionFind_Free_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtUnionFind) Find__SWIG_0(arg2 int, arg3 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (int)(C._wrap_btUnionFind_find__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtUnionFind) Unite(arg2 int, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btUnionFind_unite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtUnionFind) Find__SWIG_1(arg2 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (int)(C._wrap_btUnionFind_find__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (p SwigcptrBtUnionFind) Find(a ...interface{}) int { + argc := len(a) + if argc == 1 { + return p.Find__SWIG_1(a[0].(int)) + } + if argc == 2 { + return p.Find__SWIG_0(a[0].(int), a[1].(int)) + } + panic("No match for overloaded function call") +} + +type BtUnionFind interface { + Swigcptr() uintptr + SwigIsBtUnionFind() + SortIslands() + Reset(arg2 int) + GetNumElements() (_swig_ret int) + IsRoot(arg2 int) (_swig_ret bool) + GetElement(a ...interface{}) interface{} + Allocate(arg2 int) + Free() + Unite(arg2 int, arg3 int) + Find(a ...interface{}) int +} + +type SwigcptrBtSimulationIslandManager uintptr + +func (p SwigcptrBtSimulationIslandManager) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSimulationIslandManager) SwigIsBtSimulationIslandManager() { +} + +func NewBtSimulationIslandManager() (_swig_ret BtSimulationIslandManager) { + var swig_r BtSimulationIslandManager + swig_r = (BtSimulationIslandManager)(SwigcptrBtSimulationIslandManager(C._wrap_new_btSimulationIslandManager_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtSimulationIslandManager(arg1 BtSimulationIslandManager) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSimulationIslandManager_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSimulationIslandManager) InitUnionFind(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSimulationIslandManager_initUnionFind_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSimulationIslandManager) GetUnionFind() (_swig_ret BtUnionFind) { + var swig_r BtUnionFind + _swig_i_0 := arg1 + swig_r = (BtUnionFind)(SwigcptrBtUnionFind(C._wrap_btSimulationIslandManager_getUnionFind_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSimulationIslandManager) UpdateActivationState(arg2 BtCollisionWorld, arg3 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSimulationIslandManager_updateActivationState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSimulationIslandManager) StoreIslandActivationState(arg2 BtCollisionWorld) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSimulationIslandManager_storeIslandActivationState_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSimulationIslandManager) FindUnions(arg2 BtDispatcher, arg3 BtCollisionWorld) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSimulationIslandManager_findUnions_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSimulationIslandManager) BuildAndProcessIslands(arg2 BtDispatcher, arg3 BtCollisionWorld, arg4 BtSimulationIslandManager_IslandCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btSimulationIslandManager_buildAndProcessIslands_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtSimulationIslandManager) BuildIslands(arg2 BtDispatcher, arg3 BtCollisionWorld) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSimulationIslandManager_buildIslands_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSimulationIslandManager) ProcessIslands(arg2 BtDispatcher, arg3 BtCollisionWorld, arg4 BtSimulationIslandManager_IslandCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btSimulationIslandManager_processIslands_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtSimulationIslandManager) GetSplitIslands() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btSimulationIslandManager_getSplitIslands_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSimulationIslandManager) SetSplitIslands(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSimulationIslandManager_setSplitIslands_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +type BtSimulationIslandManager interface { + Swigcptr() uintptr + SwigIsBtSimulationIslandManager() + InitUnionFind(arg2 int) + GetUnionFind() (_swig_ret BtUnionFind) + UpdateActivationState(arg2 BtCollisionWorld, arg3 BtDispatcher) + StoreIslandActivationState(arg2 BtCollisionWorld) + FindUnions(arg2 BtDispatcher, arg3 BtCollisionWorld) + BuildAndProcessIslands(arg2 BtDispatcher, arg3 BtCollisionWorld, arg4 BtSimulationIslandManager_IslandCallback) + BuildIslands(arg2 BtDispatcher, arg3 BtCollisionWorld) + ProcessIslands(arg2 BtDispatcher, arg3 BtCollisionWorld, arg4 BtSimulationIslandManager_IslandCallback) + GetSplitIslands() (_swig_ret bool) + SetSplitIslands(arg2 bool) +} + +type BtConstraintSolverType int + +func _swig_getBT_SEQUENTIAL_IMPULSE_SOLVER() (_swig_ret BtConstraintSolverType) { + var swig_r BtConstraintSolverType + swig_r = (BtConstraintSolverType)(C._wrap_BT_SEQUENTIAL_IMPULSE_SOLVER_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_SEQUENTIAL_IMPULSE_SOLVER BtConstraintSolverType = _swig_getBT_SEQUENTIAL_IMPULSE_SOLVER() + +func _swig_getBT_MLCP_SOLVER() (_swig_ret BtConstraintSolverType) { + var swig_r BtConstraintSolverType + swig_r = (BtConstraintSolverType)(C._wrap_BT_MLCP_SOLVER_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_MLCP_SOLVER BtConstraintSolverType = _swig_getBT_MLCP_SOLVER() + +func _swig_getBT_NNCG_SOLVER() (_swig_ret BtConstraintSolverType) { + var swig_r BtConstraintSolverType + swig_r = (BtConstraintSolverType)(C._wrap_BT_NNCG_SOLVER_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_NNCG_SOLVER BtConstraintSolverType = _swig_getBT_NNCG_SOLVER() + +func _swig_getBT_MULTIBODY_SOLVER() (_swig_ret BtConstraintSolverType) { + var swig_r BtConstraintSolverType + swig_r = (BtConstraintSolverType)(C._wrap_BT_MULTIBODY_SOLVER_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_MULTIBODY_SOLVER BtConstraintSolverType = _swig_getBT_MULTIBODY_SOLVER() + +func _swig_getBT_BLOCK_SOLVER() (_swig_ret BtConstraintSolverType) { + var swig_r BtConstraintSolverType + swig_r = (BtConstraintSolverType)(C._wrap_BT_BLOCK_SOLVER_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_BLOCK_SOLVER BtConstraintSolverType = _swig_getBT_BLOCK_SOLVER() + +type SwigcptrBtConstraintSolver uintptr + +func (p SwigcptrBtConstraintSolver) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConstraintSolver) SwigIsBtConstraintSolver() { +} + +func DeleteBtConstraintSolver(arg1 BtConstraintSolver) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConstraintSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConstraintSolver) PrepareSolve(arg2 int, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btConstraintSolver_prepareSolve_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtConstraintSolver) SolveGroup(arg2 BtCollisionObject, arg3 int, arg4 BtPersistentManifold, arg5 int, arg6 BtTypedConstraint, arg7 int, arg8 BtContactSolverInfo, arg9 BtIDebugDraw, arg10 BtDispatcher) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := arg7 + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := getSwigcptr(arg10) + swig_r = (float32)(C._wrap_btConstraintSolver_solveGroup_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_intgo(_swig_i_4), C.uintptr_t(_swig_i_5), C.swig_intgo(_swig_i_6), C.uintptr_t(_swig_i_7), C.uintptr_t(_swig_i_8), C.uintptr_t(_swig_i_9))) + return swig_r +} + +func (arg1 SwigcptrBtConstraintSolver) AllSolved(arg2 BtContactSolverInfo, arg3 BtIDebugDraw) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btConstraintSolver_allSolved_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtConstraintSolver) Reset() { + _swig_i_0 := arg1 + C._wrap_btConstraintSolver_reset_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConstraintSolver) GetSolverType() (_swig_ret BtConstraintSolverType) { + var swig_r BtConstraintSolverType + _swig_i_0 := arg1 + swig_r = (BtConstraintSolverType)(C._wrap_btConstraintSolver_getSolverType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +type BtConstraintSolver interface { + Swigcptr() uintptr + SwigIsBtConstraintSolver() + PrepareSolve(arg2 int, arg3 int) + SolveGroup(arg2 BtCollisionObject, arg3 int, arg4 BtPersistentManifold, arg5 int, arg6 BtTypedConstraint, arg7 int, arg8 BtContactSolverInfo, arg9 BtIDebugDraw, arg10 BtDispatcher) (_swig_ret float32) + AllSolved(arg2 BtContactSolverInfo, arg3 BtIDebugDraw) + Reset() + GetSolverType() (_swig_ret BtConstraintSolverType) +} + +type SwigcptrBtSolverAnalyticsData uintptr + +func (p SwigcptrBtSolverAnalyticsData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSolverAnalyticsData) SwigIsBtSolverAnalyticsData() { +} + +func NewBtSolverAnalyticsData() (_swig_ret BtSolverAnalyticsData) { + var swig_r BtSolverAnalyticsData + swig_r = (BtSolverAnalyticsData)(SwigcptrBtSolverAnalyticsData(C._wrap_new_btSolverAnalyticsData_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtSolverAnalyticsData) SetM_islandId(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverAnalyticsData_m_islandId_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverAnalyticsData) GetM_islandId() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSolverAnalyticsData_m_islandId_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverAnalyticsData) SetM_numBodies(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverAnalyticsData_m_numBodies_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverAnalyticsData) GetM_numBodies() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSolverAnalyticsData_m_numBodies_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverAnalyticsData) SetM_numContactManifolds(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverAnalyticsData_m_numContactManifolds_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverAnalyticsData) GetM_numContactManifolds() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSolverAnalyticsData_m_numContactManifolds_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverAnalyticsData) SetM_numSolverCalls(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverAnalyticsData_m_numSolverCalls_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverAnalyticsData) GetM_numSolverCalls() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSolverAnalyticsData_m_numSolverCalls_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverAnalyticsData) SetM_numIterationsUsed(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverAnalyticsData_m_numIterationsUsed_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverAnalyticsData) GetM_numIterationsUsed() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSolverAnalyticsData_m_numIterationsUsed_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSolverAnalyticsData) SetM_remainingLeastSquaresResidual(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSolverAnalyticsData_m_remainingLeastSquaresResidual_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtSolverAnalyticsData) GetM_remainingLeastSquaresResidual() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btSolverAnalyticsData_m_remainingLeastSquaresResidual_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtSolverAnalyticsData(arg1 BtSolverAnalyticsData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSolverAnalyticsData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtSolverAnalyticsData interface { + Swigcptr() uintptr + SwigIsBtSolverAnalyticsData() + SetM_islandId(arg2 int) + GetM_islandId() (_swig_ret int) + SetM_numBodies(arg2 int) + GetM_numBodies() (_swig_ret int) + SetM_numContactManifolds(arg2 int) + GetM_numContactManifolds() (_swig_ret int) + SetM_numSolverCalls(arg2 int) + GetM_numSolverCalls() (_swig_ret int) + SetM_numIterationsUsed(arg2 int) + GetM_numIterationsUsed() (_swig_ret int) + SetM_remainingLeastSquaresResidual(arg2 float64) + GetM_remainingLeastSquaresResidual() (_swig_ret float64) +} + +type SwigcptrBtSequentialImpulseConstraintSolver uintptr + +func (p SwigcptrBtSequentialImpulseConstraintSolver) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSequentialImpulseConstraintSolver) SwigIsBtSequentialImpulseConstraintSolver() { +} + +func NewBtSequentialImpulseConstraintSolver() (_swig_ret BtSequentialImpulseConstraintSolver) { + var swig_r BtSequentialImpulseConstraintSolver + swig_r = (BtSequentialImpulseConstraintSolver)(SwigcptrBtSequentialImpulseConstraintSolver(C._wrap_new_btSequentialImpulseConstraintSolver_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtSequentialImpulseConstraintSolver(arg1 BtSequentialImpulseConstraintSolver) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSequentialImpulseConstraintSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) SolveGroup(arg2 BtCollisionObject, arg3 int, arg4 BtPersistentManifold, arg5 int, arg6 BtTypedConstraint, arg7 int, arg8 BtContactSolverInfo, arg9 BtIDebugDraw, arg10 BtDispatcher) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := arg7 + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := getSwigcptr(arg10) + swig_r = (float32)(C._wrap_btSequentialImpulseConstraintSolver_solveGroup_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_intgo(_swig_i_4), C.uintptr_t(_swig_i_5), C.swig_intgo(_swig_i_6), C.uintptr_t(_swig_i_7), C.uintptr_t(_swig_i_8), C.uintptr_t(_swig_i_9))) + return swig_r +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) Reset() { + _swig_i_0 := arg1 + C._wrap_btSequentialImpulseConstraintSolver_reset_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) BtRand2() (_swig_ret uint64) { + var swig_r uint64 + _swig_i_0 := arg1 + swig_r = (uint64)(C._wrap_btSequentialImpulseConstraintSolver_btRand2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) BtRandInt2(arg2 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (int)(C._wrap_btSequentialImpulseConstraintSolver_btRandInt2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) SetRandSeed(arg2 uint64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSequentialImpulseConstraintSolver_setRandSeed_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_147(_swig_i_1)) +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) GetRandSeed() (_swig_ret uint64) { + var swig_r uint64 + _swig_i_0 := arg1 + swig_r = (uint64)(C._wrap_btSequentialImpulseConstraintSolver_getRandSeed_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) GetSolverType() (_swig_ret BtConstraintSolverType) { + var swig_r BtConstraintSolverType + _swig_i_0 := arg1 + swig_r = (BtConstraintSolverType)(C._wrap_btSequentialImpulseConstraintSolver_getSolverType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) GetActiveConstraintRowSolverGeneric() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + _swig_i_0 := arg1 + swig_r = (_swig_fnptr)(C._wrap_btSequentialImpulseConstraintSolver_getActiveConstraintRowSolverGeneric_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) SetConstraintRowSolverGeneric(arg2 _swig_fnptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSequentialImpulseConstraintSolver_setConstraintRowSolverGeneric_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_150(_swig_i_1)) +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) GetActiveConstraintRowSolverLowerLimit() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + _swig_i_0 := arg1 + swig_r = (_swig_fnptr)(C._wrap_btSequentialImpulseConstraintSolver_getActiveConstraintRowSolverLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) SetConstraintRowSolverLowerLimit(arg2 _swig_fnptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSequentialImpulseConstraintSolver_setConstraintRowSolverLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_152(_swig_i_1)) +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) GetScalarConstraintRowSolverGeneric() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + _swig_i_0 := arg1 + swig_r = (_swig_fnptr)(C._wrap_btSequentialImpulseConstraintSolver_getScalarConstraintRowSolverGeneric_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) GetScalarConstraintRowSolverLowerLimit() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + _swig_i_0 := arg1 + swig_r = (_swig_fnptr)(C._wrap_btSequentialImpulseConstraintSolver_getScalarConstraintRowSolverLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) SetM_analyticsData(arg2 BtSolverAnalyticsData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSequentialImpulseConstraintSolver_m_analyticsData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSequentialImpulseConstraintSolver) GetM_analyticsData() (_swig_ret BtSolverAnalyticsData) { + var swig_r BtSolverAnalyticsData + _swig_i_0 := arg1 + swig_r = (BtSolverAnalyticsData)(SwigcptrBtSolverAnalyticsData(C._wrap_btSequentialImpulseConstraintSolver_m_analyticsData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtSequentialImpulseConstraintSolver) PrepareSolve(arg1 int, arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSequentialImpulseConstraintSolver_prepareSolve_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (_swig_base SwigcptrBtSequentialImpulseConstraintSolver) AllSolved(arg1 BtContactSolverInfo, arg2 BtIDebugDraw) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSequentialImpulseConstraintSolver_allSolved_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtSequentialImpulseConstraintSolver) SwigIsBtConstraintSolver() { +} + +func (p SwigcptrBtSequentialImpulseConstraintSolver) SwigGetBtConstraintSolver() BtConstraintSolver { + return SwigcptrBtConstraintSolver(getSwigcptr(p)) +} + +type BtSequentialImpulseConstraintSolver interface { + Swigcptr() uintptr + SwigIsBtSequentialImpulseConstraintSolver() + SolveGroup(arg2 BtCollisionObject, arg3 int, arg4 BtPersistentManifold, arg5 int, arg6 BtTypedConstraint, arg7 int, arg8 BtContactSolverInfo, arg9 BtIDebugDraw, arg10 BtDispatcher) (_swig_ret float32) + Reset() + BtRand2() (_swig_ret uint64) + BtRandInt2(arg2 int) (_swig_ret int) + SetRandSeed(arg2 uint64) + GetRandSeed() (_swig_ret uint64) + GetSolverType() (_swig_ret BtConstraintSolverType) + GetActiveConstraintRowSolverGeneric() (_swig_ret _swig_fnptr) + SetConstraintRowSolverGeneric(arg2 _swig_fnptr) + GetActiveConstraintRowSolverLowerLimit() (_swig_ret _swig_fnptr) + SetConstraintRowSolverLowerLimit(arg2 _swig_fnptr) + GetScalarConstraintRowSolverGeneric() (_swig_ret _swig_fnptr) + GetScalarConstraintRowSolverLowerLimit() (_swig_ret _swig_fnptr) + SetM_analyticsData(arg2 BtSolverAnalyticsData) + GetM_analyticsData() (_swig_ret BtSolverAnalyticsData) + PrepareSolve(arg1 int, arg2 int) + AllSolved(arg1 BtContactSolverInfo, arg2 BtIDebugDraw) + SwigIsBtConstraintSolver() + SwigGetBtConstraintSolver() BtConstraintSolver +} + +const BtConeTwistConstraintDataName string = "btConeTwistConstraintData" + +type BtConeTwistFlags int + +func _swig_getBT_CONETWIST_FLAGS_LIN_CFM() (_swig_ret BtConeTwistFlags) { + var swig_r BtConeTwistFlags + swig_r = (BtConeTwistFlags)(C._wrap_BT_CONETWIST_FLAGS_LIN_CFM_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONETWIST_FLAGS_LIN_CFM BtConeTwistFlags = _swig_getBT_CONETWIST_FLAGS_LIN_CFM() + +func _swig_getBT_CONETWIST_FLAGS_LIN_ERP() (_swig_ret BtConeTwistFlags) { + var swig_r BtConeTwistFlags + swig_r = (BtConeTwistFlags)(C._wrap_BT_CONETWIST_FLAGS_LIN_ERP_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONETWIST_FLAGS_LIN_ERP BtConeTwistFlags = _swig_getBT_CONETWIST_FLAGS_LIN_ERP() + +func _swig_getBT_CONETWIST_FLAGS_ANG_CFM() (_swig_ret BtConeTwistFlags) { + var swig_r BtConeTwistFlags + swig_r = (BtConeTwistFlags)(C._wrap_BT_CONETWIST_FLAGS_ANG_CFM_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_CONETWIST_FLAGS_ANG_CFM BtConeTwistFlags = _swig_getBT_CONETWIST_FLAGS_ANG_CFM() + +type SwigcptrBtConeTwistConstraint uintptr + +func (p SwigcptrBtConeTwistConstraint) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConeTwistConstraint) SwigIsBtConeTwistConstraint() { +} + +func NewBtConeTwistConstraint__SWIG_0(arg1 BtRigidBody, arg2 BtRigidBody, arg3 BtTransform, arg4 BtTransform) (_swig_ret BtConeTwistConstraint) { + var swig_r BtConeTwistConstraint + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtConeTwistConstraint)(SwigcptrBtConeTwistConstraint(C._wrap_new_btConeTwistConstraint__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func NewBtConeTwistConstraint__SWIG_1(arg1 BtRigidBody, arg2 BtTransform) (_swig_ret BtConeTwistConstraint) { + var swig_r BtConeTwistConstraint + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtConeTwistConstraint)(SwigcptrBtConeTwistConstraint(C._wrap_new_btConeTwistConstraint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func NewBtConeTwistConstraint(a ...interface{}) BtConeTwistConstraint { + argc := len(a) + if argc == 2 { + return NewBtConeTwistConstraint__SWIG_1(a[0].(BtRigidBody), a[1].(BtTransform)) + } + if argc == 4 { + return NewBtConeTwistConstraint__SWIG_0(a[0].(BtRigidBody), a[1].(BtRigidBody), a[2].(BtTransform), a[3].(BtTransform)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtConeTwistConstraint) BuildJacobian() { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_buildJacobian_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetInfo1(arg2 BtTypedConstraint_btConstraintInfo1) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraint_getInfo1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetInfo1NonVirtual(arg2 BtTypedConstraint_btConstraintInfo1) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraint_getInfo1NonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetInfo2(arg2 BtTypedConstraint_btConstraintInfo2) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraint_getInfo2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetInfo2NonVirtual(arg2 BtTypedConstraint_btConstraintInfo2, arg3 BtTransform, arg4 BtTransform, arg5 BtMatrix3x3, arg6 BtMatrix3x3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btConeTwistConstraint_getInfo2NonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) SolveConstraintObsolete(arg2 BtSolverBody, arg3 BtSolverBody, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btConeTwistConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) UpdateRHS(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraint_updateRHS_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetRigidBodyA() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := arg1 + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btConeTwistConstraint_getRigidBodyA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetRigidBodyB() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + _swig_i_0 := arg1 + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btConeTwistConstraint_getRigidBodyB_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetAngularOnly(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraint_setAngularOnly_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetAngularOnly() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btConeTwistConstraint_getAngularOnly_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetLimit__SWIG_0(arg2 int, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btConeTwistConstraint_setLimit__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetLimit(arg2 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetLimit__SWIG_1(arg2 float32, arg3 float32, arg4 float32, arg5 float32, arg6 float32, arg7 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + C._wrap_btConeTwistConstraint_setLimit__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetLimit__SWIG_2(arg2 float32, arg3 float32, arg4 float32, arg5 float32, arg6 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + C._wrap_btConeTwistConstraint_setLimit__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetLimit__SWIG_3(arg2 float32, arg3 float32, arg4 float32, arg5 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_btConeTwistConstraint_setLimit__SWIG_3_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3), C.float(_swig_i_4)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetLimit__SWIG_4(arg2 float32, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btConeTwistConstraint_setLimit__SWIG_4_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (p SwigcptrBtConeTwistConstraint) SetLimit(a ...interface{}) { + argc := len(a) + if argc == 2 { + p.SetLimit__SWIG_0(a[0].(int), a[1].(float32)) + return + } + if argc == 3 { + p.SetLimit__SWIG_4(a[0].(float32), a[1].(float32), a[2].(float32)) + return + } + if argc == 4 { + p.SetLimit__SWIG_3(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32)) + return + } + if argc == 5 { + p.SetLimit__SWIG_2(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32), a[4].(float32)) + return + } + if argc == 6 { + p.SetLimit__SWIG_1(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32), a[4].(float32), a[5].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetAFrame() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btConeTwistConstraint_getAFrame_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetBFrame() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btConeTwistConstraint_getBFrame_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetSolveTwistLimit() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btConeTwistConstraint_getSolveTwistLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetSolveSwingLimit() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btConeTwistConstraint_getSolveSwingLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetTwistLimitSign() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getTwistLimitSign_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) CalcAngleInfo() { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_calcAngleInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) CalcAngleInfo2(arg2 BtTransform, arg3 BtTransform, arg4 BtMatrix3x3, arg5 BtMatrix3x3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btConeTwistConstraint_calcAngleInfo2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetSwingSpan1() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getSwingSpan1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetSwingSpan2() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getSwingSpan2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetTwistSpan() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getTwistSpan_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetLimitSoftness() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getLimitSoftness_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetBiasFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getBiasFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetRelaxationFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getRelaxationFactor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetTwistAngle() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getTwistAngle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) IsPastSwingLimit() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btConeTwistConstraint_isPastSwingLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetDamping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetDamping(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraint_setDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) EnableMotor(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraint_enableMotor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) IsMotorEnabled() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btConeTwistConstraint_isMotorEnabled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetMaxMotorImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getMaxMotorImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) IsMaxMotorImpulseNormalized() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btConeTwistConstraint_isMaxMotorImpulseNormalized_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetMaxMotorImpulse(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraint_setMaxMotorImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetMaxMotorImpulseNormalized(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraint_setMaxMotorImpulseNormalized_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetFixThresh() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getFixThresh_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetFixThresh(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraint_setFixThresh_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetMotorTarget(arg2 BtQuaternion) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraint_setMotorTarget_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetMotorTarget() (_swig_ret BtQuaternion) { + var swig_r BtQuaternion + _swig_i_0 := arg1 + swig_r = (BtQuaternion)(SwigcptrBtQuaternion(C._wrap_btConeTwistConstraint_getMotorTarget_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetMotorTargetInConstraintSpace(arg2 BtQuaternion) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraint_setMotorTargetInConstraintSpace_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetPointForAngle(arg2 float32, arg3 float32) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConeTwistConstraint_GetPointForAngle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetParam__SWIG_0(arg2 int, arg3 float32, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btConeTwistConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetParam__SWIG_1(arg2 int, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btConeTwistConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2)) +} + +func (p SwigcptrBtConeTwistConstraint) SetParam(a ...interface{}) { + argc := len(a) + if argc == 2 { + p.SetParam__SWIG_1(a[0].(int), a[1].(float32)) + return + } + if argc == 3 { + p.SetParam__SWIG_0(a[0].(int), a[1].(float32), a[2].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtConeTwistConstraint) SetFrames(arg2 BtTransform, arg3 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btConeTwistConstraint_setFrames_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetFrameOffsetA() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btConeTwistConstraint_getFrameOffsetA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetFrameOffsetB() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btConeTwistConstraint_getFrameOffsetB_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetParam__SWIG_0(arg2 int, arg3 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetParam__SWIG_1(arg2 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (p SwigcptrBtConeTwistConstraint) GetParam(a ...interface{}) float32 { + argc := len(a) + if argc == 1 { + return p.GetParam__SWIG_1(a[0].(int)) + } + if argc == 2 { + return p.GetParam__SWIG_0(a[0].(int), a[1].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtConeTwistConstraint) GetFlags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btConeTwistConstraint_getFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btConeTwistConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraint) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btConeTwistConstraint_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func DeleteBtConeTwistConstraint(arg1 BtConeTwistConstraint) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConeTwistConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func BtConeTwistConstraintGetFixedBody() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btConeTwistConstraint_getFixedBody_mbt_e879218550ba2e2b())) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetOverrideNumSolverIterations() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConeTwistConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) SetOverrideNumSolverIterations(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) SetupSolverConstraint(arg1 BtAlignedObjectArray_Sl_btSolverConstraint_Sg_, arg2 int, arg3 int, arg4 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btConeTwistConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.float(_swig_i_3)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) InternalSetAppliedImpulse(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) InternalGetAppliedImpulse() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConeTwistConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetBreakingImpulseThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) SetBreakingImpulseThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) IsEnabled() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConeTwistConstraint_isEnabled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) SetEnabled(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_setEnabled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetUserConstraintType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConeTwistConstraint_getUserConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) SetUserConstraintType(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_setUserConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) SetUserConstraintId(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_setUserConstraintId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetUserConstraintId() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConeTwistConstraint_getUserConstraintId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) SetUserConstraintPtr(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetUserConstraintPtr() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btConeTwistConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) SetJointFeedback(arg1 BtJointFeedback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btConeTwistConstraint_setJointFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetJointFeedback__SWIG_0() (_swig_ret BtJointFeedback) { + var swig_r BtJointFeedback + swig_r = (BtJointFeedback)(SwigcptrBtJointFeedback(C._wrap_btConeTwistConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetJointFeedback__SWIG_1() (_swig_ret BtJointFeedback) { + var swig_r BtJointFeedback + swig_r = (BtJointFeedback)(SwigcptrBtJointFeedback(C._wrap_btConeTwistConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtConeTwistConstraint) GetJointFeedback(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetJointFeedback__SWIG_0() + } + if argc == 0 { + return p.GetJointFeedback__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetUid() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConeTwistConstraint_getUid_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) NeedsFeedback() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btConeTwistConstraint_needsFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) EnableFeedback(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_enableFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetAppliedImpulse() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetConstraintType() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_btConeTwistConstraint_getConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) SetDbgDrawSize(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btConeTwistConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetDbgDrawSize() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btConeTwistConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) SetM_objectType(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtConeTwistConstraint_M_objectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetM_objectType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtConeTwistConstraint_M_objectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtConeTwistConstraint) GetObjectType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btConeTwistConstraint_getObjectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtConeTwistConstraint) SwigIsBtTypedConstraint() { +} + +func (p SwigcptrBtConeTwistConstraint) SwigGetBtTypedConstraint() BtTypedConstraint { + return SwigcptrBtTypedConstraint(getSwigcptr(p)) +} + +func (p SwigcptrBtConeTwistConstraint) SwigIsBtTypedObject() { +} + +func (p SwigcptrBtConeTwistConstraint) SwigGetBtTypedObject() BtTypedObject { + return SwigcptrBtTypedObject(getSwigcptr(p)) +} + +type BtConeTwistConstraint interface { + Swigcptr() uintptr + SwigIsBtConeTwistConstraint() + BuildJacobian() + GetInfo1(arg2 BtTypedConstraint_btConstraintInfo1) + GetInfo1NonVirtual(arg2 BtTypedConstraint_btConstraintInfo1) + GetInfo2(arg2 BtTypedConstraint_btConstraintInfo2) + GetInfo2NonVirtual(arg2 BtTypedConstraint_btConstraintInfo2, arg3 BtTransform, arg4 BtTransform, arg5 BtMatrix3x3, arg6 BtMatrix3x3) + SolveConstraintObsolete(arg2 BtSolverBody, arg3 BtSolverBody, arg4 float32) + UpdateRHS(arg2 float32) + GetRigidBodyA() (_swig_ret BtRigidBody) + GetRigidBodyB() (_swig_ret BtRigidBody) + SetAngularOnly(arg2 bool) + GetAngularOnly() (_swig_ret bool) + GetLimit(arg2 int) (_swig_ret float32) + SetLimit(a ...interface{}) + GetAFrame() (_swig_ret BtTransform) + GetBFrame() (_swig_ret BtTransform) + GetSolveTwistLimit() (_swig_ret int) + GetSolveSwingLimit() (_swig_ret int) + GetTwistLimitSign() (_swig_ret float32) + CalcAngleInfo() + CalcAngleInfo2(arg2 BtTransform, arg3 BtTransform, arg4 BtMatrix3x3, arg5 BtMatrix3x3) + GetSwingSpan1() (_swig_ret float32) + GetSwingSpan2() (_swig_ret float32) + GetTwistSpan() (_swig_ret float32) + GetLimitSoftness() (_swig_ret float32) + GetBiasFactor() (_swig_ret float32) + GetRelaxationFactor() (_swig_ret float32) + GetTwistAngle() (_swig_ret float32) + IsPastSwingLimit() (_swig_ret bool) + GetDamping() (_swig_ret float32) + SetDamping(arg2 float32) + EnableMotor(arg2 bool) + IsMotorEnabled() (_swig_ret bool) + GetMaxMotorImpulse() (_swig_ret float32) + IsMaxMotorImpulseNormalized() (_swig_ret bool) + SetMaxMotorImpulse(arg2 float32) + SetMaxMotorImpulseNormalized(arg2 float32) + GetFixThresh() (_swig_ret float32) + SetFixThresh(arg2 float32) + SetMotorTarget(arg2 BtQuaternion) + GetMotorTarget() (_swig_ret BtQuaternion) + SetMotorTargetInConstraintSpace(arg2 BtQuaternion) + GetPointForAngle(arg2 float32, arg3 float32) (_swig_ret BtVector3) + SetParam(a ...interface{}) + SetFrames(arg2 BtTransform, arg3 BtTransform) + GetFrameOffsetA() (_swig_ret BtTransform) + GetFrameOffsetB() (_swig_ret BtTransform) + GetParam(a ...interface{}) float32 + GetFlags() (_swig_ret int) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + GetOverrideNumSolverIterations() (_swig_ret int) + SetOverrideNumSolverIterations(arg1 int) + SetupSolverConstraint(arg1 BtAlignedObjectArray_Sl_btSolverConstraint_Sg_, arg2 int, arg3 int, arg4 float32) + InternalSetAppliedImpulse(arg1 float32) + InternalGetAppliedImpulse() (_swig_ret float32) + GetBreakingImpulseThreshold() (_swig_ret float32) + SetBreakingImpulseThreshold(arg1 float32) + IsEnabled() (_swig_ret bool) + SetEnabled(arg1 bool) + GetUserConstraintType() (_swig_ret int) + SetUserConstraintType(arg1 int) + SetUserConstraintId(arg1 int) + GetUserConstraintId() (_swig_ret int) + SetUserConstraintPtr(arg1 uintptr) + GetUserConstraintPtr() (_swig_ret uintptr) + SetJointFeedback(arg1 BtJointFeedback) + GetJointFeedback(a ...interface{}) interface{} + GetUid() (_swig_ret int) + NeedsFeedback() (_swig_ret bool) + EnableFeedback(arg1 bool) + GetAppliedImpulse() (_swig_ret float32) + GetConstraintType() (_swig_ret BtTypedConstraintType) + SetDbgDrawSize(arg1 float32) + GetDbgDrawSize() (_swig_ret float32) + SetM_objectType(arg1 int) + GetM_objectType() (_swig_ret int) + GetObjectType() (_swig_ret int) + SwigIsBtTypedConstraint() + SwigGetBtTypedConstraint() BtTypedConstraint + SwigIsBtTypedObject() + SwigGetBtTypedObject() BtTypedObject +} + +type SwigcptrBtConeTwistConstraintDoubleData uintptr + +func (p SwigcptrBtConeTwistConstraintDoubleData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConeTwistConstraintDoubleData) SwigIsBtConeTwistConstraintDoubleData() { +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) SetM_typeConstraintData(arg2 BtTypedConstraintDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraintDoubleData_m_typeConstraintData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) GetM_typeConstraintData() (_swig_ret BtTypedConstraintDoubleData) { + var swig_r BtTypedConstraintDoubleData + _swig_i_0 := arg1 + swig_r = (BtTypedConstraintDoubleData)(SwigcptrBtTypedConstraintDoubleData(C._wrap_btConeTwistConstraintDoubleData_m_typeConstraintData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) SetM_rbAFrame(arg2 BtTransformDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraintDoubleData_m_rbAFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) GetM_rbAFrame() (_swig_ret BtTransformDoubleData) { + var swig_r BtTransformDoubleData + _swig_i_0 := arg1 + swig_r = (BtTransformDoubleData)(SwigcptrBtTransformDoubleData(C._wrap_btConeTwistConstraintDoubleData_m_rbAFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) SetM_rbBFrame(arg2 BtTransformDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraintDoubleData_m_rbBFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) GetM_rbBFrame() (_swig_ret BtTransformDoubleData) { + var swig_r BtTransformDoubleData + _swig_i_0 := arg1 + swig_r = (BtTransformDoubleData)(SwigcptrBtTransformDoubleData(C._wrap_btConeTwistConstraintDoubleData_m_rbBFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) SetM_swingSpan1(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintDoubleData_m_swingSpan1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) GetM_swingSpan1() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btConeTwistConstraintDoubleData_m_swingSpan1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) SetM_swingSpan2(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintDoubleData_m_swingSpan2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) GetM_swingSpan2() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btConeTwistConstraintDoubleData_m_swingSpan2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) SetM_twistSpan(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintDoubleData_m_twistSpan_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) GetM_twistSpan() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btConeTwistConstraintDoubleData_m_twistSpan_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) SetM_limitSoftness(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintDoubleData_m_limitSoftness_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) GetM_limitSoftness() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btConeTwistConstraintDoubleData_m_limitSoftness_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) SetM_biasFactor(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintDoubleData_m_biasFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) GetM_biasFactor() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btConeTwistConstraintDoubleData_m_biasFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) SetM_relaxationFactor(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintDoubleData_m_relaxationFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) GetM_relaxationFactor() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btConeTwistConstraintDoubleData_m_relaxationFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) SetM_damping(arg2 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintDoubleData_m_damping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.double(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintDoubleData) GetM_damping() (_swig_ret float64) { + var swig_r float64 + _swig_i_0 := arg1 + swig_r = (float64)(C._wrap_btConeTwistConstraintDoubleData_m_damping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtConeTwistConstraintDoubleData() (_swig_ret BtConeTwistConstraintDoubleData) { + var swig_r BtConeTwistConstraintDoubleData + swig_r = (BtConeTwistConstraintDoubleData)(SwigcptrBtConeTwistConstraintDoubleData(C._wrap_new_btConeTwistConstraintDoubleData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtConeTwistConstraintDoubleData(arg1 BtConeTwistConstraintDoubleData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConeTwistConstraintDoubleData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtConeTwistConstraintDoubleData interface { + Swigcptr() uintptr + SwigIsBtConeTwistConstraintDoubleData() + SetM_typeConstraintData(arg2 BtTypedConstraintDoubleData) + GetM_typeConstraintData() (_swig_ret BtTypedConstraintDoubleData) + SetM_rbAFrame(arg2 BtTransformDoubleData) + GetM_rbAFrame() (_swig_ret BtTransformDoubleData) + SetM_rbBFrame(arg2 BtTransformDoubleData) + GetM_rbBFrame() (_swig_ret BtTransformDoubleData) + SetM_swingSpan1(arg2 float64) + GetM_swingSpan1() (_swig_ret float64) + SetM_swingSpan2(arg2 float64) + GetM_swingSpan2() (_swig_ret float64) + SetM_twistSpan(arg2 float64) + GetM_twistSpan() (_swig_ret float64) + SetM_limitSoftness(arg2 float64) + GetM_limitSoftness() (_swig_ret float64) + SetM_biasFactor(arg2 float64) + GetM_biasFactor() (_swig_ret float64) + SetM_relaxationFactor(arg2 float64) + GetM_relaxationFactor() (_swig_ret float64) + SetM_damping(arg2 float64) + GetM_damping() (_swig_ret float64) +} + +type SwigcptrBtConeTwistConstraintData uintptr + +func (p SwigcptrBtConeTwistConstraintData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConeTwistConstraintData) SwigIsBtConeTwistConstraintData() { +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_typeConstraintData(arg2 BtTypedConstraintData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraintData_m_typeConstraintData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_typeConstraintData() (_swig_ret BtTypedConstraintData) { + var swig_r BtTypedConstraintData + _swig_i_0 := arg1 + swig_r = (BtTypedConstraintData)(SwigcptrBtTypedConstraintData(C._wrap_btConeTwistConstraintData_m_typeConstraintData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_rbAFrame(arg2 BtTransformFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraintData_m_rbAFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_rbAFrame() (_swig_ret BtTransformFloatData) { + var swig_r BtTransformFloatData + _swig_i_0 := arg1 + swig_r = (BtTransformFloatData)(SwigcptrBtTransformFloatData(C._wrap_btConeTwistConstraintData_m_rbAFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_rbBFrame(arg2 BtTransformFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConeTwistConstraintData_m_rbBFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_rbBFrame() (_swig_ret BtTransformFloatData) { + var swig_r BtTransformFloatData + _swig_i_0 := arg1 + swig_r = (BtTransformFloatData)(SwigcptrBtTransformFloatData(C._wrap_btConeTwistConstraintData_m_rbBFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_swingSpan1(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintData_m_swingSpan1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_swingSpan1() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraintData_m_swingSpan1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_swingSpan2(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintData_m_swingSpan2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_swingSpan2() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraintData_m_swingSpan2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_twistSpan(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintData_m_twistSpan_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_twistSpan() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraintData_m_twistSpan_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_limitSoftness(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintData_m_limitSoftness_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_limitSoftness() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraintData_m_limitSoftness_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_biasFactor(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintData_m_biasFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_biasFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraintData_m_biasFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_relaxationFactor(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintData_m_relaxationFactor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_relaxationFactor() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraintData_m_relaxationFactor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_damping(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintData_m_damping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_damping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btConeTwistConstraintData_m_damping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConeTwistConstraintData) SetM_pad(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConeTwistConstraintData_m_pad_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_156)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtConeTwistConstraintData) GetM_pad() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btConeTwistConstraintData_m_pad_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtConeTwistConstraintData() (_swig_ret BtConeTwistConstraintData) { + var swig_r BtConeTwistConstraintData + swig_r = (BtConeTwistConstraintData)(SwigcptrBtConeTwistConstraintData(C._wrap_new_btConeTwistConstraintData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtConeTwistConstraintData(arg1 BtConeTwistConstraintData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConeTwistConstraintData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtConeTwistConstraintData interface { + Swigcptr() uintptr + SwigIsBtConeTwistConstraintData() + SetM_typeConstraintData(arg2 BtTypedConstraintData) + GetM_typeConstraintData() (_swig_ret BtTypedConstraintData) + SetM_rbAFrame(arg2 BtTransformFloatData) + GetM_rbAFrame() (_swig_ret BtTransformFloatData) + SetM_rbBFrame(arg2 BtTransformFloatData) + GetM_rbBFrame() (_swig_ret BtTransformFloatData) + SetM_swingSpan1(arg2 float32) + GetM_swingSpan1() (_swig_ret float32) + SetM_swingSpan2(arg2 float32) + GetM_swingSpan2() (_swig_ret float32) + SetM_twistSpan(arg2 float32) + GetM_twistSpan() (_swig_ret float32) + SetM_limitSoftness(arg2 float32) + GetM_limitSoftness() (_swig_ret float32) + SetM_biasFactor(arg2 float32) + GetM_biasFactor() (_swig_ret float32) + SetM_relaxationFactor(arg2 float32) + GetM_relaxationFactor() (_swig_ret float32) + SetM_damping(arg2 float32) + GetM_damping() (_swig_ret float32) + SetM_pad(arg2 string) + GetM_pad() (_swig_ret string) +} + +const BtGeneric6DofConstraintDataName string = "btGeneric6DofConstraintData" + +type SwigcptrBtRotationalLimitMotor uintptr + +func (p SwigcptrBtRotationalLimitMotor) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtRotationalLimitMotor) SwigIsBtRotationalLimitMotor() { +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_loLimit(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_loLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_loLimit() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_loLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_hiLimit(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_hiLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_hiLimit() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_hiLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_targetVelocity(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_targetVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_targetVelocity() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_targetVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_maxMotorForce(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_maxMotorForce_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_maxMotorForce() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_maxMotorForce_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_maxLimitForce(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_maxLimitForce_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_maxLimitForce() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_maxLimitForce_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_damping(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_damping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_damping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_damping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_limitSoftness(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_limitSoftness_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_limitSoftness() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_limitSoftness_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_normalCFM(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_normalCFM_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_normalCFM() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_normalCFM_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_stopERP(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_stopERP_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_stopERP() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_stopERP_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_stopCFM(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_stopCFM_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_stopCFM() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_stopCFM_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_bounce(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_bounce_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_bounce() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_bounce_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_enableMotor(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_enableMotor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_enableMotor() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btRotationalLimitMotor_m_enableMotor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_currentLimitError(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_currentLimitError_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_currentLimitError() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_currentLimitError_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_currentPosition(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_currentPosition_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_currentPosition() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_currentPosition_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_currentLimit(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_currentLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_currentLimit() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btRotationalLimitMotor_m_currentLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SetM_accumulatedImpulse(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btRotationalLimitMotor_m_accumulatedImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtRotationalLimitMotor) GetM_accumulatedImpulse() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btRotationalLimitMotor_m_accumulatedImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtRotationalLimitMotor__SWIG_0() (_swig_ret BtRotationalLimitMotor) { + var swig_r BtRotationalLimitMotor + swig_r = (BtRotationalLimitMotor)(SwigcptrBtRotationalLimitMotor(C._wrap_new_btRotationalLimitMotor__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtRotationalLimitMotor__SWIG_1(arg1 BtRotationalLimitMotor) (_swig_ret BtRotationalLimitMotor) { + var swig_r BtRotationalLimitMotor + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtRotationalLimitMotor)(SwigcptrBtRotationalLimitMotor(C._wrap_new_btRotationalLimitMotor__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtRotationalLimitMotor(a ...interface{}) BtRotationalLimitMotor { + argc := len(a) + if argc == 0 { + return NewBtRotationalLimitMotor__SWIG_0() + } + if argc == 1 { + return NewBtRotationalLimitMotor__SWIG_1(a[0].(BtRotationalLimitMotor)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtRotationalLimitMotor) IsLimited() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btRotationalLimitMotor_isLimited_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) NeedApplyTorques() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btRotationalLimitMotor_needApplyTorques_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) TestLimitValue(arg2 float32) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (int)(C._wrap_btRotationalLimitMotor_testLimitValue_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtRotationalLimitMotor) SolveAngularLimits(arg2 float32, arg3 BtVector3, arg4 float32, arg5 BtRigidBody, arg6 BtRigidBody) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (float32)(C._wrap_btRotationalLimitMotor_solveAngularLimits_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func DeleteBtRotationalLimitMotor(arg1 BtRotationalLimitMotor) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btRotationalLimitMotor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtRotationalLimitMotor interface { + Swigcptr() uintptr + SwigIsBtRotationalLimitMotor() + SetM_loLimit(arg2 float32) + GetM_loLimit() (_swig_ret float32) + SetM_hiLimit(arg2 float32) + GetM_hiLimit() (_swig_ret float32) + SetM_targetVelocity(arg2 float32) + GetM_targetVelocity() (_swig_ret float32) + SetM_maxMotorForce(arg2 float32) + GetM_maxMotorForce() (_swig_ret float32) + SetM_maxLimitForce(arg2 float32) + GetM_maxLimitForce() (_swig_ret float32) + SetM_damping(arg2 float32) + GetM_damping() (_swig_ret float32) + SetM_limitSoftness(arg2 float32) + GetM_limitSoftness() (_swig_ret float32) + SetM_normalCFM(arg2 float32) + GetM_normalCFM() (_swig_ret float32) + SetM_stopERP(arg2 float32) + GetM_stopERP() (_swig_ret float32) + SetM_stopCFM(arg2 float32) + GetM_stopCFM() (_swig_ret float32) + SetM_bounce(arg2 float32) + GetM_bounce() (_swig_ret float32) + SetM_enableMotor(arg2 bool) + GetM_enableMotor() (_swig_ret bool) + SetM_currentLimitError(arg2 float32) + GetM_currentLimitError() (_swig_ret float32) + SetM_currentPosition(arg2 float32) + GetM_currentPosition() (_swig_ret float32) + SetM_currentLimit(arg2 int) + GetM_currentLimit() (_swig_ret int) + SetM_accumulatedImpulse(arg2 float32) + GetM_accumulatedImpulse() (_swig_ret float32) + IsLimited() (_swig_ret bool) + NeedApplyTorques() (_swig_ret bool) + TestLimitValue(arg2 float32) (_swig_ret int) + SolveAngularLimits(arg2 float32, arg3 BtVector3, arg4 float32, arg5 BtRigidBody, arg6 BtRigidBody) (_swig_ret float32) +} + +type SwigcptrBtTranslationalLimitMotor uintptr + +func (p SwigcptrBtTranslationalLimitMotor) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtTranslationalLimitMotor) SwigIsBtTranslationalLimitMotor() { +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_lowerLimit(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTranslationalLimitMotor_m_lowerLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_lowerLimit() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTranslationalLimitMotor_m_lowerLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_upperLimit(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTranslationalLimitMotor_m_upperLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_upperLimit() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTranslationalLimitMotor_m_upperLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_accumulatedImpulse(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTranslationalLimitMotor_m_accumulatedImpulse_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_accumulatedImpulse() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTranslationalLimitMotor_m_accumulatedImpulse_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_limitSoftness(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTranslationalLimitMotor_m_limitSoftness_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_limitSoftness() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTranslationalLimitMotor_m_limitSoftness_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_damping(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTranslationalLimitMotor_m_damping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_damping() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTranslationalLimitMotor_m_damping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_restitution(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTranslationalLimitMotor_m_restitution_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_restitution() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btTranslationalLimitMotor_m_restitution_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_normalCFM(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTranslationalLimitMotor_m_normalCFM_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_normalCFM() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTranslationalLimitMotor_m_normalCFM_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_stopERP(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTranslationalLimitMotor_m_stopERP_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_stopERP() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTranslationalLimitMotor_m_stopERP_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_stopCFM(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTranslationalLimitMotor_m_stopCFM_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_stopCFM() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTranslationalLimitMotor_m_stopCFM_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_enableMotor(arg2 *bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTranslationalLimitMotor_m_enableMotor_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_enableMotor() (_swig_ret *bool) { + var swig_r *bool + _swig_i_0 := arg1 + swig_r = (*bool)(C._wrap_btTranslationalLimitMotor_m_enableMotor_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_targetVelocity(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTranslationalLimitMotor_m_targetVelocity_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_targetVelocity() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTranslationalLimitMotor_m_targetVelocity_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_maxMotorForce(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTranslationalLimitMotor_m_maxMotorForce_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_maxMotorForce() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTranslationalLimitMotor_m_maxMotorForce_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_currentLimitError(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTranslationalLimitMotor_m_currentLimitError_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_currentLimitError() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTranslationalLimitMotor_m_currentLimitError_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_currentLinearDiff(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btTranslationalLimitMotor_m_currentLinearDiff_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_currentLinearDiff() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btTranslationalLimitMotor_m_currentLinearDiff_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SetM_currentLimit(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btTranslationalLimitMotor_m_currentLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) GetM_currentLimit() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btTranslationalLimitMotor_m_currentLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtTranslationalLimitMotor__SWIG_0() (_swig_ret BtTranslationalLimitMotor) { + var swig_r BtTranslationalLimitMotor + swig_r = (BtTranslationalLimitMotor)(SwigcptrBtTranslationalLimitMotor(C._wrap_new_btTranslationalLimitMotor__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtTranslationalLimitMotor__SWIG_1(arg1 BtTranslationalLimitMotor) (_swig_ret BtTranslationalLimitMotor) { + var swig_r BtTranslationalLimitMotor + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtTranslationalLimitMotor)(SwigcptrBtTranslationalLimitMotor(C._wrap_new_btTranslationalLimitMotor__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtTranslationalLimitMotor(a ...interface{}) BtTranslationalLimitMotor { + argc := len(a) + if argc == 0 { + return NewBtTranslationalLimitMotor__SWIG_0() + } + if argc == 1 { + return NewBtTranslationalLimitMotor__SWIG_1(a[0].(BtTranslationalLimitMotor)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) IsLimited(arg2 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btTranslationalLimitMotor_isLimited_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) NeedApplyForce(arg2 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btTranslationalLimitMotor_needApplyForce_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) TestLimitValue(arg2 int, arg3 float32) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (int)(C._wrap_btTranslationalLimitMotor_testLimitValue_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtTranslationalLimitMotor) SolveLinearAxis(arg2 float32, arg3 float32, arg4 BtRigidBody, arg5 BtVector3, arg6 BtRigidBody, arg7 BtVector3, arg8 int, arg9 BtVector3, arg10 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := arg8 + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := getSwigcptr(arg10) + swig_r = (float32)(C._wrap_btTranslationalLimitMotor_solveLinearAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.swig_intgo(_swig_i_7), C.uintptr_t(_swig_i_8), C.uintptr_t(_swig_i_9))) + return swig_r +} + +func DeleteBtTranslationalLimitMotor(arg1 BtTranslationalLimitMotor) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btTranslationalLimitMotor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtTranslationalLimitMotor interface { + Swigcptr() uintptr + SwigIsBtTranslationalLimitMotor() + SetM_lowerLimit(arg2 BtVector3) + GetM_lowerLimit() (_swig_ret BtVector3) + SetM_upperLimit(arg2 BtVector3) + GetM_upperLimit() (_swig_ret BtVector3) + SetM_accumulatedImpulse(arg2 BtVector3) + GetM_accumulatedImpulse() (_swig_ret BtVector3) + SetM_limitSoftness(arg2 float32) + GetM_limitSoftness() (_swig_ret float32) + SetM_damping(arg2 float32) + GetM_damping() (_swig_ret float32) + SetM_restitution(arg2 float32) + GetM_restitution() (_swig_ret float32) + SetM_normalCFM(arg2 BtVector3) + GetM_normalCFM() (_swig_ret BtVector3) + SetM_stopERP(arg2 BtVector3) + GetM_stopERP() (_swig_ret BtVector3) + SetM_stopCFM(arg2 BtVector3) + GetM_stopCFM() (_swig_ret BtVector3) + SetM_enableMotor(arg2 *bool) + GetM_enableMotor() (_swig_ret *bool) + SetM_targetVelocity(arg2 BtVector3) + GetM_targetVelocity() (_swig_ret BtVector3) + SetM_maxMotorForce(arg2 BtVector3) + GetM_maxMotorForce() (_swig_ret BtVector3) + SetM_currentLimitError(arg2 BtVector3) + GetM_currentLimitError() (_swig_ret BtVector3) + SetM_currentLinearDiff(arg2 BtVector3) + GetM_currentLinearDiff() (_swig_ret BtVector3) + SetM_currentLimit(arg2 *int) + GetM_currentLimit() (_swig_ret *int) + IsLimited(arg2 int) (_swig_ret bool) + NeedApplyForce(arg2 int) (_swig_ret bool) + TestLimitValue(arg2 int, arg3 float32) (_swig_ret int) + SolveLinearAxis(arg2 float32, arg3 float32, arg4 BtRigidBody, arg5 BtVector3, arg6 BtRigidBody, arg7 BtVector3, arg8 int, arg9 BtVector3, arg10 BtVector3) (_swig_ret float32) +} + +type Bt6DofFlags int + +func _swig_getBT_6DOF_FLAGS_CFM_NORM() (_swig_ret Bt6DofFlags) { + var swig_r Bt6DofFlags + swig_r = (Bt6DofFlags)(C._wrap_BT_6DOF_FLAGS_CFM_NORM_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_6DOF_FLAGS_CFM_NORM Bt6DofFlags = _swig_getBT_6DOF_FLAGS_CFM_NORM() + +func _swig_getBT_6DOF_FLAGS_CFM_STOP() (_swig_ret Bt6DofFlags) { + var swig_r Bt6DofFlags + swig_r = (Bt6DofFlags)(C._wrap_BT_6DOF_FLAGS_CFM_STOP_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_6DOF_FLAGS_CFM_STOP Bt6DofFlags = _swig_getBT_6DOF_FLAGS_CFM_STOP() + +func _swig_getBT_6DOF_FLAGS_ERP_STOP() (_swig_ret Bt6DofFlags) { + var swig_r Bt6DofFlags + swig_r = (Bt6DofFlags)(C._wrap_BT_6DOF_FLAGS_ERP_STOP_mbt_e879218550ba2e2b()) + return swig_r +} + +var BT_6DOF_FLAGS_ERP_STOP Bt6DofFlags = _swig_getBT_6DOF_FLAGS_ERP_STOP() + +const BT_6DOF_FLAGS_AXIS_SHIFT int = 3 + +type SwigcptrBtGeneric6DofConstraint uintptr + +func (p SwigcptrBtGeneric6DofConstraint) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGeneric6DofConstraint) SwigIsBtGeneric6DofConstraint() { +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetM_useSolveConstraintObsolete(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofConstraint_m_useSolveConstraintObsolete_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetM_useSolveConstraintObsolete() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btGeneric6DofConstraint_m_useSolveConstraintObsolete_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtGeneric6DofConstraint__SWIG_0(arg1 BtRigidBody, arg2 BtRigidBody, arg3 BtTransform, arg4 BtTransform, arg5 bool) (_swig_ret BtGeneric6DofConstraint) { + var swig_r BtGeneric6DofConstraint + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (BtGeneric6DofConstraint)(SwigcptrBtGeneric6DofConstraint(C._wrap_new_btGeneric6DofConstraint__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4)))) + return swig_r +} + +func NewBtGeneric6DofConstraint__SWIG_1(arg1 BtRigidBody, arg2 BtTransform, arg3 bool) (_swig_ret BtGeneric6DofConstraint) { + var swig_r BtGeneric6DofConstraint + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (BtGeneric6DofConstraint)(SwigcptrBtGeneric6DofConstraint(C._wrap_new_btGeneric6DofConstraint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C._Bool(_swig_i_2)))) + return swig_r +} + +func NewBtGeneric6DofConstraint(a ...interface{}) BtGeneric6DofConstraint { + argc := len(a) + if argc == 3 { + return NewBtGeneric6DofConstraint__SWIG_1(a[0].(BtRigidBody), a[1].(BtTransform), a[2].(bool)) + } + if argc == 5 { + return NewBtGeneric6DofConstraint__SWIG_0(a[0].(BtRigidBody), a[1].(BtRigidBody), a[2].(BtTransform), a[3].(BtTransform), a[4].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) CalculateTransforms__SWIG_0(arg2 BtTransform, arg3 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btGeneric6DofConstraint_calculateTransforms__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) CalculateTransforms__SWIG_1() { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_calculateTransforms__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtGeneric6DofConstraint) CalculateTransforms(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.CalculateTransforms__SWIG_1() + return + } + if argc == 2 { + p.CalculateTransforms__SWIG_0(a[0].(BtTransform), a[1].(BtTransform)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetCalculatedTransformA() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofConstraint_getCalculatedTransformA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetCalculatedTransformB() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofConstraint_getCalculatedTransformB_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetFrameOffsetA__SWIG_0() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofConstraint_getFrameOffsetA__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetFrameOffsetB__SWIG_0() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofConstraint_getFrameOffsetB__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetFrameOffsetA__SWIG_1() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofConstraint_getFrameOffsetA__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofConstraint) GetFrameOffsetA(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetFrameOffsetA__SWIG_0() + } + if argc == 0 { + return p.GetFrameOffsetA__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetFrameOffsetB__SWIG_1() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofConstraint_getFrameOffsetB__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofConstraint) GetFrameOffsetB(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetFrameOffsetB__SWIG_0() + } + if argc == 0 { + return p.GetFrameOffsetB__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) BuildJacobian() { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_buildJacobian_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetInfo1(arg2 BtTypedConstraint_btConstraintInfo1) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_getInfo1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetInfo1NonVirtual(arg2 BtTypedConstraint_btConstraintInfo1) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_getInfo1NonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetInfo2(arg2 BtTypedConstraint_btConstraintInfo2) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_getInfo2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetInfo2NonVirtual(arg2 BtTypedConstraint_btConstraintInfo2, arg3 BtTransform, arg4 BtTransform, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3, arg8 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + C._wrap_btGeneric6DofConstraint_getInfo2NonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) UpdateRHS(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofConstraint_updateRHS_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetAxis(arg2 int) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btGeneric6DofConstraint_getAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetAngle(arg2 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btGeneric6DofConstraint_getAngle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetRelativePivotPosition(arg2 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btGeneric6DofConstraint_getRelativePivotPosition_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetFrames(arg2 BtTransform, arg3 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btGeneric6DofConstraint_setFrames_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) TestAngularLimitMotor(arg2 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btGeneric6DofConstraint_testAngularLimitMotor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetLinearLowerLimit(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_setLinearLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetLinearLowerLimit(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_getLinearLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetLinearUpperLimit(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_setLinearUpperLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetLinearUpperLimit(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_getLinearUpperLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetAngularLowerLimit(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_setAngularLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetAngularLowerLimit(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_getAngularLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetAngularUpperLimit(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_setAngularUpperLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetAngularUpperLimit(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraint_getAngularUpperLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetRotationalLimitMotor(arg2 int) (_swig_ret BtRotationalLimitMotor) { + var swig_r BtRotationalLimitMotor + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtRotationalLimitMotor)(SwigcptrBtRotationalLimitMotor(C._wrap_btGeneric6DofConstraint_getRotationalLimitMotor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetTranslationalLimitMotor() (_swig_ret BtTranslationalLimitMotor) { + var swig_r BtTranslationalLimitMotor + _swig_i_0 := arg1 + swig_r = (BtTranslationalLimitMotor)(SwigcptrBtTranslationalLimitMotor(C._wrap_btGeneric6DofConstraint_getTranslationalLimitMotor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetLimit(arg2 int, arg3 float32, arg4 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btGeneric6DofConstraint_setLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2), C.float(_swig_i_3)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) IsLimited(arg2 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btGeneric6DofConstraint_isLimited_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) CalcAnchorPos() { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_calcAnchorPos_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) Get_limit_motor_info2__SWIG_0(arg2 BtRotationalLimitMotor, arg3 BtTransform, arg4 BtTransform, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3, arg8 BtVector3, arg9 BtTypedConstraint_btConstraintInfo2, arg10 int, arg11 BtVector3, arg12 int, arg13 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := arg10 + _swig_i_10 := getSwigcptr(arg11) + _swig_i_11 := arg12 + _swig_i_12 := arg13 + swig_r = (int)(C._wrap_btGeneric6DofConstraint_get_limit_motor_info2__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7), C.uintptr_t(_swig_i_8), C.swig_intgo(_swig_i_9), C.uintptr_t(_swig_i_10), C.swig_intgo(_swig_i_11), C.swig_intgo(_swig_i_12))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) Get_limit_motor_info2__SWIG_1(arg2 BtRotationalLimitMotor, arg3 BtTransform, arg4 BtTransform, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3, arg8 BtVector3, arg9 BtTypedConstraint_btConstraintInfo2, arg10 int, arg11 BtVector3, arg12 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := arg10 + _swig_i_10 := getSwigcptr(arg11) + _swig_i_11 := arg12 + swig_r = (int)(C._wrap_btGeneric6DofConstraint_get_limit_motor_info2__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7), C.uintptr_t(_swig_i_8), C.swig_intgo(_swig_i_9), C.uintptr_t(_swig_i_10), C.swig_intgo(_swig_i_11))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofConstraint) Get_limit_motor_info2(a ...interface{}) int { + argc := len(a) + if argc == 11 { + return p.Get_limit_motor_info2__SWIG_1(a[0].(BtRotationalLimitMotor), a[1].(BtTransform), a[2].(BtTransform), a[3].(BtVector3), a[4].(BtVector3), a[5].(BtVector3), a[6].(BtVector3), a[7].(BtTypedConstraint_btConstraintInfo2), a[8].(int), a[9].(BtVector3), a[10].(int)) + } + if argc == 12 { + return p.Get_limit_motor_info2__SWIG_0(a[0].(BtRotationalLimitMotor), a[1].(BtTransform), a[2].(BtTransform), a[3].(BtVector3), a[4].(BtVector3), a[5].(BtVector3), a[6].(BtVector3), a[7].(BtTypedConstraint_btConstraintInfo2), a[8].(int), a[9].(BtVector3), a[10].(int), a[11].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetUseFrameOffset() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btGeneric6DofConstraint_getUseFrameOffset_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetUseFrameOffset(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofConstraint_setUseFrameOffset_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetUseLinearReferenceFrameA() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btGeneric6DofConstraint_getUseLinearReferenceFrameA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetUseLinearReferenceFrameA(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofConstraint_setUseLinearReferenceFrameA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetParam__SWIG_0(arg2 int, arg3 float32, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btGeneric6DofConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetParam__SWIG_1(arg2 int, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btGeneric6DofConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2)) +} + +func (p SwigcptrBtGeneric6DofConstraint) SetParam(a ...interface{}) { + argc := len(a) + if argc == 2 { + p.SetParam__SWIG_1(a[0].(int), a[1].(float32)) + return + } + if argc == 3 { + p.SetParam__SWIG_0(a[0].(int), a[1].(float32), a[2].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetParam__SWIG_0(arg2 int, arg3 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btGeneric6DofConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetParam__SWIG_1(arg2 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btGeneric6DofConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofConstraint) GetParam(a ...interface{}) float32 { + argc := len(a) + if argc == 1 { + return p.GetParam__SWIG_1(a[0].(int)) + } + if argc == 2 { + return p.GetParam__SWIG_0(a[0].(int), a[1].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) SetAxis(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btGeneric6DofConstraint_setAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) GetFlags() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGeneric6DofConstraint_getFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGeneric6DofConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraint) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btGeneric6DofConstraint_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func DeleteBtGeneric6DofConstraint(arg1 BtGeneric6DofConstraint) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGeneric6DofConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func BtGeneric6DofConstraintGetFixedBody() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btGeneric6DofConstraint_getFixedBody_mbt_e879218550ba2e2b())) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetOverrideNumSolverIterations() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SetOverrideNumSolverIterations(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SetupSolverConstraint(arg1 BtAlignedObjectArray_Sl_btSolverConstraint_Sg_, arg2 int, arg3 int, arg4 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btGeneric6DofConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.float(_swig_i_3)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) InternalSetAppliedImpulse(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) InternalGetAppliedImpulse() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btGeneric6DofConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetBreakingImpulseThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btGeneric6DofConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SetBreakingImpulseThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) IsEnabled() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btGeneric6DofConstraint_isEnabled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SetEnabled(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_setEnabled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SolveConstraintObsolete(arg1 BtSolverBody, arg2 BtSolverBody, arg3 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btGeneric6DofConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetRigidBodyA__SWIG_0() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btGeneric6DofConstraint_getRigidBodyA__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetRigidBodyA__SWIG_1() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btGeneric6DofConstraint_getRigidBodyA__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofConstraint) GetRigidBodyA(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetRigidBodyA__SWIG_0() + } + if argc == 0 { + return p.GetRigidBodyA__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetRigidBodyB__SWIG_0() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btGeneric6DofConstraint_getRigidBodyB__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetRigidBodyB__SWIG_1() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btGeneric6DofConstraint_getRigidBodyB__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofConstraint) GetRigidBodyB(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetRigidBodyB__SWIG_0() + } + if argc == 0 { + return p.GetRigidBodyB__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetUserConstraintType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofConstraint_getUserConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SetUserConstraintType(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_setUserConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SetUserConstraintId(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_setUserConstraintId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetUserConstraintId() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofConstraint_getUserConstraintId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SetUserConstraintPtr(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetUserConstraintPtr() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btGeneric6DofConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SetJointFeedback(arg1 BtJointFeedback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofConstraint_setJointFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetJointFeedback__SWIG_0() (_swig_ret BtJointFeedback) { + var swig_r BtJointFeedback + swig_r = (BtJointFeedback)(SwigcptrBtJointFeedback(C._wrap_btGeneric6DofConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetJointFeedback__SWIG_1() (_swig_ret BtJointFeedback) { + var swig_r BtJointFeedback + swig_r = (BtJointFeedback)(SwigcptrBtJointFeedback(C._wrap_btGeneric6DofConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofConstraint) GetJointFeedback(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetJointFeedback__SWIG_0() + } + if argc == 0 { + return p.GetJointFeedback__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetUid() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofConstraint_getUid_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) NeedsFeedback() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btGeneric6DofConstraint_needsFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) EnableFeedback(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_enableFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetAppliedImpulse() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btGeneric6DofConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetConstraintType() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_btGeneric6DofConstraint_getConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SetDbgDrawSize(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetDbgDrawSize() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btGeneric6DofConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) SetM_objectType(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtGeneric6DofConstraint_M_objectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetM_objectType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtGeneric6DofConstraint_M_objectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofConstraint) GetObjectType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofConstraint_getObjectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofConstraint) SwigIsBtTypedConstraint() { +} + +func (p SwigcptrBtGeneric6DofConstraint) SwigGetBtTypedConstraint() BtTypedConstraint { + return SwigcptrBtTypedConstraint(getSwigcptr(p)) +} + +func (p SwigcptrBtGeneric6DofConstraint) SwigIsBtTypedObject() { +} + +func (p SwigcptrBtGeneric6DofConstraint) SwigGetBtTypedObject() BtTypedObject { + return SwigcptrBtTypedObject(getSwigcptr(p)) +} + +type BtGeneric6DofConstraint interface { + Swigcptr() uintptr + SwigIsBtGeneric6DofConstraint() + SetM_useSolveConstraintObsolete(arg2 bool) + GetM_useSolveConstraintObsolete() (_swig_ret bool) + CalculateTransforms(a ...interface{}) + GetCalculatedTransformA() (_swig_ret BtTransform) + GetCalculatedTransformB() (_swig_ret BtTransform) + GetFrameOffsetA(a ...interface{}) interface{} + GetFrameOffsetB(a ...interface{}) interface{} + BuildJacobian() + GetInfo1(arg2 BtTypedConstraint_btConstraintInfo1) + GetInfo1NonVirtual(arg2 BtTypedConstraint_btConstraintInfo1) + GetInfo2(arg2 BtTypedConstraint_btConstraintInfo2) + GetInfo2NonVirtual(arg2 BtTypedConstraint_btConstraintInfo2, arg3 BtTransform, arg4 BtTransform, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3, arg8 BtVector3) + UpdateRHS(arg2 float32) + GetAxis(arg2 int) (_swig_ret BtVector3) + GetAngle(arg2 int) (_swig_ret float32) + GetRelativePivotPosition(arg2 int) (_swig_ret float32) + SetFrames(arg2 BtTransform, arg3 BtTransform) + TestAngularLimitMotor(arg2 int) (_swig_ret bool) + SetLinearLowerLimit(arg2 BtVector3) + GetLinearLowerLimit(arg2 BtVector3) + SetLinearUpperLimit(arg2 BtVector3) + GetLinearUpperLimit(arg2 BtVector3) + SetAngularLowerLimit(arg2 BtVector3) + GetAngularLowerLimit(arg2 BtVector3) + SetAngularUpperLimit(arg2 BtVector3) + GetAngularUpperLimit(arg2 BtVector3) + GetRotationalLimitMotor(arg2 int) (_swig_ret BtRotationalLimitMotor) + GetTranslationalLimitMotor() (_swig_ret BtTranslationalLimitMotor) + SetLimit(arg2 int, arg3 float32, arg4 float32) + IsLimited(arg2 int) (_swig_ret bool) + CalcAnchorPos() + Get_limit_motor_info2(a ...interface{}) int + GetUseFrameOffset() (_swig_ret bool) + SetUseFrameOffset(arg2 bool) + GetUseLinearReferenceFrameA() (_swig_ret bool) + SetUseLinearReferenceFrameA(arg2 bool) + SetParam(a ...interface{}) + GetParam(a ...interface{}) float32 + SetAxis(arg2 BtVector3, arg3 BtVector3) + GetFlags() (_swig_ret int) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + GetOverrideNumSolverIterations() (_swig_ret int) + SetOverrideNumSolverIterations(arg1 int) + SetupSolverConstraint(arg1 BtAlignedObjectArray_Sl_btSolverConstraint_Sg_, arg2 int, arg3 int, arg4 float32) + InternalSetAppliedImpulse(arg1 float32) + InternalGetAppliedImpulse() (_swig_ret float32) + GetBreakingImpulseThreshold() (_swig_ret float32) + SetBreakingImpulseThreshold(arg1 float32) + IsEnabled() (_swig_ret bool) + SetEnabled(arg1 bool) + SolveConstraintObsolete(arg1 BtSolverBody, arg2 BtSolverBody, arg3 float32) + GetRigidBodyA(a ...interface{}) interface{} + GetRigidBodyB(a ...interface{}) interface{} + GetUserConstraintType() (_swig_ret int) + SetUserConstraintType(arg1 int) + SetUserConstraintId(arg1 int) + GetUserConstraintId() (_swig_ret int) + SetUserConstraintPtr(arg1 uintptr) + GetUserConstraintPtr() (_swig_ret uintptr) + SetJointFeedback(arg1 BtJointFeedback) + GetJointFeedback(a ...interface{}) interface{} + GetUid() (_swig_ret int) + NeedsFeedback() (_swig_ret bool) + EnableFeedback(arg1 bool) + GetAppliedImpulse() (_swig_ret float32) + GetConstraintType() (_swig_ret BtTypedConstraintType) + SetDbgDrawSize(arg1 float32) + GetDbgDrawSize() (_swig_ret float32) + SetM_objectType(arg1 int) + GetM_objectType() (_swig_ret int) + GetObjectType() (_swig_ret int) + SwigIsBtTypedConstraint() + SwigGetBtTypedConstraint() BtTypedConstraint + SwigIsBtTypedObject() + SwigGetBtTypedObject() BtTypedObject +} + +type SwigcptrBtGeneric6DofConstraintData uintptr + +func (p SwigcptrBtGeneric6DofConstraintData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGeneric6DofConstraintData) SwigIsBtGeneric6DofConstraintData() { +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) SetM_typeConstraintData(arg2 BtTypedConstraintData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintData_m_typeConstraintData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) GetM_typeConstraintData() (_swig_ret BtTypedConstraintData) { + var swig_r BtTypedConstraintData + _swig_i_0 := arg1 + swig_r = (BtTypedConstraintData)(SwigcptrBtTypedConstraintData(C._wrap_btGeneric6DofConstraintData_m_typeConstraintData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) SetM_rbAFrame(arg2 BtTransformFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintData_m_rbAFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) GetM_rbAFrame() (_swig_ret BtTransformFloatData) { + var swig_r BtTransformFloatData + _swig_i_0 := arg1 + swig_r = (BtTransformFloatData)(SwigcptrBtTransformFloatData(C._wrap_btGeneric6DofConstraintData_m_rbAFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) SetM_rbBFrame(arg2 BtTransformFloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintData_m_rbBFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) GetM_rbBFrame() (_swig_ret BtTransformFloatData) { + var swig_r BtTransformFloatData + _swig_i_0 := arg1 + swig_r = (BtTransformFloatData)(SwigcptrBtTransformFloatData(C._wrap_btGeneric6DofConstraintData_m_rbBFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) SetM_linearUpperLimit(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintData_m_linearUpperLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) GetM_linearUpperLimit() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btGeneric6DofConstraintData_m_linearUpperLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) SetM_linearLowerLimit(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintData_m_linearLowerLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) GetM_linearLowerLimit() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btGeneric6DofConstraintData_m_linearLowerLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) SetM_angularUpperLimit(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintData_m_angularUpperLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) GetM_angularUpperLimit() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btGeneric6DofConstraintData_m_angularUpperLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) SetM_angularLowerLimit(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintData_m_angularLowerLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) GetM_angularLowerLimit() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btGeneric6DofConstraintData_m_angularLowerLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) SetM_useLinearReferenceFrameA(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofConstraintData_m_useLinearReferenceFrameA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) GetM_useLinearReferenceFrameA() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGeneric6DofConstraintData_m_useLinearReferenceFrameA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) SetM_useOffsetForConstraintFrame(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofConstraintData_m_useOffsetForConstraintFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintData) GetM_useOffsetForConstraintFrame() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGeneric6DofConstraintData_m_useOffsetForConstraintFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtGeneric6DofConstraintData() (_swig_ret BtGeneric6DofConstraintData) { + var swig_r BtGeneric6DofConstraintData + swig_r = (BtGeneric6DofConstraintData)(SwigcptrBtGeneric6DofConstraintData(C._wrap_new_btGeneric6DofConstraintData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtGeneric6DofConstraintData(arg1 BtGeneric6DofConstraintData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGeneric6DofConstraintData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtGeneric6DofConstraintData interface { + Swigcptr() uintptr + SwigIsBtGeneric6DofConstraintData() + SetM_typeConstraintData(arg2 BtTypedConstraintData) + GetM_typeConstraintData() (_swig_ret BtTypedConstraintData) + SetM_rbAFrame(arg2 BtTransformFloatData) + GetM_rbAFrame() (_swig_ret BtTransformFloatData) + SetM_rbBFrame(arg2 BtTransformFloatData) + GetM_rbBFrame() (_swig_ret BtTransformFloatData) + SetM_linearUpperLimit(arg2 BtVector3FloatData) + GetM_linearUpperLimit() (_swig_ret BtVector3FloatData) + SetM_linearLowerLimit(arg2 BtVector3FloatData) + GetM_linearLowerLimit() (_swig_ret BtVector3FloatData) + SetM_angularUpperLimit(arg2 BtVector3FloatData) + GetM_angularUpperLimit() (_swig_ret BtVector3FloatData) + SetM_angularLowerLimit(arg2 BtVector3FloatData) + GetM_angularLowerLimit() (_swig_ret BtVector3FloatData) + SetM_useLinearReferenceFrameA(arg2 int) + GetM_useLinearReferenceFrameA() (_swig_ret int) + SetM_useOffsetForConstraintFrame(arg2 int) + GetM_useOffsetForConstraintFrame() (_swig_ret int) +} + +type SwigcptrBtGeneric6DofConstraintDoubleData2 uintptr + +func (p SwigcptrBtGeneric6DofConstraintDoubleData2) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGeneric6DofConstraintDoubleData2) SwigIsBtGeneric6DofConstraintDoubleData2() { +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) SetM_typeConstraintData(arg2 BtTypedConstraintDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintDoubleData2_m_typeConstraintData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) GetM_typeConstraintData() (_swig_ret BtTypedConstraintDoubleData) { + var swig_r BtTypedConstraintDoubleData + _swig_i_0 := arg1 + swig_r = (BtTypedConstraintDoubleData)(SwigcptrBtTypedConstraintDoubleData(C._wrap_btGeneric6DofConstraintDoubleData2_m_typeConstraintData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) SetM_rbAFrame(arg2 BtTransformDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintDoubleData2_m_rbAFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) GetM_rbAFrame() (_swig_ret BtTransformDoubleData) { + var swig_r BtTransformDoubleData + _swig_i_0 := arg1 + swig_r = (BtTransformDoubleData)(SwigcptrBtTransformDoubleData(C._wrap_btGeneric6DofConstraintDoubleData2_m_rbAFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) SetM_rbBFrame(arg2 BtTransformDoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintDoubleData2_m_rbBFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) GetM_rbBFrame() (_swig_ret BtTransformDoubleData) { + var swig_r BtTransformDoubleData + _swig_i_0 := arg1 + swig_r = (BtTransformDoubleData)(SwigcptrBtTransformDoubleData(C._wrap_btGeneric6DofConstraintDoubleData2_m_rbBFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) SetM_linearUpperLimit(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintDoubleData2_m_linearUpperLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) GetM_linearUpperLimit() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btGeneric6DofConstraintDoubleData2_m_linearUpperLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) SetM_linearLowerLimit(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintDoubleData2_m_linearLowerLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) GetM_linearLowerLimit() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btGeneric6DofConstraintDoubleData2_m_linearLowerLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) SetM_angularUpperLimit(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintDoubleData2_m_angularUpperLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) GetM_angularUpperLimit() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btGeneric6DofConstraintDoubleData2_m_angularUpperLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) SetM_angularLowerLimit(arg2 BtVector3DoubleData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofConstraintDoubleData2_m_angularLowerLimit_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) GetM_angularLowerLimit() (_swig_ret BtVector3DoubleData) { + var swig_r BtVector3DoubleData + _swig_i_0 := arg1 + swig_r = (BtVector3DoubleData)(SwigcptrBtVector3DoubleData(C._wrap_btGeneric6DofConstraintDoubleData2_m_angularLowerLimit_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) SetM_useLinearReferenceFrameA(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofConstraintDoubleData2_m_useLinearReferenceFrameA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) GetM_useLinearReferenceFrameA() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGeneric6DofConstraintDoubleData2_m_useLinearReferenceFrameA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) SetM_useOffsetForConstraintFrame(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofConstraintDoubleData2_m_useOffsetForConstraintFrame_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofConstraintDoubleData2) GetM_useOffsetForConstraintFrame() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGeneric6DofConstraintDoubleData2_m_useOffsetForConstraintFrame_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtGeneric6DofConstraintDoubleData2() (_swig_ret BtGeneric6DofConstraintDoubleData2) { + var swig_r BtGeneric6DofConstraintDoubleData2 + swig_r = (BtGeneric6DofConstraintDoubleData2)(SwigcptrBtGeneric6DofConstraintDoubleData2(C._wrap_new_btGeneric6DofConstraintDoubleData2_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtGeneric6DofConstraintDoubleData2(arg1 BtGeneric6DofConstraintDoubleData2) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGeneric6DofConstraintDoubleData2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtGeneric6DofConstraintDoubleData2 interface { + Swigcptr() uintptr + SwigIsBtGeneric6DofConstraintDoubleData2() + SetM_typeConstraintData(arg2 BtTypedConstraintDoubleData) + GetM_typeConstraintData() (_swig_ret BtTypedConstraintDoubleData) + SetM_rbAFrame(arg2 BtTransformDoubleData) + GetM_rbAFrame() (_swig_ret BtTransformDoubleData) + SetM_rbBFrame(arg2 BtTransformDoubleData) + GetM_rbBFrame() (_swig_ret BtTransformDoubleData) + SetM_linearUpperLimit(arg2 BtVector3DoubleData) + GetM_linearUpperLimit() (_swig_ret BtVector3DoubleData) + SetM_linearLowerLimit(arg2 BtVector3DoubleData) + GetM_linearLowerLimit() (_swig_ret BtVector3DoubleData) + SetM_angularUpperLimit(arg2 BtVector3DoubleData) + GetM_angularUpperLimit() (_swig_ret BtVector3DoubleData) + SetM_angularLowerLimit(arg2 BtVector3DoubleData) + GetM_angularLowerLimit() (_swig_ret BtVector3DoubleData) + SetM_useLinearReferenceFrameA(arg2 int) + GetM_useLinearReferenceFrameA() (_swig_ret int) + SetM_useOffsetForConstraintFrame(arg2 int) + GetM_useOffsetForConstraintFrame() (_swig_ret int) +} + +func BtGetConstraintIslandId(arg1 BtTypedConstraint) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + swig_r = (int)(C._wrap_btGetConstraintIslandId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +type SwigcptrBtSortConstraintOnIslandPredicate uintptr + +func (p SwigcptrBtSortConstraintOnIslandPredicate) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSortConstraintOnIslandPredicate) SwigIsBtSortConstraintOnIslandPredicate() { +} + +func NewBtSortConstraintOnIslandPredicate() (_swig_ret BtSortConstraintOnIslandPredicate) { + var swig_r BtSortConstraintOnIslandPredicate + swig_r = (BtSortConstraintOnIslandPredicate)(SwigcptrBtSortConstraintOnIslandPredicate(C._wrap_new_btSortConstraintOnIslandPredicate_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtSortConstraintOnIslandPredicate(arg1 BtSortConstraintOnIslandPredicate) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSortConstraintOnIslandPredicate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtSortConstraintOnIslandPredicate interface { + Swigcptr() uintptr + SwigIsBtSortConstraintOnIslandPredicate() +} + +type SwigcptrInplaceSolverIslandCallback uintptr + +func (p SwigcptrInplaceSolverIslandCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrInplaceSolverIslandCallback) SwigIsInplaceSolverIslandCallback() { +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) SetM_solverInfo(arg2 BtContactSolverInfo) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_InplaceSolverIslandCallback_m_solverInfo_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) GetM_solverInfo() (_swig_ret BtContactSolverInfo) { + var swig_r BtContactSolverInfo + _swig_i_0 := arg1 + swig_r = (BtContactSolverInfo)(SwigcptrBtContactSolverInfo(C._wrap_InplaceSolverIslandCallback_m_solverInfo_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) SetM_solver(arg2 BtConstraintSolver) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_InplaceSolverIslandCallback_m_solver_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) GetM_solver() (_swig_ret BtConstraintSolver) { + var swig_r BtConstraintSolver + _swig_i_0 := arg1 + swig_r = (BtConstraintSolver)(SwigcptrBtConstraintSolver(C._wrap_InplaceSolverIslandCallback_m_solver_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) SetM_sortedConstraints(arg2 BtTypedConstraint) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_InplaceSolverIslandCallback_m_sortedConstraints_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) GetM_sortedConstraints() (_swig_ret BtTypedConstraint) { + var swig_r BtTypedConstraint + _swig_i_0 := arg1 + swig_r = (BtTypedConstraint)(SwigcptrBtTypedConstraint(C._wrap_InplaceSolverIslandCallback_m_sortedConstraints_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) SetM_numConstraints(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_InplaceSolverIslandCallback_m_numConstraints_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) GetM_numConstraints() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_InplaceSolverIslandCallback_m_numConstraints_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) SetM_debugDrawer(arg2 BtIDebugDraw) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_InplaceSolverIslandCallback_m_debugDrawer_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) GetM_debugDrawer() (_swig_ret BtIDebugDraw) { + var swig_r BtIDebugDraw + _swig_i_0 := arg1 + swig_r = (BtIDebugDraw)(SwigcptrBtIDebugDraw(C._wrap_InplaceSolverIslandCallback_m_debugDrawer_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) SetM_dispatcher(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_InplaceSolverIslandCallback_m_dispatcher_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) GetM_dispatcher() (_swig_ret BtDispatcher) { + var swig_r BtDispatcher + _swig_i_0 := arg1 + swig_r = (BtDispatcher)(SwigcptrBtDispatcher(C._wrap_InplaceSolverIslandCallback_m_dispatcher_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) SetM_bodies(arg2 BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_InplaceSolverIslandCallback_m_bodies_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) GetM_bodies() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_(C._wrap_InplaceSolverIslandCallback_m_bodies_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) SetM_manifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_InplaceSolverIslandCallback_m_manifolds_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) GetM_manifolds() (_swig_ret BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_(C._wrap_InplaceSolverIslandCallback_m_manifolds_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) SetM_constraints(arg2 BtAlignedObjectArray_Sl_btTypedConstraint_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_InplaceSolverIslandCallback_m_constraints_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) GetM_constraints() (_swig_ret BtAlignedObjectArray_Sl_btTypedConstraint_Sm__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btTypedConstraint_Sm__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btTypedConstraint_Sm__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btTypedConstraint_Sm__Sg_(C._wrap_InplaceSolverIslandCallback_m_constraints_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewInplaceSolverIslandCallback(arg1 BtConstraintSolver, arg2 BtStackAlloc, arg3 BtDispatcher) (_swig_ret InplaceSolverIslandCallback) { + var swig_r InplaceSolverIslandCallback + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (InplaceSolverIslandCallback)(SwigcptrInplaceSolverIslandCallback(C._wrap_new_InplaceSolverIslandCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) Setup(arg2 BtContactSolverInfo, arg3 BtTypedConstraint, arg4 int, arg5 BtIDebugDraw) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + C._wrap_InplaceSolverIslandCallback_setup_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) ProcessIsland(arg2 BtCollisionObject, arg3 int, arg4 BtPersistentManifold, arg5 int, arg6 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + C._wrap_InplaceSolverIslandCallback_processIsland_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_intgo(_swig_i_4), C.swig_intgo(_swig_i_5)) +} + +func (arg1 SwigcptrInplaceSolverIslandCallback) ProcessConstraints() { + _swig_i_0 := arg1 + C._wrap_InplaceSolverIslandCallback_processConstraints_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func DeleteInplaceSolverIslandCallback(arg1 InplaceSolverIslandCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_InplaceSolverIslandCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type InplaceSolverIslandCallback interface { + Swigcptr() uintptr + SwigIsInplaceSolverIslandCallback() + SetM_solverInfo(arg2 BtContactSolverInfo) + GetM_solverInfo() (_swig_ret BtContactSolverInfo) + SetM_solver(arg2 BtConstraintSolver) + GetM_solver() (_swig_ret BtConstraintSolver) + SetM_sortedConstraints(arg2 BtTypedConstraint) + GetM_sortedConstraints() (_swig_ret BtTypedConstraint) + SetM_numConstraints(arg2 int) + GetM_numConstraints() (_swig_ret int) + SetM_debugDrawer(arg2 BtIDebugDraw) + GetM_debugDrawer() (_swig_ret BtIDebugDraw) + SetM_dispatcher(arg2 BtDispatcher) + GetM_dispatcher() (_swig_ret BtDispatcher) + SetM_bodies(arg2 BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) + GetM_bodies() (_swig_ret BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) + SetM_manifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + GetM_manifolds() (_swig_ret BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + SetM_constraints(arg2 BtAlignedObjectArray_Sl_btTypedConstraint_Sm__Sg_) + GetM_constraints() (_swig_ret BtAlignedObjectArray_Sl_btTypedConstraint_Sm__Sg_) + Setup(arg2 BtContactSolverInfo, arg3 BtTypedConstraint, arg4 int, arg5 BtIDebugDraw) + ProcessIsland(arg2 BtCollisionObject, arg3 int, arg4 BtPersistentManifold, arg5 int, arg6 int) + ProcessConstraints() +} + +type SwigcptrBtClosestNotMeConvexResultCallback uintptr + +func (p SwigcptrBtClosestNotMeConvexResultCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtClosestNotMeConvexResultCallback) SwigIsBtClosestNotMeConvexResultCallback() { +} + +func (arg1 SwigcptrBtClosestNotMeConvexResultCallback) SetM_me(arg2 BtCollisionObject) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btClosestNotMeConvexResultCallback_m_me_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtClosestNotMeConvexResultCallback) GetM_me() (_swig_ret BtCollisionObject) { + var swig_r BtCollisionObject + _swig_i_0 := arg1 + swig_r = (BtCollisionObject)(SwigcptrBtCollisionObject(C._wrap_btClosestNotMeConvexResultCallback_m_me_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtClosestNotMeConvexResultCallback) SetM_allowedPenetration(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btClosestNotMeConvexResultCallback_m_allowedPenetration_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtClosestNotMeConvexResultCallback) GetM_allowedPenetration() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btClosestNotMeConvexResultCallback_m_allowedPenetration_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtClosestNotMeConvexResultCallback) SetM_pairCache(arg2 BtOverlappingPairCache) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btClosestNotMeConvexResultCallback_m_pairCache_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtClosestNotMeConvexResultCallback) GetM_pairCache() (_swig_ret BtOverlappingPairCache) { + var swig_r BtOverlappingPairCache + _swig_i_0 := arg1 + swig_r = (BtOverlappingPairCache)(SwigcptrBtOverlappingPairCache(C._wrap_btClosestNotMeConvexResultCallback_m_pairCache_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtClosestNotMeConvexResultCallback) SetM_dispatcher(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btClosestNotMeConvexResultCallback_m_dispatcher_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtClosestNotMeConvexResultCallback) GetM_dispatcher() (_swig_ret BtDispatcher) { + var swig_r BtDispatcher + _swig_i_0 := arg1 + swig_r = (BtDispatcher)(SwigcptrBtDispatcher(C._wrap_btClosestNotMeConvexResultCallback_m_dispatcher_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtClosestNotMeConvexResultCallback(arg1 BtCollisionObject, arg2 BtVector3, arg3 BtVector3, arg4 BtOverlappingPairCache, arg5 BtDispatcher) (_swig_ret BtClosestNotMeConvexResultCallback) { + var swig_r BtClosestNotMeConvexResultCallback + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (BtClosestNotMeConvexResultCallback)(SwigcptrBtClosestNotMeConvexResultCallback(C._wrap_new_btClosestNotMeConvexResultCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)))) + return swig_r +} + +func (arg1 SwigcptrBtClosestNotMeConvexResultCallback) AddSingleResult(arg2 BtCollisionWorld_LocalConvexResult, arg3 bool) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (float32)(C._wrap_btClosestNotMeConvexResultCallback_addSingleResult_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C._Bool(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtClosestNotMeConvexResultCallback) NeedsCollision(arg2 BtBroadphaseProxy) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btClosestNotMeConvexResultCallback_needsCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func DeleteBtClosestNotMeConvexResultCallback(arg1 BtClosestNotMeConvexResultCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btClosestNotMeConvexResultCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtClosestNotMeConvexResultCallback interface { + Swigcptr() uintptr + SwigIsBtClosestNotMeConvexResultCallback() + SetM_me(arg2 BtCollisionObject) + GetM_me() (_swig_ret BtCollisionObject) + SetM_allowedPenetration(arg2 float32) + GetM_allowedPenetration() (_swig_ret float32) + SetM_pairCache(arg2 BtOverlappingPairCache) + GetM_pairCache() (_swig_ret BtOverlappingPairCache) + SetM_dispatcher(arg2 BtDispatcher) + GetM_dispatcher() (_swig_ret BtDispatcher) + AddSingleResult(arg2 BtCollisionWorld_LocalConvexResult, arg3 bool) (_swig_ret float32) + NeedsCollision(arg2 BtBroadphaseProxy) (_swig_ret bool) +} + +func SetGNumClampedCcdMotions(arg1 int) { + _swig_i_0 := arg1 + C._wrap_gNumClampedCcdMotions_set_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0)) +} + +func GetGNumClampedCcdMotions() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_gNumClampedCcdMotions_get_mbt_e879218550ba2e2b()) + return swig_r +} + +type SwigcptrBtUnionFindElementSortPredicate uintptr + +func (p SwigcptrBtUnionFindElementSortPredicate) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtUnionFindElementSortPredicate) SwigIsBtUnionFindElementSortPredicate() { +} + +func NewBtUnionFindElementSortPredicate() (_swig_ret BtUnionFindElementSortPredicate) { + var swig_r BtUnionFindElementSortPredicate + swig_r = (BtUnionFindElementSortPredicate)(SwigcptrBtUnionFindElementSortPredicate(C._wrap_new_btUnionFindElementSortPredicate_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtUnionFindElementSortPredicate(arg1 BtUnionFindElementSortPredicate) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btUnionFindElementSortPredicate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtUnionFindElementSortPredicate interface { + Swigcptr() uintptr + SwigIsBtUnionFindElementSortPredicate() +} + +func GetIslandId(arg1 BtPersistentManifold) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + swig_r = (int)(C._wrap_getIslandId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +type SwigcptrBtPersistentManifoldSortPredicate uintptr + +func (p SwigcptrBtPersistentManifoldSortPredicate) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtPersistentManifoldSortPredicate) SwigIsBtPersistentManifoldSortPredicate() { +} + +func NewBtPersistentManifoldSortPredicate() (_swig_ret BtPersistentManifoldSortPredicate) { + var swig_r BtPersistentManifoldSortPredicate + swig_r = (BtPersistentManifoldSortPredicate)(SwigcptrBtPersistentManifoldSortPredicate(C._wrap_new_btPersistentManifoldSortPredicate_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtPersistentManifoldSortPredicate(arg1 BtPersistentManifoldSortPredicate) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btPersistentManifoldSortPredicate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtPersistentManifoldSortPredicate interface { + Swigcptr() uintptr + SwigIsBtPersistentManifoldSortPredicate() +} + +type SwigcptrBtPersistentManifoldSortPredicateDeterministic uintptr + +func (p SwigcptrBtPersistentManifoldSortPredicateDeterministic) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtPersistentManifoldSortPredicateDeterministic) SwigIsBtPersistentManifoldSortPredicateDeterministic() { +} + +func NewBtPersistentManifoldSortPredicateDeterministic() (_swig_ret BtPersistentManifoldSortPredicateDeterministic) { + var swig_r BtPersistentManifoldSortPredicateDeterministic + swig_r = (BtPersistentManifoldSortPredicateDeterministic)(SwigcptrBtPersistentManifoldSortPredicateDeterministic(C._wrap_new_btPersistentManifoldSortPredicateDeterministic_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtPersistentManifoldSortPredicateDeterministic(arg1 BtPersistentManifoldSortPredicateDeterministic) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btPersistentManifoldSortPredicateDeterministic_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtPersistentManifoldSortPredicateDeterministic interface { + Swigcptr() uintptr + SwigIsBtPersistentManifoldSortPredicateDeterministic() +} + +type SwigcptrBtGjkPairDetector uintptr + +func (p SwigcptrBtGjkPairDetector) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGjkPairDetector) SwigIsBtGjkPairDetector() { +} + +func (arg1 SwigcptrBtGjkPairDetector) SetM_lastUsedMethod(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGjkPairDetector_m_lastUsedMethod_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtGjkPairDetector) GetM_lastUsedMethod() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGjkPairDetector_m_lastUsedMethod_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGjkPairDetector) SetM_curIter(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGjkPairDetector_m_curIter_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtGjkPairDetector) GetM_curIter() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGjkPairDetector_m_curIter_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGjkPairDetector) SetM_degenerateSimplex(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGjkPairDetector_m_degenerateSimplex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtGjkPairDetector) GetM_degenerateSimplex() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGjkPairDetector_m_degenerateSimplex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGjkPairDetector) SetM_catchDegeneracies(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGjkPairDetector_m_catchDegeneracies_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtGjkPairDetector) GetM_catchDegeneracies() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGjkPairDetector_m_catchDegeneracies_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGjkPairDetector) SetM_fixContactNormalDirection(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGjkPairDetector_m_fixContactNormalDirection_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtGjkPairDetector) GetM_fixContactNormalDirection() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGjkPairDetector_m_fixContactNormalDirection_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtGjkPairDetector__SWIG_0(arg1 BtConvexShape, arg2 BtConvexShape, arg3 BtVoronoiSimplexSolver, arg4 BtConvexPenetrationDepthSolver) (_swig_ret BtGjkPairDetector) { + var swig_r BtGjkPairDetector + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtGjkPairDetector)(SwigcptrBtGjkPairDetector(C._wrap_new_btGjkPairDetector__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func NewBtGjkPairDetector__SWIG_1(arg1 BtConvexShape, arg2 BtConvexShape, arg3 int, arg4 int, arg5 float32, arg6 float32, arg7 BtVoronoiSimplexSolver, arg8 BtConvexPenetrationDepthSolver) (_swig_ret BtGjkPairDetector) { + var swig_r BtGjkPairDetector + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + swig_r = (BtGjkPairDetector)(SwigcptrBtGjkPairDetector(C._wrap_new_btGjkPairDetector__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7)))) + return swig_r +} + +func NewBtGjkPairDetector(a ...interface{}) BtGjkPairDetector { + argc := len(a) + if argc == 4 { + return NewBtGjkPairDetector__SWIG_0(a[0].(BtConvexShape), a[1].(BtConvexShape), a[2].(BtVoronoiSimplexSolver), a[3].(BtConvexPenetrationDepthSolver)) + } + if argc == 8 { + return NewBtGjkPairDetector__SWIG_1(a[0].(BtConvexShape), a[1].(BtConvexShape), a[2].(int), a[3].(int), a[4].(float32), a[5].(float32), a[6].(BtVoronoiSimplexSolver), a[7].(BtConvexPenetrationDepthSolver)) + } + panic("No match for overloaded function call") +} + +func DeleteBtGjkPairDetector(arg1 BtGjkPairDetector) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGjkPairDetector_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtGjkPairDetector) GetClosestPoints__SWIG_0(arg2 BtDiscreteCollisionDetectorInterface_ClosestPointInput, arg3 BtDiscreteCollisionDetectorInterface_Result, arg4 BtIDebugDraw, arg5 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + C._wrap_btGjkPairDetector_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4)) +} + +func (arg1 SwigcptrBtGjkPairDetector) GetClosestPoints__SWIG_1(arg2 BtDiscreteCollisionDetectorInterface_ClosestPointInput, arg3 BtDiscreteCollisionDetectorInterface_Result, arg4 BtIDebugDraw) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btGjkPairDetector_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtGjkPairDetector) GetClosestPoints(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.GetClosestPoints__SWIG_1(a[0].(BtDiscreteCollisionDetectorInterface_ClosestPointInput), a[1].(BtDiscreteCollisionDetectorInterface_Result), a[2].(BtIDebugDraw)) + return + } + if argc == 4 { + p.GetClosestPoints__SWIG_0(a[0].(BtDiscreteCollisionDetectorInterface_ClosestPointInput), a[1].(BtDiscreteCollisionDetectorInterface_Result), a[2].(BtIDebugDraw), a[3].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtGjkPairDetector) GetClosestPointsNonVirtual(arg2 BtDiscreteCollisionDetectorInterface_ClosestPointInput, arg3 BtDiscreteCollisionDetectorInterface_Result, arg4 BtIDebugDraw) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btGjkPairDetector_getClosestPointsNonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtGjkPairDetector) SetMinkowskiA(arg2 BtConvexShape) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGjkPairDetector_setMinkowskiA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGjkPairDetector) SetMinkowskiB(arg2 BtConvexShape) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGjkPairDetector_setMinkowskiB_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGjkPairDetector) SetCachedSeparatingAxis(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGjkPairDetector_setCachedSeparatingAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGjkPairDetector) GetCachedSeparatingAxis() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btGjkPairDetector_getCachedSeparatingAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGjkPairDetector) GetCachedSeparatingDistance() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btGjkPairDetector_getCachedSeparatingDistance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGjkPairDetector) SetPenetrationDepthSolver(arg2 BtConvexPenetrationDepthSolver) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGjkPairDetector_setPenetrationDepthSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGjkPairDetector) SetIgnoreMargin(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGjkPairDetector_setIgnoreMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (p SwigcptrBtGjkPairDetector) SwigIsBtDiscreteCollisionDetectorInterface() { +} + +func (p SwigcptrBtGjkPairDetector) SwigGetBtDiscreteCollisionDetectorInterface() BtDiscreteCollisionDetectorInterface { + return SwigcptrBtDiscreteCollisionDetectorInterface(getSwigcptr(p)) +} + +type BtGjkPairDetector interface { + Swigcptr() uintptr + SwigIsBtGjkPairDetector() + SetM_lastUsedMethod(arg2 int) + GetM_lastUsedMethod() (_swig_ret int) + SetM_curIter(arg2 int) + GetM_curIter() (_swig_ret int) + SetM_degenerateSimplex(arg2 int) + GetM_degenerateSimplex() (_swig_ret int) + SetM_catchDegeneracies(arg2 int) + GetM_catchDegeneracies() (_swig_ret int) + SetM_fixContactNormalDirection(arg2 int) + GetM_fixContactNormalDirection() (_swig_ret int) + GetClosestPoints(a ...interface{}) + GetClosestPointsNonVirtual(arg2 BtDiscreteCollisionDetectorInterface_ClosestPointInput, arg3 BtDiscreteCollisionDetectorInterface_Result, arg4 BtIDebugDraw) + SetMinkowskiA(arg2 BtConvexShape) + SetMinkowskiB(arg2 BtConvexShape) + SetCachedSeparatingAxis(arg2 BtVector3) + GetCachedSeparatingAxis() (_swig_ret BtVector3) + GetCachedSeparatingDistance() (_swig_ret float32) + SetPenetrationDepthSolver(arg2 BtConvexPenetrationDepthSolver) + SetIgnoreMargin(arg2 bool) + SwigIsBtDiscreteCollisionDetectorInterface() + SwigGetBtDiscreteCollisionDetectorInterface() BtDiscreteCollisionDetectorInterface +} + +type SwigcptrSupportVertexCallback uintptr + +func (p SwigcptrSupportVertexCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrSupportVertexCallback) SwigIsSupportVertexCallback() { +} + +func (arg1 SwigcptrSupportVertexCallback) SetM_worldTrans(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_SupportVertexCallback_m_worldTrans_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrSupportVertexCallback) GetM_worldTrans() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_SupportVertexCallback_m_worldTrans_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrSupportVertexCallback) SetM_maxDot(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_SupportVertexCallback_m_maxDot_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrSupportVertexCallback) GetM_maxDot() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_SupportVertexCallback_m_maxDot_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrSupportVertexCallback) SetM_supportVecLocal(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_SupportVertexCallback_m_supportVecLocal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrSupportVertexCallback) GetM_supportVecLocal() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_SupportVertexCallback_m_supportVecLocal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewSupportVertexCallback(arg1 BtVector3, arg2 BtTransform) (_swig_ret SupportVertexCallback) { + var swig_r SupportVertexCallback + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (SupportVertexCallback)(SwigcptrSupportVertexCallback(C._wrap_new_SupportVertexCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrSupportVertexCallback) ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_SupportVertexCallback_processTriangle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrSupportVertexCallback) GetSupportVertexWorldSpace() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_SupportVertexCallback_GetSupportVertexWorldSpace_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrSupportVertexCallback) GetSupportVertexLocal() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_SupportVertexCallback_GetSupportVertexLocal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func DeleteSupportVertexCallback(arg1 SupportVertexCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_SupportVertexCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrSupportVertexCallback) SwigIsBtTriangleCallback() { +} + +func (p SwigcptrSupportVertexCallback) SwigGetBtTriangleCallback() BtTriangleCallback { + return SwigcptrBtTriangleCallback(getSwigcptr(p)) +} + +type SupportVertexCallback interface { + Swigcptr() uintptr + SwigIsSupportVertexCallback() + SetM_worldTrans(arg2 BtTransform) + GetM_worldTrans() (_swig_ret BtTransform) + SetM_maxDot(arg2 float32) + GetM_maxDot() (_swig_ret float32) + SetM_supportVecLocal(arg2 BtVector3) + GetM_supportVecLocal() (_swig_ret BtVector3) + ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) + GetSupportVertexWorldSpace() (_swig_ret BtVector3) + GetSupportVertexLocal() (_swig_ret BtVector3) + SwigIsBtTriangleCallback() + SwigGetBtTriangleCallback() BtTriangleCallback +} + +func GetQuantized(arg1 float32) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_getQuantized_mbt_e879218550ba2e2b(C.float(_swig_i_0))) + return swig_r +} + +func MinmaxRange(arg1 float32, arg2 float32, arg3 float32) (_swig_ret BtHeightfieldTerrainShape_Range) { + var swig_r BtHeightfieldTerrainShape_Range + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtHeightfieldTerrainShape_Range)(SwigcptrBtHeightfieldTerrainShape_Range(C._wrap_minmaxRange_mbt_e879218550ba2e2b(C.float(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +type SwigcptrProcessTrianglesAction uintptr + +func (p SwigcptrProcessTrianglesAction) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrProcessTrianglesAction) SwigIsProcessTrianglesAction() { +} + +func (arg1 SwigcptrProcessTrianglesAction) SetShape(arg2 BtHeightfieldTerrainShape) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_ProcessTrianglesAction_shape_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrProcessTrianglesAction) GetShape() (_swig_ret BtHeightfieldTerrainShape) { + var swig_r BtHeightfieldTerrainShape + _swig_i_0 := arg1 + swig_r = (BtHeightfieldTerrainShape)(SwigcptrBtHeightfieldTerrainShape(C._wrap_ProcessTrianglesAction_shape_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrProcessTrianglesAction) SetFlipQuadEdges(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_ProcessTrianglesAction_flipQuadEdges_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrProcessTrianglesAction) GetFlipQuadEdges() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_ProcessTrianglesAction_flipQuadEdges_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrProcessTrianglesAction) SetUseDiamondSubdivision(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_ProcessTrianglesAction_useDiamondSubdivision_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrProcessTrianglesAction) GetUseDiamondSubdivision() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_ProcessTrianglesAction_useDiamondSubdivision_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrProcessTrianglesAction) SetWidth(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_ProcessTrianglesAction_width_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrProcessTrianglesAction) GetWidth() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_ProcessTrianglesAction_width_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrProcessTrianglesAction) SetLength(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_ProcessTrianglesAction_length_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrProcessTrianglesAction) GetLength() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_ProcessTrianglesAction_length_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrProcessTrianglesAction) SetCallback(arg2 BtTriangleCallback) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_ProcessTrianglesAction_callback_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrProcessTrianglesAction) GetCallback() (_swig_ret BtTriangleCallback) { + var swig_r BtTriangleCallback + _swig_i_0 := arg1 + swig_r = (BtTriangleCallback)(SwigcptrBtTriangleCallback(C._wrap_ProcessTrianglesAction_callback_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrProcessTrianglesAction) Exec(arg2 int, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_ProcessTrianglesAction_exec_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func NewProcessTrianglesAction() (_swig_ret ProcessTrianglesAction) { + var swig_r ProcessTrianglesAction + swig_r = (ProcessTrianglesAction)(SwigcptrProcessTrianglesAction(C._wrap_new_ProcessTrianglesAction_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteProcessTrianglesAction(arg1 ProcessTrianglesAction) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_ProcessTrianglesAction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type ProcessTrianglesAction interface { + Swigcptr() uintptr + SwigIsProcessTrianglesAction() + SetShape(arg2 BtHeightfieldTerrainShape) + GetShape() (_swig_ret BtHeightfieldTerrainShape) + SetFlipQuadEdges(arg2 bool) + GetFlipQuadEdges() (_swig_ret bool) + SetUseDiamondSubdivision(arg2 bool) + GetUseDiamondSubdivision() (_swig_ret bool) + SetWidth(arg2 int) + GetWidth() (_swig_ret int) + SetLength(arg2 int) + GetLength() (_swig_ret int) + SetCallback(arg2 BtTriangleCallback) + GetCallback() (_swig_ret BtTriangleCallback) + Exec(arg2 int, arg3 int) +} + +type SwigcptrProcessVBoundsAction uintptr + +func (p SwigcptrProcessVBoundsAction) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrProcessVBoundsAction) SwigIsProcessVBoundsAction() { +} + +func (arg1 SwigcptrProcessVBoundsAction) GetVbounds() (_swig_ret BtAlignedObjectArray_Sl_btHeightfieldTerrainShape_Range_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btHeightfieldTerrainShape_Range_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btHeightfieldTerrainShape_Range_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btHeightfieldTerrainShape_Range_Sg_(C._wrap_ProcessVBoundsAction_vbounds_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrProcessVBoundsAction) SetWidth(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_ProcessVBoundsAction_width_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrProcessVBoundsAction) GetWidth() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_ProcessVBoundsAction_width_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrProcessVBoundsAction) SetLength(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_ProcessVBoundsAction_length_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrProcessVBoundsAction) GetLength() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_ProcessVBoundsAction_length_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrProcessVBoundsAction) SetChunkSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_ProcessVBoundsAction_chunkSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrProcessVBoundsAction) GetChunkSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_ProcessVBoundsAction_chunkSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrProcessVBoundsAction) SetRayBegin(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_ProcessVBoundsAction_rayBegin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrProcessVBoundsAction) GetRayBegin() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_ProcessVBoundsAction_rayBegin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrProcessVBoundsAction) SetRayEnd(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_ProcessVBoundsAction_rayEnd_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrProcessVBoundsAction) GetRayEnd() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_ProcessVBoundsAction_rayEnd_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrProcessVBoundsAction) SetRayDir(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_ProcessVBoundsAction_rayDir_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrProcessVBoundsAction) GetRayDir() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_ProcessVBoundsAction_rayDir_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrProcessVBoundsAction) SetM_indices(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_ProcessVBoundsAction_m_indices_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrProcessVBoundsAction) GetM_indices() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_ProcessVBoundsAction_m_indices_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrProcessVBoundsAction) SetProcessTriangles(arg2 ProcessTrianglesAction) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_ProcessVBoundsAction_processTriangles_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrProcessVBoundsAction) GetProcessTriangles() (_swig_ret ProcessTrianglesAction) { + var swig_r ProcessTrianglesAction + _swig_i_0 := arg1 + swig_r = (ProcessTrianglesAction)(SwigcptrProcessTrianglesAction(C._wrap_ProcessVBoundsAction_processTriangles_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewProcessVBoundsAction(arg1 BtAlignedObjectArray_Sl_btHeightfieldTerrainShape_Range_Sg_, arg2 *int) (_swig_ret ProcessVBoundsAction) { + var swig_r ProcessVBoundsAction + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (ProcessVBoundsAction)(SwigcptrProcessVBoundsAction(C._wrap_new_ProcessVBoundsAction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)))) + return swig_r +} + +func DeleteProcessVBoundsAction(arg1 ProcessVBoundsAction) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_ProcessVBoundsAction_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type ProcessVBoundsAction interface { + Swigcptr() uintptr + SwigIsProcessVBoundsAction() + GetVbounds() (_swig_ret BtAlignedObjectArray_Sl_btHeightfieldTerrainShape_Range_Sg_) + SetWidth(arg2 int) + GetWidth() (_swig_ret int) + SetLength(arg2 int) + GetLength() (_swig_ret int) + SetChunkSize(arg2 int) + GetChunkSize() (_swig_ret int) + SetRayBegin(arg2 BtVector3) + GetRayBegin() (_swig_ret BtVector3) + SetRayEnd(arg2 BtVector3) + GetRayEnd() (_swig_ret BtVector3) + SetRayDir(arg2 BtVector3) + GetRayDir() (_swig_ret BtVector3) + SetM_indices(arg2 *int) + GetM_indices() (_swig_ret *int) + SetProcessTriangles(arg2 ProcessTrianglesAction) + GetProcessTriangles() (_swig_ret ProcessTrianglesAction) +} + +type SwigcptrBtGjkEpaSolver2 uintptr + +func (p SwigcptrBtGjkEpaSolver2) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGjkEpaSolver2) SwigIsBtGjkEpaSolver2() { +} + +func BtGjkEpaSolver2StackSizeRequirement() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGjkEpaSolver2_StackSizeRequirement_mbt_e879218550ba2e2b()) + return swig_r +} + +func BtGjkEpaSolver2Distance(arg1 BtConvexShape, arg2 BtTransform, arg3 BtConvexShape, arg4 BtTransform, arg5 BtVector3, arg6 BtGjkEpaSolver2_sResults) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_btGjkEpaSolver2_Distance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func BtGjkEpaSolver2Penetration__SWIG_0(arg1 BtConvexShape, arg2 BtTransform, arg3 BtConvexShape, arg4 BtTransform, arg5 BtVector3, arg6 BtGjkEpaSolver2_sResults, arg7 bool) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := arg7 + swig_r = (bool)(C._wrap_btGjkEpaSolver2_Penetration__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C._Bool(_swig_i_6))) + return swig_r +} + +func BtGjkEpaSolver2Penetration__SWIG_1(arg1 BtConvexShape, arg2 BtTransform, arg3 BtConvexShape, arg4 BtTransform, arg5 BtVector3, arg6 BtGjkEpaSolver2_sResults) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_btGjkEpaSolver2_Penetration__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func BtGjkEpaSolver2Penetration(a ...interface{}) bool { + argc := len(a) + if argc == 6 { + return BtGjkEpaSolver2Penetration__SWIG_1(a[0].(BtConvexShape), a[1].(BtTransform), a[2].(BtConvexShape), a[3].(BtTransform), a[4].(BtVector3), a[5].(BtGjkEpaSolver2_sResults)) + } + if argc == 7 { + return BtGjkEpaSolver2Penetration__SWIG_0(a[0].(BtConvexShape), a[1].(BtTransform), a[2].(BtConvexShape), a[3].(BtTransform), a[4].(BtVector3), a[5].(BtGjkEpaSolver2_sResults), a[6].(bool)) + } + panic("No match for overloaded function call") +} + +func BtGjkEpaSolver2SignedDistance__SWIG_0(arg1 BtVector3, arg2 float32, arg3 BtConvexShape, arg4 BtTransform, arg5 BtGjkEpaSolver2_sResults) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btGjkEpaSolver2_SignedDistance__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func BtGjkEpaSolver2SignedDistance__SWIG_1(arg1 BtConvexShape, arg2 BtTransform, arg3 BtConvexShape, arg4 BtTransform, arg5 BtVector3, arg6 BtGjkEpaSolver2_sResults) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_btGjkEpaSolver2_SignedDistance__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func BtGjkEpaSolver2SignedDistance(a ...interface{}) interface{} { + argc := len(a) + if argc == 5 { + return BtGjkEpaSolver2SignedDistance__SWIG_0(a[0].(BtVector3), a[1].(float32), a[2].(BtConvexShape), a[3].(BtTransform), a[4].(BtGjkEpaSolver2_sResults)) + } + if argc == 6 { + return BtGjkEpaSolver2SignedDistance__SWIG_1(a[0].(BtConvexShape), a[1].(BtTransform), a[2].(BtConvexShape), a[3].(BtTransform), a[4].(BtVector3), a[5].(BtGjkEpaSolver2_sResults)) + } + panic("No match for overloaded function call") +} + +func NewBtGjkEpaSolver2() (_swig_ret BtGjkEpaSolver2) { + var swig_r BtGjkEpaSolver2 + swig_r = (BtGjkEpaSolver2)(SwigcptrBtGjkEpaSolver2(C._wrap_new_btGjkEpaSolver2_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtGjkEpaSolver2(arg1 BtGjkEpaSolver2) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGjkEpaSolver2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtGjkEpaSolver2 interface { + Swigcptr() uintptr + SwigIsBtGjkEpaSolver2() +} + +const GJK_MAX_ITERATIONS int = 128 +const EPA_MAX_VERTICES int = 128 +const EPA_MAX_ITERATIONS int = 255 + +func _swig_getEPA_MAX_FACES() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_EPA_MAX_FACES_mbt_e879218550ba2e2b()) + return swig_r +} + +var EPA_MAX_FACES int = _swig_getEPA_MAX_FACES() + +type SwigcptrMinkowskiDiff uintptr + +func (p SwigcptrMinkowskiDiff) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrMinkowskiDiff) SwigIsMinkowskiDiff() { +} + +func (arg1 SwigcptrMinkowskiDiff) SetM_shapes(arg2 BtConvexShape) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_MinkowskiDiff_m_shapes_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrMinkowskiDiff) GetM_shapes() (_swig_ret BtConvexShape) { + var swig_r BtConvexShape + _swig_i_0 := arg1 + swig_r = (BtConvexShape)(SwigcptrBtConvexShape(C._wrap_MinkowskiDiff_m_shapes_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrMinkowskiDiff) SetM_toshape1(arg2 BtMatrix3x3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_MinkowskiDiff_m_toshape1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrMinkowskiDiff) GetM_toshape1() (_swig_ret BtMatrix3x3) { + var swig_r BtMatrix3x3 + _swig_i_0 := arg1 + swig_r = (BtMatrix3x3)(SwigcptrBtMatrix3x3(C._wrap_MinkowskiDiff_m_toshape1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrMinkowskiDiff) SetM_toshape0(arg2 BtTransform) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_MinkowskiDiff_m_toshape0_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrMinkowskiDiff) GetM_toshape0() (_swig_ret BtTransform) { + var swig_r BtTransform + _swig_i_0 := arg1 + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_MinkowskiDiff_m_toshape0_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrMinkowskiDiff) SetLs(arg2 _swig_memberptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_MinkowskiDiff_Ls_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_type_159(_swig_i_1)) +} + +func (arg1 SwigcptrMinkowskiDiff) GetLs() (_swig_ret _swig_memberptr) { + var swig_r _swig_memberptr + _swig_i_0 := arg1 + swig_r = (_swig_memberptr)(C._wrap_MinkowskiDiff_Ls_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + var swig_r_1 _swig_memberptr + + { + type swig_out_type struct { + size int + val uintptr + } + p := (*swig_out_type)(unsafe.Pointer(swig_r)) + if p == nil || p.val == 0 { + swig_r_1 = nil + } else { + m := make([]byte, p.size) + a := (*[1024]byte)(unsafe.Pointer(p.val))[:p.size] + copy(m, a) + Swig_free(p.val) + Swig_free(uintptr(unsafe.Pointer(p))) + swig_r_1 = &m[0] + } + } + + return swig_r_1 +} + +func NewMinkowskiDiff() (_swig_ret MinkowskiDiff) { + var swig_r MinkowskiDiff + swig_r = (MinkowskiDiff)(SwigcptrMinkowskiDiff(C._wrap_new_MinkowskiDiff_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrMinkowskiDiff) EnableMargin(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_MinkowskiDiff_EnableMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrMinkowskiDiff) Support0(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_MinkowskiDiff_Support0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrMinkowskiDiff) Support1(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_MinkowskiDiff_Support1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrMinkowskiDiff) Support__SWIG_0(arg2 BtVector3) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_MinkowskiDiff_Support__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrMinkowskiDiff) Support__SWIG_1(arg2 BtVector3, arg3 uint) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_MinkowskiDiff_Support__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func (p SwigcptrMinkowskiDiff) Support(a ...interface{}) BtVector3 { + argc := len(a) + if argc == 1 { + return p.Support__SWIG_0(a[0].(BtVector3)) + } + if argc == 2 { + return p.Support__SWIG_1(a[0].(BtVector3), a[1].(uint)) + } + panic("No match for overloaded function call") +} + +func DeleteMinkowskiDiff(arg1 MinkowskiDiff) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_MinkowskiDiff_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type MinkowskiDiff interface { + Swigcptr() uintptr + SwigIsMinkowskiDiff() + SetM_shapes(arg2 BtConvexShape) + GetM_shapes() (_swig_ret BtConvexShape) + SetM_toshape1(arg2 BtMatrix3x3) + GetM_toshape1() (_swig_ret BtMatrix3x3) + SetM_toshape0(arg2 BtTransform) + GetM_toshape0() (_swig_ret BtTransform) + SetLs(arg2 _swig_memberptr) + GetLs() (_swig_ret _swig_memberptr) + EnableMargin(arg2 bool) + Support0(arg2 BtVector3) (_swig_ret BtVector3) + Support1(arg2 BtVector3) (_swig_ret BtVector3) + Support(a ...interface{}) BtVector3 +} + +type SwigcptrGJK uintptr + +func (p SwigcptrGJK) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrGJK) SwigIsGJK() { +} + +func (arg1 SwigcptrGJK) SetM_shape(arg2 MinkowskiDiff) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_GJK_m_shape_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) GetM_shape() (_swig_ret MinkowskiDiff) { + var swig_r MinkowskiDiff + _swig_i_0 := arg1 + swig_r = (MinkowskiDiff)(SwigcptrMinkowskiDiff(C._wrap_GJK_m_shape_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrGJK) SetM_ray(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_GJK_m_ray_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) GetM_ray() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_GJK_m_ray_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrGJK) SetM_distance(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_GJK_m_distance_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) GetM_distance() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_GJK_m_distance_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrGJK) SetM_simplices(arg2 Gjkepa2_impl_GJK_sSimplex) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_GJK_m_simplices_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) GetM_simplices() (_swig_ret Gjkepa2_impl_GJK_sSimplex) { + var swig_r Gjkepa2_impl_GJK_sSimplex + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_GJK_sSimplex)(SwigcptrGjkepa2_impl_GJK_sSimplex(C._wrap_GJK_m_simplices_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrGJK) SetM_store(arg2 Gjkepa2_impl_GJK_sSV) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_GJK_m_store_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) GetM_store() (_swig_ret Gjkepa2_impl_GJK_sSV) { + var swig_r Gjkepa2_impl_GJK_sSV + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_GJK_sSV)(SwigcptrGjkepa2_impl_GJK_sSV(C._wrap_GJK_m_store_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrGJK) SetM_free(arg2 Gjkepa2_impl_GJK_sSV) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_GJK_m_free_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) GetM_free() (_swig_ret Gjkepa2_impl_GJK_sSV) { + var swig_r Gjkepa2_impl_GJK_sSV + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_GJK_sSV)(SwigcptrGjkepa2_impl_GJK_sSV(C._wrap_GJK_m_free_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrGJK) SetM_nfree(arg2 uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_GJK_m_nfree_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) GetM_nfree() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_GJK_m_nfree_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrGJK) SetM_current(arg2 uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_GJK_m_current_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) GetM_current() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_GJK_m_current_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrGJK) SetM_simplex(arg2 Gjkepa2_impl_GJK_sSimplex) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_GJK_m_simplex_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) GetM_simplex() (_swig_ret Gjkepa2_impl_GJK_sSimplex) { + var swig_r Gjkepa2_impl_GJK_sSimplex + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_GJK_sSimplex)(SwigcptrGjkepa2_impl_GJK_sSimplex(C._wrap_GJK_m_simplex_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrGJK) SetM_status(arg2 Gjkepa2_impl_GJK_eStatus__) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_GJK_m_status_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) GetM_status() (_swig_ret Gjkepa2_impl_GJK_eStatus__) { + var swig_r Gjkepa2_impl_GJK_eStatus__ + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_GJK_eStatus__)(SwigcptrGjkepa2_impl_GJK_eStatus__(C._wrap_GJK_m_status_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewGJK() (_swig_ret GJK) { + var swig_r GJK + swig_r = (GJK)(SwigcptrGJK(C._wrap_new_GJK_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrGJK) Initialize() { + _swig_i_0 := arg1 + C._wrap_GJK_Initialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrGJK) Evaluate(arg2 MinkowskiDiff, arg3 BtVector3) (_swig_ret Gjkepa2_impl_GJK_eStatus__) { + var swig_r Gjkepa2_impl_GJK_eStatus__ + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (Gjkepa2_impl_GJK_eStatus__)(SwigcptrGjkepa2_impl_GJK_eStatus__(C._wrap_GJK_Evaluate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrGJK) EncloseOrigin() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_GJK_EncloseOrigin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrGJK) Getsupport(arg2 BtVector3, arg3 Gjkepa2_impl_GJK_sSV) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_GJK_getsupport_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrGJK) Removevertice(arg2 Gjkepa2_impl_GJK_sSimplex) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_GJK_removevertice_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrGJK) Appendvertice(arg2 Gjkepa2_impl_GJK_sSimplex, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_GJK_appendvertice_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func GJKDet(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (float32)(C._wrap_GJK_det_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2))) + return swig_r +} + +func GJKProjectorigin__SWIG_0(arg1 BtVector3, arg2 BtVector3, arg3 *float32, arg4 *uint) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + swig_r = (float32)(C._wrap_GJK_projectorigin__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.swig_voidp(_swig_i_3))) + return swig_r +} + +func GJKProjectorigin__SWIG_1(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 *float32, arg5 *uint) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := arg5 + swig_r = (float32)(C._wrap_GJK_projectorigin__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_voidp(_swig_i_3), C.swig_voidp(_swig_i_4))) + return swig_r +} + +func GJKProjectorigin__SWIG_2(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 *float32, arg6 *uint) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + swig_r = (float32)(C._wrap_GJK_projectorigin__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_voidp(_swig_i_4), C.swig_voidp(_swig_i_5))) + return swig_r +} + +func GJKProjectorigin(a ...interface{}) float32 { + argc := len(a) + if argc == 4 { + return GJKProjectorigin__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(*float32), a[3].(*uint)) + } + if argc == 5 { + return GJKProjectorigin__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(*float32), a[4].(*uint)) + } + if argc == 6 { + return GJKProjectorigin__SWIG_2(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(BtVector3), a[4].(*float32), a[5].(*uint)) + } + panic("No match for overloaded function call") +} + +func DeleteGJK(arg1 GJK) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_GJK_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type GJK interface { + Swigcptr() uintptr + SwigIsGJK() + SetM_shape(arg2 MinkowskiDiff) + GetM_shape() (_swig_ret MinkowskiDiff) + SetM_ray(arg2 BtVector3) + GetM_ray() (_swig_ret BtVector3) + SetM_distance(arg2 float32) + GetM_distance() (_swig_ret float32) + SetM_simplices(arg2 Gjkepa2_impl_GJK_sSimplex) + GetM_simplices() (_swig_ret Gjkepa2_impl_GJK_sSimplex) + SetM_store(arg2 Gjkepa2_impl_GJK_sSV) + GetM_store() (_swig_ret Gjkepa2_impl_GJK_sSV) + SetM_free(arg2 Gjkepa2_impl_GJK_sSV) + GetM_free() (_swig_ret Gjkepa2_impl_GJK_sSV) + SetM_nfree(arg2 uint) + GetM_nfree() (_swig_ret uint) + SetM_current(arg2 uint) + GetM_current() (_swig_ret uint) + SetM_simplex(arg2 Gjkepa2_impl_GJK_sSimplex) + GetM_simplex() (_swig_ret Gjkepa2_impl_GJK_sSimplex) + SetM_status(arg2 Gjkepa2_impl_GJK_eStatus__) + GetM_status() (_swig_ret Gjkepa2_impl_GJK_eStatus__) + Initialize() + Evaluate(arg2 MinkowskiDiff, arg3 BtVector3) (_swig_ret Gjkepa2_impl_GJK_eStatus__) + EncloseOrigin() (_swig_ret bool) + Getsupport(arg2 BtVector3, arg3 Gjkepa2_impl_GJK_sSV) + Removevertice(arg2 Gjkepa2_impl_GJK_sSimplex) + Appendvertice(arg2 Gjkepa2_impl_GJK_sSimplex, arg3 BtVector3) +} + +type SwigcptrEPA uintptr + +func (p SwigcptrEPA) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrEPA) SwigIsEPA() { +} + +func (arg1 SwigcptrEPA) SetM_status(arg2 Gjkepa2_impl_EPA_eStatus__) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_EPA_m_status_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrEPA) GetM_status() (_swig_ret Gjkepa2_impl_EPA_eStatus__) { + var swig_r Gjkepa2_impl_EPA_eStatus__ + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_EPA_eStatus__)(SwigcptrGjkepa2_impl_EPA_eStatus__(C._wrap_EPA_m_status_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrEPA) SetM_result(arg2 Gjkepa2_impl_GJK_sSimplex) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_EPA_m_result_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrEPA) GetM_result() (_swig_ret Gjkepa2_impl_GJK_sSimplex) { + var swig_r Gjkepa2_impl_GJK_sSimplex + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_GJK_sSimplex)(SwigcptrGjkepa2_impl_GJK_sSimplex(C._wrap_EPA_m_result_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrEPA) SetM_normal(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_EPA_m_normal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrEPA) GetM_normal() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_EPA_m_normal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrEPA) SetM_depth(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_EPA_m_depth_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrEPA) GetM_depth() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_EPA_m_depth_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrEPA) SetM_sv_store(arg2 Gjkepa2_impl_GJK_sSV) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_EPA_m_sv_store_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrEPA) GetM_sv_store() (_swig_ret Gjkepa2_impl_GJK_sSV) { + var swig_r Gjkepa2_impl_GJK_sSV + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_GJK_sSV)(SwigcptrGjkepa2_impl_GJK_sSV(C._wrap_EPA_m_sv_store_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrEPA) SetM_fc_store(arg2 Gjkepa2_impl_EPA_sFace) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_EPA_m_fc_store_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrEPA) GetM_fc_store() (_swig_ret Gjkepa2_impl_EPA_sFace) { + var swig_r Gjkepa2_impl_EPA_sFace + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_EPA_sFace)(SwigcptrGjkepa2_impl_EPA_sFace(C._wrap_EPA_m_fc_store_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrEPA) SetM_nextsv(arg2 uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_EPA_m_nextsv_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrEPA) GetM_nextsv() (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + swig_r = (uint)(C._wrap_EPA_m_nextsv_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrEPA) SetM_hull(arg2 Gjkepa2_impl_EPA_sList) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_EPA_m_hull_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrEPA) GetM_hull() (_swig_ret Gjkepa2_impl_EPA_sList) { + var swig_r Gjkepa2_impl_EPA_sList + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_EPA_sList)(SwigcptrGjkepa2_impl_EPA_sList(C._wrap_EPA_m_hull_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrEPA) SetM_stock(arg2 Gjkepa2_impl_EPA_sList) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_EPA_m_stock_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrEPA) GetM_stock() (_swig_ret Gjkepa2_impl_EPA_sList) { + var swig_r Gjkepa2_impl_EPA_sList + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_EPA_sList)(SwigcptrGjkepa2_impl_EPA_sList(C._wrap_EPA_m_stock_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewEPA() (_swig_ret EPA) { + var swig_r EPA + swig_r = (EPA)(SwigcptrEPA(C._wrap_new_EPA_mbt_e879218550ba2e2b())) + return swig_r +} + +func EPABind(arg1 Gjkepa2_impl_EPA_sFace, arg2 uint, arg3 Gjkepa2_impl_EPA_sFace, arg4 uint) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_EPA_bind_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func EPAAppend(arg1 Gjkepa2_impl_EPA_sList, arg2 Gjkepa2_impl_EPA_sFace) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_EPA_append_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func EPARemove(arg1 Gjkepa2_impl_EPA_sList, arg2 Gjkepa2_impl_EPA_sFace) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_EPA_remove_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrEPA) Initialize() { + _swig_i_0 := arg1 + C._wrap_EPA_Initialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrEPA) Evaluate(arg2 GJK, arg3 BtVector3) (_swig_ret Gjkepa2_impl_EPA_eStatus__) { + var swig_r Gjkepa2_impl_EPA_eStatus__ + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (Gjkepa2_impl_EPA_eStatus__)(SwigcptrGjkepa2_impl_EPA_eStatus__(C._wrap_EPA_Evaluate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrEPA) Getedgedist(arg2 Gjkepa2_impl_EPA_sFace, arg3 Gjkepa2_impl_GJK_sSV, arg4 Gjkepa2_impl_GJK_sSV, arg5 *float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (bool)(C._wrap_EPA_getedgedist_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_voidp(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrEPA) Newface(arg2 Gjkepa2_impl_GJK_sSV, arg3 Gjkepa2_impl_GJK_sSV, arg4 Gjkepa2_impl_GJK_sSV, arg5 bool) (_swig_ret Gjkepa2_impl_EPA_sFace) { + var swig_r Gjkepa2_impl_EPA_sFace + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (Gjkepa2_impl_EPA_sFace)(SwigcptrGjkepa2_impl_EPA_sFace(C._wrap_EPA_newface_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4)))) + return swig_r +} + +func (arg1 SwigcptrEPA) Findbest() (_swig_ret Gjkepa2_impl_EPA_sFace) { + var swig_r Gjkepa2_impl_EPA_sFace + _swig_i_0 := arg1 + swig_r = (Gjkepa2_impl_EPA_sFace)(SwigcptrGjkepa2_impl_EPA_sFace(C._wrap_EPA_findbest_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrEPA) Expand(arg2 uint, arg3 Gjkepa2_impl_GJK_sSV, arg4 Gjkepa2_impl_EPA_sFace, arg5 uint, arg6 Gjkepa2_impl_EPA_sHorizon) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_EPA_expand_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_intgo(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func DeleteEPA(arg1 EPA) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_EPA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type EPA interface { + Swigcptr() uintptr + SwigIsEPA() + SetM_status(arg2 Gjkepa2_impl_EPA_eStatus__) + GetM_status() (_swig_ret Gjkepa2_impl_EPA_eStatus__) + SetM_result(arg2 Gjkepa2_impl_GJK_sSimplex) + GetM_result() (_swig_ret Gjkepa2_impl_GJK_sSimplex) + SetM_normal(arg2 BtVector3) + GetM_normal() (_swig_ret BtVector3) + SetM_depth(arg2 float32) + GetM_depth() (_swig_ret float32) + SetM_sv_store(arg2 Gjkepa2_impl_GJK_sSV) + GetM_sv_store() (_swig_ret Gjkepa2_impl_GJK_sSV) + SetM_fc_store(arg2 Gjkepa2_impl_EPA_sFace) + GetM_fc_store() (_swig_ret Gjkepa2_impl_EPA_sFace) + SetM_nextsv(arg2 uint) + GetM_nextsv() (_swig_ret uint) + SetM_hull(arg2 Gjkepa2_impl_EPA_sList) + GetM_hull() (_swig_ret Gjkepa2_impl_EPA_sList) + SetM_stock(arg2 Gjkepa2_impl_EPA_sList) + GetM_stock() (_swig_ret Gjkepa2_impl_EPA_sList) + Initialize() + Evaluate(arg2 GJK, arg3 BtVector3) (_swig_ret Gjkepa2_impl_EPA_eStatus__) + Getedgedist(arg2 Gjkepa2_impl_EPA_sFace, arg3 Gjkepa2_impl_GJK_sSV, arg4 Gjkepa2_impl_GJK_sSV, arg5 *float32) (_swig_ret bool) + Newface(arg2 Gjkepa2_impl_GJK_sSV, arg3 Gjkepa2_impl_GJK_sSV, arg4 Gjkepa2_impl_GJK_sSV, arg5 bool) (_swig_ret Gjkepa2_impl_EPA_sFace) + Findbest() (_swig_ret Gjkepa2_impl_EPA_sFace) + Expand(arg2 uint, arg3 Gjkepa2_impl_GJK_sSV, arg4 Gjkepa2_impl_EPA_sFace, arg5 uint, arg6 Gjkepa2_impl_EPA_sHorizon) (_swig_ret bool) +} + +func Initialize(arg1 BtConvexShape, arg2 BtTransform, arg3 BtConvexShape, arg4 BtTransform, arg5 BtGjkEpaSolver2_sResults, arg6 MinkowskiDiff, arg7 bool) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := arg7 + C._wrap_Initialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C._Bool(_swig_i_6)) +} + +type SwigcptrBtCollisionConfiguration uintptr + +func (p SwigcptrBtCollisionConfiguration) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionConfiguration) SwigIsBtCollisionConfiguration() { +} + +func DeleteBtCollisionConfiguration(arg1 BtCollisionConfiguration) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionConfiguration_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionConfiguration) GetPersistentManifoldPool() (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_btCollisionConfiguration_getPersistentManifoldPool_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionConfiguration) GetCollisionAlgorithmPool() (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_btCollisionConfiguration_getCollisionAlgorithmPool_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionConfiguration) GetCollisionAlgorithmCreateFunc(arg2 int, arg3 int) (_swig_ret BtCollisionAlgorithmCreateFunc) { + var swig_r BtCollisionAlgorithmCreateFunc + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtCollisionAlgorithmCreateFunc)(SwigcptrBtCollisionAlgorithmCreateFunc(C._wrap_btCollisionConfiguration_getCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionConfiguration) GetClosestPointsAlgorithmCreateFunc(arg2 int, arg3 int) (_swig_ret BtCollisionAlgorithmCreateFunc) { + var swig_r BtCollisionAlgorithmCreateFunc + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtCollisionAlgorithmCreateFunc)(SwigcptrBtCollisionAlgorithmCreateFunc(C._wrap_btCollisionConfiguration_getClosestPointsAlgorithmCreateFunc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +type BtCollisionConfiguration interface { + Swigcptr() uintptr + SwigIsBtCollisionConfiguration() + GetPersistentManifoldPool() (_swig_ret BtPoolAllocator) + GetCollisionAlgorithmPool() (_swig_ret BtPoolAllocator) + GetCollisionAlgorithmCreateFunc(arg2 int, arg3 int) (_swig_ret BtCollisionAlgorithmCreateFunc) + GetClosestPointsAlgorithmCreateFunc(arg2 int, arg3 int) (_swig_ret BtCollisionAlgorithmCreateFunc) +} + +type SwigcptrBtDefaultCollisionConstructionInfo uintptr + +func (p SwigcptrBtDefaultCollisionConstructionInfo) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDefaultCollisionConstructionInfo) SwigIsBtDefaultCollisionConstructionInfo() { +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) SetM_persistentManifoldPool(arg2 BtPoolAllocator) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDefaultCollisionConstructionInfo_m_persistentManifoldPool_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) GetM_persistentManifoldPool() (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_btDefaultCollisionConstructionInfo_m_persistentManifoldPool_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) SetM_collisionAlgorithmPool(arg2 BtPoolAllocator) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btDefaultCollisionConstructionInfo_m_collisionAlgorithmPool_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) GetM_collisionAlgorithmPool() (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_btDefaultCollisionConstructionInfo_m_collisionAlgorithmPool_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) SetM_defaultMaxPersistentManifoldPoolSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDefaultCollisionConstructionInfo_m_defaultMaxPersistentManifoldPoolSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) GetM_defaultMaxPersistentManifoldPoolSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDefaultCollisionConstructionInfo_m_defaultMaxPersistentManifoldPoolSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) SetM_defaultMaxCollisionAlgorithmPoolSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDefaultCollisionConstructionInfo_m_defaultMaxCollisionAlgorithmPoolSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) GetM_defaultMaxCollisionAlgorithmPoolSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDefaultCollisionConstructionInfo_m_defaultMaxCollisionAlgorithmPoolSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) SetM_customCollisionAlgorithmMaxElementSize(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDefaultCollisionConstructionInfo_m_customCollisionAlgorithmMaxElementSize_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) GetM_customCollisionAlgorithmMaxElementSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDefaultCollisionConstructionInfo_m_customCollisionAlgorithmMaxElementSize_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) SetM_useEpaPenetrationAlgorithm(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDefaultCollisionConstructionInfo_m_useEpaPenetrationAlgorithm_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultCollisionConstructionInfo) GetM_useEpaPenetrationAlgorithm() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btDefaultCollisionConstructionInfo_m_useEpaPenetrationAlgorithm_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtDefaultCollisionConstructionInfo() (_swig_ret BtDefaultCollisionConstructionInfo) { + var swig_r BtDefaultCollisionConstructionInfo + swig_r = (BtDefaultCollisionConstructionInfo)(SwigcptrBtDefaultCollisionConstructionInfo(C._wrap_new_btDefaultCollisionConstructionInfo_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtDefaultCollisionConstructionInfo(arg1 BtDefaultCollisionConstructionInfo) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDefaultCollisionConstructionInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtDefaultCollisionConstructionInfo interface { + Swigcptr() uintptr + SwigIsBtDefaultCollisionConstructionInfo() + SetM_persistentManifoldPool(arg2 BtPoolAllocator) + GetM_persistentManifoldPool() (_swig_ret BtPoolAllocator) + SetM_collisionAlgorithmPool(arg2 BtPoolAllocator) + GetM_collisionAlgorithmPool() (_swig_ret BtPoolAllocator) + SetM_defaultMaxPersistentManifoldPoolSize(arg2 int) + GetM_defaultMaxPersistentManifoldPoolSize() (_swig_ret int) + SetM_defaultMaxCollisionAlgorithmPoolSize(arg2 int) + GetM_defaultMaxCollisionAlgorithmPoolSize() (_swig_ret int) + SetM_customCollisionAlgorithmMaxElementSize(arg2 int) + GetM_customCollisionAlgorithmMaxElementSize() (_swig_ret int) + SetM_useEpaPenetrationAlgorithm(arg2 int) + GetM_useEpaPenetrationAlgorithm() (_swig_ret int) +} + +type SwigcptrBtDefaultCollisionConfiguration uintptr + +func (p SwigcptrBtDefaultCollisionConfiguration) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtDefaultCollisionConfiguration) SwigIsBtDefaultCollisionConfiguration() { +} + +func NewBtDefaultCollisionConfiguration__SWIG_0(arg1 BtDefaultCollisionConstructionInfo) (_swig_ret BtDefaultCollisionConfiguration) { + var swig_r BtDefaultCollisionConfiguration + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtDefaultCollisionConfiguration)(SwigcptrBtDefaultCollisionConfiguration(C._wrap_new_btDefaultCollisionConfiguration__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtDefaultCollisionConfiguration__SWIG_1() (_swig_ret BtDefaultCollisionConfiguration) { + var swig_r BtDefaultCollisionConfiguration + swig_r = (BtDefaultCollisionConfiguration)(SwigcptrBtDefaultCollisionConfiguration(C._wrap_new_btDefaultCollisionConfiguration__SWIG_1_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtDefaultCollisionConfiguration(a ...interface{}) BtDefaultCollisionConfiguration { + argc := len(a) + if argc == 0 { + return NewBtDefaultCollisionConfiguration__SWIG_1() + } + if argc == 1 { + return NewBtDefaultCollisionConfiguration__SWIG_0(a[0].(BtDefaultCollisionConstructionInfo)) + } + panic("No match for overloaded function call") +} + +func DeleteBtDefaultCollisionConfiguration(arg1 BtDefaultCollisionConfiguration) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btDefaultCollisionConfiguration_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtDefaultCollisionConfiguration) GetPersistentManifoldPool() (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_btDefaultCollisionConfiguration_getPersistentManifoldPool_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultCollisionConfiguration) GetCollisionAlgorithmPool() (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_btDefaultCollisionConfiguration_getCollisionAlgorithmPool_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultCollisionConfiguration) GetCollisionAlgorithmCreateFunc(arg2 int, arg3 int) (_swig_ret BtCollisionAlgorithmCreateFunc) { + var swig_r BtCollisionAlgorithmCreateFunc + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtCollisionAlgorithmCreateFunc)(SwigcptrBtCollisionAlgorithmCreateFunc(C._wrap_btDefaultCollisionConfiguration_getCollisionAlgorithmCreateFunc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultCollisionConfiguration) GetClosestPointsAlgorithmCreateFunc(arg2 int, arg3 int) (_swig_ret BtCollisionAlgorithmCreateFunc) { + var swig_r BtCollisionAlgorithmCreateFunc + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtCollisionAlgorithmCreateFunc)(SwigcptrBtCollisionAlgorithmCreateFunc(C._wrap_btDefaultCollisionConfiguration_getClosestPointsAlgorithmCreateFunc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtDefaultCollisionConfiguration) SetConvexConvexMultipointIterations__SWIG_0(arg2 int, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btDefaultCollisionConfiguration_setConvexConvexMultipointIterations__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtDefaultCollisionConfiguration) SetConvexConvexMultipointIterations__SWIG_1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDefaultCollisionConfiguration_setConvexConvexMultipointIterations__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultCollisionConfiguration) SetConvexConvexMultipointIterations__SWIG_2() { + _swig_i_0 := arg1 + C._wrap_btDefaultCollisionConfiguration_setConvexConvexMultipointIterations__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtDefaultCollisionConfiguration) SetConvexConvexMultipointIterations(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.SetConvexConvexMultipointIterations__SWIG_2() + return + } + if argc == 1 { + p.SetConvexConvexMultipointIterations__SWIG_1(a[0].(int)) + return + } + if argc == 2 { + p.SetConvexConvexMultipointIterations__SWIG_0(a[0].(int), a[1].(int)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtDefaultCollisionConfiguration) SetPlaneConvexMultipointIterations__SWIG_0(arg2 int, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btDefaultCollisionConfiguration_setPlaneConvexMultipointIterations__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (arg1 SwigcptrBtDefaultCollisionConfiguration) SetPlaneConvexMultipointIterations__SWIG_1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btDefaultCollisionConfiguration_setPlaneConvexMultipointIterations__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtDefaultCollisionConfiguration) SetPlaneConvexMultipointIterations__SWIG_2() { + _swig_i_0 := arg1 + C._wrap_btDefaultCollisionConfiguration_setPlaneConvexMultipointIterations__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtDefaultCollisionConfiguration) SetPlaneConvexMultipointIterations(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.SetPlaneConvexMultipointIterations__SWIG_2() + return + } + if argc == 1 { + p.SetPlaneConvexMultipointIterations__SWIG_1(a[0].(int)) + return + } + if argc == 2 { + p.SetPlaneConvexMultipointIterations__SWIG_0(a[0].(int), a[1].(int)) + return + } + panic("No match for overloaded function call") +} + +func (p SwigcptrBtDefaultCollisionConfiguration) SwigIsBtCollisionConfiguration() { +} + +func (p SwigcptrBtDefaultCollisionConfiguration) SwigGetBtCollisionConfiguration() BtCollisionConfiguration { + return SwigcptrBtCollisionConfiguration(getSwigcptr(p)) +} + +type BtDefaultCollisionConfiguration interface { + Swigcptr() uintptr + SwigIsBtDefaultCollisionConfiguration() + GetPersistentManifoldPool() (_swig_ret BtPoolAllocator) + GetCollisionAlgorithmPool() (_swig_ret BtPoolAllocator) + GetCollisionAlgorithmCreateFunc(arg2 int, arg3 int) (_swig_ret BtCollisionAlgorithmCreateFunc) + GetClosestPointsAlgorithmCreateFunc(arg2 int, arg3 int) (_swig_ret BtCollisionAlgorithmCreateFunc) + SetConvexConvexMultipointIterations(a ...interface{}) + SetPlaneConvexMultipointIterations(a ...interface{}) + SwigIsBtCollisionConfiguration() + SwigGetBtCollisionConfiguration() BtCollisionConfiguration +} + +type SwigcptrBtCollisionAlgorithmConstructionInfo uintptr + +func (p SwigcptrBtCollisionAlgorithmConstructionInfo) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionAlgorithmConstructionInfo) SwigIsBtCollisionAlgorithmConstructionInfo() { +} + +func NewBtCollisionAlgorithmConstructionInfo__SWIG_0() (_swig_ret BtCollisionAlgorithmConstructionInfo) { + var swig_r BtCollisionAlgorithmConstructionInfo + swig_r = (BtCollisionAlgorithmConstructionInfo)(SwigcptrBtCollisionAlgorithmConstructionInfo(C._wrap_new_btCollisionAlgorithmConstructionInfo__SWIG_0_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtCollisionAlgorithmConstructionInfo__SWIG_1(arg1 BtDispatcher, arg2 int) (_swig_ret BtCollisionAlgorithmConstructionInfo) { + var swig_r BtCollisionAlgorithmConstructionInfo + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtCollisionAlgorithmConstructionInfo)(SwigcptrBtCollisionAlgorithmConstructionInfo(C._wrap_new_btCollisionAlgorithmConstructionInfo__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func NewBtCollisionAlgorithmConstructionInfo(a ...interface{}) BtCollisionAlgorithmConstructionInfo { + argc := len(a) + if argc == 0 { + return NewBtCollisionAlgorithmConstructionInfo__SWIG_0() + } + if argc == 2 { + return NewBtCollisionAlgorithmConstructionInfo__SWIG_1(a[0].(BtDispatcher), a[1].(int)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtCollisionAlgorithmConstructionInfo) SetM_dispatcher1(arg2 BtDispatcher) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionAlgorithmConstructionInfo_m_dispatcher1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionAlgorithmConstructionInfo) GetM_dispatcher1() (_swig_ret BtDispatcher) { + var swig_r BtDispatcher + _swig_i_0 := arg1 + swig_r = (BtDispatcher)(SwigcptrBtDispatcher(C._wrap_btCollisionAlgorithmConstructionInfo_m_dispatcher1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionAlgorithmConstructionInfo) SetM_manifold(arg2 BtPersistentManifold) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionAlgorithmConstructionInfo_m_manifold_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtCollisionAlgorithmConstructionInfo) GetM_manifold() (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btCollisionAlgorithmConstructionInfo_m_manifold_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func DeleteBtCollisionAlgorithmConstructionInfo(arg1 BtCollisionAlgorithmConstructionInfo) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionAlgorithmConstructionInfo_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtCollisionAlgorithmConstructionInfo interface { + Swigcptr() uintptr + SwigIsBtCollisionAlgorithmConstructionInfo() + SetM_dispatcher1(arg2 BtDispatcher) + GetM_dispatcher1() (_swig_ret BtDispatcher) + SetM_manifold(arg2 BtPersistentManifold) + GetM_manifold() (_swig_ret BtPersistentManifold) +} + +type SwigcptrBtCollisionAlgorithm uintptr + +func (p SwigcptrBtCollisionAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCollisionAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func DeleteBtCollisionAlgorithm(arg1 BtCollisionAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCollisionAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtCollisionAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtCollisionAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +type BtCollisionAlgorithm interface { + Swigcptr() uintptr + SwigIsBtCollisionAlgorithm() + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) +} + +type SwigcptrBtActivatingCollisionAlgorithm uintptr + +func (p SwigcptrBtActivatingCollisionAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtActivatingCollisionAlgorithm) SwigIsBtActivatingCollisionAlgorithm() { +} + +func DeleteBtActivatingCollisionAlgorithm(arg1 BtActivatingCollisionAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btActivatingCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtActivatingCollisionAlgorithm) ProcessCollision(arg1 BtCollisionObjectWrapper, arg2 BtCollisionObjectWrapper, arg3 BtDispatcherInfo, arg4 BtManifoldResult) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btActivatingCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (_swig_base SwigcptrBtActivatingCollisionAlgorithm) CalculateTimeOfImpact(arg1 BtCollisionObject, arg2 BtCollisionObject, arg3 BtDispatcherInfo, arg4 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (float32)(C._wrap_btActivatingCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +func (_swig_base SwigcptrBtActivatingCollisionAlgorithm) GetAllContactManifolds(arg1 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btActivatingCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtActivatingCollisionAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtActivatingCollisionAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtActivatingCollisionAlgorithm interface { + Swigcptr() uintptr + SwigIsBtActivatingCollisionAlgorithm() + ProcessCollision(arg1 BtCollisionObjectWrapper, arg2 BtCollisionObjectWrapper, arg3 BtDispatcherInfo, arg4 BtManifoldResult) + CalculateTimeOfImpact(arg1 BtCollisionObject, arg2 BtCollisionObject, arg3 BtDispatcherInfo, arg4 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg1 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +type SwigcptrBtPolyhedralContactClipping uintptr + +func (p SwigcptrBtPolyhedralContactClipping) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtPolyhedralContactClipping) SwigIsBtPolyhedralContactClipping() { +} + +func BtPolyhedralContactClippingClipHullAgainstHull(arg1 BtVector3, arg2 BtConvexPolyhedron, arg3 BtConvexPolyhedron, arg4 BtTransform, arg5 BtTransform, arg6 float32, arg7 float32, arg8 BtAlignedObjectArray_Sl_btVector3_Sg_, arg9 BtAlignedObjectArray_Sl_btVector3_Sg_, arg10 BtDiscreteCollisionDetectorInterface_Result) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := getSwigcptr(arg10) + C._wrap_btPolyhedralContactClipping_clipHullAgainstHull_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.uintptr_t(_swig_i_7), C.uintptr_t(_swig_i_8), C.uintptr_t(_swig_i_9)) +} + +func BtPolyhedralContactClippingClipFaceAgainstHull(arg1 BtVector3, arg2 BtConvexPolyhedron, arg3 BtTransform, arg4 BtAlignedObjectArray_Sl_btVector3_Sg_, arg5 BtAlignedObjectArray_Sl_btVector3_Sg_, arg6 float32, arg7 float32, arg8 BtDiscreteCollisionDetectorInterface_Result) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := getSwigcptr(arg8) + C._wrap_btPolyhedralContactClipping_clipFaceAgainstHull_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.uintptr_t(_swig_i_7)) +} + +func BtPolyhedralContactClippingFindSeparatingAxis(arg1 BtConvexPolyhedron, arg2 BtConvexPolyhedron, arg3 BtTransform, arg4 BtTransform, arg5 BtVector3, arg6 BtDiscreteCollisionDetectorInterface_Result) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + swig_r = (bool)(C._wrap_btPolyhedralContactClipping_findSeparatingAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5))) + return swig_r +} + +func BtPolyhedralContactClippingClipFace(arg1 BtAlignedObjectArray_Sl_btVector3_Sg_, arg2 BtAlignedObjectArray_Sl_btVector3_Sg_, arg3 BtVector3, arg4 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + C._wrap_btPolyhedralContactClipping_clipFace_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3)) +} + +func NewBtPolyhedralContactClipping() (_swig_ret BtPolyhedralContactClipping) { + var swig_r BtPolyhedralContactClipping + swig_r = (BtPolyhedralContactClipping)(SwigcptrBtPolyhedralContactClipping(C._wrap_new_btPolyhedralContactClipping_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtPolyhedralContactClipping(arg1 BtPolyhedralContactClipping) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btPolyhedralContactClipping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtPolyhedralContactClipping interface { + Swigcptr() uintptr + SwigIsBtPolyhedralContactClipping() +} + +type SwigcptrBtConvexConvexAlgorithm uintptr + +func (p SwigcptrBtConvexConvexAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexConvexAlgorithm) SwigIsBtConvexConvexAlgorithm() { +} + +func NewBtConvexConvexAlgorithm(arg1 BtPersistentManifold, arg2 BtCollisionAlgorithmConstructionInfo, arg3 BtCollisionObjectWrapper, arg4 BtCollisionObjectWrapper, arg5 BtConvexPenetrationDepthSolver, arg6 int, arg7 int) (_swig_ret BtConvexConvexAlgorithm) { + var swig_r BtConvexConvexAlgorithm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + _swig_i_6 := arg7 + swig_r = (BtConvexConvexAlgorithm)(SwigcptrBtConvexConvexAlgorithm(C._wrap_new_btConvexConvexAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.swig_intgo(_swig_i_5), C.swig_intgo(_swig_i_6)))) + return swig_r +} + +func DeleteBtConvexConvexAlgorithm(arg1 BtConvexConvexAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexConvexAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexConvexAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btConvexConvexAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtConvexConvexAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btConvexConvexAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtConvexConvexAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexConvexAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexConvexAlgorithm) SetLowLevelOfDetail(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConvexConvexAlgorithm_setLowLevelOfDetail_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexConvexAlgorithm) GetManifold() (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btConvexConvexAlgorithm_getManifold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtConvexConvexAlgorithm) SwigIsBtActivatingCollisionAlgorithm() { +} + +func (p SwigcptrBtConvexConvexAlgorithm) SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm { + return SwigcptrBtActivatingCollisionAlgorithm(getSwigcptr(p)) +} + +func (p SwigcptrBtConvexConvexAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtConvexConvexAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtConvexConvexAlgorithm interface { + Swigcptr() uintptr + SwigIsBtConvexConvexAlgorithm() + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + SetLowLevelOfDetail(arg2 bool) + GetManifold() (_swig_ret BtPersistentManifold) + SwigIsBtActivatingCollisionAlgorithm() + SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +type SwigcptrBtEmptyAlgorithm uintptr + +func (p SwigcptrBtEmptyAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtEmptyAlgorithm) SwigIsBtEmptyAlgorithm() { +} + +func NewBtEmptyAlgorithm(arg1 BtCollisionAlgorithmConstructionInfo) (_swig_ret BtEmptyAlgorithm) { + var swig_r BtEmptyAlgorithm + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtEmptyAlgorithm)(SwigcptrBtEmptyAlgorithm(C._wrap_new_btEmptyAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtEmptyAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btEmptyAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtEmptyAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btEmptyAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtEmptyAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btEmptyAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBtEmptyAlgorithm(arg1 BtEmptyAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btEmptyAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtEmptyAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtEmptyAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtEmptyAlgorithm interface { + Swigcptr() uintptr + SwigIsBtEmptyAlgorithm() + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +type SwigcptrBtConvexTriangleCallback uintptr + +func (p SwigcptrBtConvexTriangleCallback) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexTriangleCallback) SwigIsBtConvexTriangleCallback() { +} + +func (arg1 SwigcptrBtConvexTriangleCallback) SetM_triangleCount(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btConvexTriangleCallback_m_triangleCount_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexTriangleCallback) GetM_triangleCount() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btConvexTriangleCallback_m_triangleCount_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtConvexTriangleCallback) SetM_manifoldPtr(arg2 BtPersistentManifold) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexTriangleCallback_m_manifoldPtr_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexTriangleCallback) GetM_manifoldPtr() (_swig_ret BtPersistentManifold) { + var swig_r BtPersistentManifold + _swig_i_0 := arg1 + swig_r = (BtPersistentManifold)(SwigcptrBtPersistentManifold(C._wrap_btConvexTriangleCallback_m_manifoldPtr_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtConvexTriangleCallback(arg1 BtDispatcher, arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 bool) (_swig_ret BtConvexTriangleCallback) { + var swig_r BtConvexTriangleCallback + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + swig_r = (BtConvexTriangleCallback)(SwigcptrBtConvexTriangleCallback(C._wrap_new_btConvexTriangleCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C._Bool(_swig_i_3)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexTriangleCallback) SetTimeStepAndCounters(arg2 float32, arg3 BtDispatcherInfo, arg4 BtCollisionObjectWrapper, arg5 BtCollisionObjectWrapper, arg6 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btConvexTriangleCallback_setTimeStepAndCounters_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtConvexTriangleCallback) ClearWrapperData() { + _swig_i_0 := arg1 + C._wrap_btConvexTriangleCallback_clearWrapperData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func DeleteBtConvexTriangleCallback(arg1 BtConvexTriangleCallback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexTriangleCallback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexTriangleCallback) ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btConvexTriangleCallback_processTriangle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3)) +} + +func (arg1 SwigcptrBtConvexTriangleCallback) ClearCache() { + _swig_i_0 := arg1 + C._wrap_btConvexTriangleCallback_clearCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexTriangleCallback) GetAabbMin() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexTriangleCallback_getAabbMin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtConvexTriangleCallback) GetAabbMax() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btConvexTriangleCallback_getAabbMax_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtConvexTriangleCallback) SwigIsBtTriangleCallback() { +} + +func (p SwigcptrBtConvexTriangleCallback) SwigGetBtTriangleCallback() BtTriangleCallback { + return SwigcptrBtTriangleCallback(getSwigcptr(p)) +} + +type BtConvexTriangleCallback interface { + Swigcptr() uintptr + SwigIsBtConvexTriangleCallback() + SetM_triangleCount(arg2 int) + GetM_triangleCount() (_swig_ret int) + SetM_manifoldPtr(arg2 BtPersistentManifold) + GetM_manifoldPtr() (_swig_ret BtPersistentManifold) + SetTimeStepAndCounters(arg2 float32, arg3 BtDispatcherInfo, arg4 BtCollisionObjectWrapper, arg5 BtCollisionObjectWrapper, arg6 BtManifoldResult) + ClearWrapperData() + ProcessTriangle(arg2 BtVector3, arg3 int, arg4 int) + ClearCache() + GetAabbMin() (_swig_ret BtVector3) + GetAabbMax() (_swig_ret BtVector3) + SwigIsBtTriangleCallback() + SwigGetBtTriangleCallback() BtTriangleCallback +} + +type SwigcptrBtConvexConcaveCollisionAlgorithm uintptr + +func (p SwigcptrBtConvexConcaveCollisionAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexConcaveCollisionAlgorithm) SwigIsBtConvexConcaveCollisionAlgorithm() { +} + +func NewBtConvexConcaveCollisionAlgorithm(arg1 BtCollisionAlgorithmConstructionInfo, arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 bool) (_swig_ret BtConvexConcaveCollisionAlgorithm) { + var swig_r BtConvexConcaveCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + swig_r = (BtConvexConcaveCollisionAlgorithm)(SwigcptrBtConvexConcaveCollisionAlgorithm(C._wrap_new_btConvexConcaveCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C._Bool(_swig_i_3)))) + return swig_r +} + +func DeleteBtConvexConcaveCollisionAlgorithm(arg1 BtConvexConcaveCollisionAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexConcaveCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexConcaveCollisionAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btConvexConcaveCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtConvexConcaveCollisionAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btConvexConcaveCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtConvexConcaveCollisionAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexConcaveCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtConvexConcaveCollisionAlgorithm) ClearCache() { + _swig_i_0 := arg1 + C._wrap_btConvexConcaveCollisionAlgorithm_clearCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtConvexConcaveCollisionAlgorithm) SwigIsBtActivatingCollisionAlgorithm() { +} + +func (p SwigcptrBtConvexConcaveCollisionAlgorithm) SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm { + return SwigcptrBtActivatingCollisionAlgorithm(getSwigcptr(p)) +} + +func (p SwigcptrBtConvexConcaveCollisionAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtConvexConcaveCollisionAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtConvexConcaveCollisionAlgorithm interface { + Swigcptr() uintptr + SwigIsBtConvexConcaveCollisionAlgorithm() + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + ClearCache() + SwigIsBtActivatingCollisionAlgorithm() + SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +func SetGCompoundChildShapePairCallback(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_gCompoundChildShapePairCallback_set_mbt_e879218550ba2e2b(C.swig_type_161(_swig_i_0)) +} + +func GetGCompoundChildShapePairCallback() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_gCompoundChildShapePairCallback_get_mbt_e879218550ba2e2b()) + return swig_r +} + +type SwigcptrBtCompoundCollisionAlgorithm uintptr + +func (p SwigcptrBtCompoundCollisionAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCompoundCollisionAlgorithm) SwigIsBtCompoundCollisionAlgorithm() { +} + +func NewBtCompoundCollisionAlgorithm(arg1 BtCollisionAlgorithmConstructionInfo, arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 bool) (_swig_ret BtCompoundCollisionAlgorithm) { + var swig_r BtCompoundCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + swig_r = (BtCompoundCollisionAlgorithm)(SwigcptrBtCompoundCollisionAlgorithm(C._wrap_new_btCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C._Bool(_swig_i_3)))) + return swig_r +} + +func DeleteBtCompoundCollisionAlgorithm(arg1 BtCompoundCollisionAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCompoundCollisionAlgorithm) GetChildAlgorithm(arg2 int) (_swig_ret BtCollisionAlgorithm) { + var swig_r BtCollisionAlgorithm + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtCollisionAlgorithm)(SwigcptrBtCollisionAlgorithm(C._wrap_btCompoundCollisionAlgorithm_getChildAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtCompoundCollisionAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btCompoundCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtCompoundCollisionAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btCompoundCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtCompoundCollisionAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCompoundCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtCompoundCollisionAlgorithm) SwigIsBtActivatingCollisionAlgorithm() { +} + +func (p SwigcptrBtCompoundCollisionAlgorithm) SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm { + return SwigcptrBtActivatingCollisionAlgorithm(getSwigcptr(p)) +} + +func (p SwigcptrBtCompoundCollisionAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtCompoundCollisionAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtCompoundCollisionAlgorithm interface { + Swigcptr() uintptr + SwigIsBtCompoundCollisionAlgorithm() + GetChildAlgorithm(arg2 int) (_swig_ret BtCollisionAlgorithm) + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + SwigIsBtActivatingCollisionAlgorithm() + SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +func GetBT_SIMPLE_NULL_PAIR() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_BT_SIMPLE_NULL_PAIR_get_mbt_e879218550ba2e2b()) + return swig_r +} + +type SwigcptrBtSimplePair uintptr + +func (p SwigcptrBtSimplePair) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSimplePair) SwigIsBtSimplePair() { +} + +func NewBtSimplePair(arg1 int, arg2 int) (_swig_ret BtSimplePair) { + var swig_r BtSimplePair + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtSimplePair)(SwigcptrBtSimplePair(C._wrap_new_btSimplePair_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtSimplePair) SetM_indexA(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSimplePair_m_indexA_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSimplePair) GetM_indexA() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSimplePair_m_indexA_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSimplePair) SetM_indexB(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSimplePair_m_indexB_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtSimplePair) GetM_indexB() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btSimplePair_m_indexB_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func DeleteBtSimplePair(arg1 BtSimplePair) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSimplePair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtSimplePair interface { + Swigcptr() uintptr + SwigIsBtSimplePair() + SetM_indexA(arg2 int) + GetM_indexA() (_swig_ret int) + SetM_indexB(arg2 int) + GetM_indexB() (_swig_ret int) +} + +type SwigcptrBtHashedSimplePairCache uintptr + +func (p SwigcptrBtHashedSimplePairCache) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtHashedSimplePairCache) SwigIsBtHashedSimplePairCache() { +} + +func NewBtHashedSimplePairCache() (_swig_ret BtHashedSimplePairCache) { + var swig_r BtHashedSimplePairCache + swig_r = (BtHashedSimplePairCache)(SwigcptrBtHashedSimplePairCache(C._wrap_new_btHashedSimplePairCache_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtHashedSimplePairCache(arg1 BtHashedSimplePairCache) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btHashedSimplePairCache_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtHashedSimplePairCache) RemoveAllPairs() { + _swig_i_0 := arg1 + C._wrap_btHashedSimplePairCache_removeAllPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtHashedSimplePairCache) RemoveOverlappingPair(arg2 int, arg3 int) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (uintptr)(C._wrap_btHashedSimplePairCache_removeOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2))) + return swig_r +} + +func (arg1 SwigcptrBtHashedSimplePairCache) AddOverlappingPair(arg2 int, arg3 int) (_swig_ret BtSimplePair) { + var swig_r BtSimplePair + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtSimplePair)(SwigcptrBtSimplePair(C._wrap_btHashedSimplePairCache_addOverlappingPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtHashedSimplePairCache) GetOverlappingPairArrayPtr__SWIG_0() (_swig_ret BtSimplePair) { + var swig_r BtSimplePair + _swig_i_0 := arg1 + swig_r = (BtSimplePair)(SwigcptrBtSimplePair(C._wrap_btHashedSimplePairCache_getOverlappingPairArrayPtr__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtHashedSimplePairCache) GetOverlappingPairArrayPtr__SWIG_1() (_swig_ret BtSimplePair) { + var swig_r BtSimplePair + _swig_i_0 := arg1 + swig_r = (BtSimplePair)(SwigcptrBtSimplePair(C._wrap_btHashedSimplePairCache_getOverlappingPairArrayPtr__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtHashedSimplePairCache) GetOverlappingPairArrayPtr(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOverlappingPairArrayPtr__SWIG_0() + } + if argc == 0 { + return p.GetOverlappingPairArrayPtr__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHashedSimplePairCache) GetOverlappingPairArray__SWIG_0() (_swig_ret BtAlignedObjectArray_Sl_btSimplePair_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btSimplePair_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btSimplePair_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btSimplePair_Sg_(C._wrap_btHashedSimplePairCache_getOverlappingPairArray__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtHashedSimplePairCache) GetOverlappingPairArray__SWIG_1() (_swig_ret BtAlignedObjectArray_Sl_btSimplePair_Sg_) { + var swig_r BtAlignedObjectArray_Sl_btSimplePair_Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btSimplePair_Sg_)(SwigcptrBtAlignedObjectArray_Sl_btSimplePair_Sg_(C._wrap_btHashedSimplePairCache_getOverlappingPairArray__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtHashedSimplePairCache) GetOverlappingPairArray(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetOverlappingPairArray__SWIG_0() + } + if argc == 0 { + return p.GetOverlappingPairArray__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtHashedSimplePairCache) FindPair(arg2 int, arg3 int) (_swig_ret BtSimplePair) { + var swig_r BtSimplePair + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (BtSimplePair)(SwigcptrBtSimplePair(C._wrap_btHashedSimplePairCache_findPair_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtHashedSimplePairCache) GetCount() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btHashedSimplePairCache_GetCount_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtHashedSimplePairCache) GetNumOverlappingPairs() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btHashedSimplePairCache_getNumOverlappingPairs_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +type BtHashedSimplePairCache interface { + Swigcptr() uintptr + SwigIsBtHashedSimplePairCache() + RemoveAllPairs() + RemoveOverlappingPair(arg2 int, arg3 int) (_swig_ret uintptr) + AddOverlappingPair(arg2 int, arg3 int) (_swig_ret BtSimplePair) + GetOverlappingPairArrayPtr(a ...interface{}) interface{} + GetOverlappingPairArray(a ...interface{}) interface{} + FindPair(arg2 int, arg3 int) (_swig_ret BtSimplePair) + GetCount() (_swig_ret int) + GetNumOverlappingPairs() (_swig_ret int) +} + +func SetGCompoundCompoundChildShapePairCallback(arg1 _swig_fnptr) { + _swig_i_0 := arg1 + C._wrap_gCompoundCompoundChildShapePairCallback_set_mbt_e879218550ba2e2b(C.swig_type_163(_swig_i_0)) +} + +func GetGCompoundCompoundChildShapePairCallback() (_swig_ret _swig_fnptr) { + var swig_r _swig_fnptr + swig_r = (_swig_fnptr)(C._wrap_gCompoundCompoundChildShapePairCallback_get_mbt_e879218550ba2e2b()) + return swig_r +} + +type SwigcptrBtCompoundCompoundCollisionAlgorithm uintptr + +func (p SwigcptrBtCompoundCompoundCollisionAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCompoundCompoundCollisionAlgorithm) SwigIsBtCompoundCompoundCollisionAlgorithm() { +} + +func NewBtCompoundCompoundCollisionAlgorithm(arg1 BtCollisionAlgorithmConstructionInfo, arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 bool) (_swig_ret BtCompoundCompoundCollisionAlgorithm) { + var swig_r BtCompoundCompoundCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + swig_r = (BtCompoundCompoundCollisionAlgorithm)(SwigcptrBtCompoundCompoundCollisionAlgorithm(C._wrap_new_btCompoundCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C._Bool(_swig_i_3)))) + return swig_r +} + +func DeleteBtCompoundCompoundCollisionAlgorithm(arg1 BtCompoundCompoundCollisionAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCompoundCompoundCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtCompoundCompoundCollisionAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btCompoundCompoundCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtCompoundCompoundCollisionAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btCompoundCompoundCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtCompoundCompoundCollisionAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btCompoundCompoundCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtCompoundCompoundCollisionAlgorithm) GetChildAlgorithm(arg1 int) (_swig_ret BtCollisionAlgorithm) { + var swig_r BtCollisionAlgorithm + _swig_i_0 := arg1 + swig_r = (BtCollisionAlgorithm)(SwigcptrBtCollisionAlgorithm(C._wrap_btCompoundCompoundCollisionAlgorithm_getChildAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)))) + return swig_r +} + +func (p SwigcptrBtCompoundCompoundCollisionAlgorithm) SwigIsBtCompoundCollisionAlgorithm() { +} + +func (p SwigcptrBtCompoundCompoundCollisionAlgorithm) SwigGetBtCompoundCollisionAlgorithm() BtCompoundCollisionAlgorithm { + return SwigcptrBtCompoundCollisionAlgorithm(getSwigcptr(p)) +} + +func (p SwigcptrBtCompoundCompoundCollisionAlgorithm) SwigIsBtActivatingCollisionAlgorithm() { +} + +func (p SwigcptrBtCompoundCompoundCollisionAlgorithm) SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm { + return SwigcptrBtActivatingCollisionAlgorithm(getSwigcptr(p)) +} + +func (p SwigcptrBtCompoundCompoundCollisionAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtCompoundCompoundCollisionAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtCompoundCompoundCollisionAlgorithm interface { + Swigcptr() uintptr + SwigIsBtCompoundCompoundCollisionAlgorithm() + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + GetChildAlgorithm(arg1 int) (_swig_ret BtCollisionAlgorithm) + SwigIsBtCompoundCollisionAlgorithm() + SwigGetBtCompoundCollisionAlgorithm() BtCompoundCollisionAlgorithm + SwigIsBtActivatingCollisionAlgorithm() + SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +type SwigcptrBtConvexPlaneCollisionAlgorithm uintptr + +func (p SwigcptrBtConvexPlaneCollisionAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexPlaneCollisionAlgorithm) SwigIsBtConvexPlaneCollisionAlgorithm() { +} + +func NewBtConvexPlaneCollisionAlgorithm(arg1 BtPersistentManifold, arg2 BtCollisionAlgorithmConstructionInfo, arg3 BtCollisionObjectWrapper, arg4 BtCollisionObjectWrapper, arg5 bool, arg6 int, arg7 int) (_swig_ret BtConvexPlaneCollisionAlgorithm) { + var swig_r BtConvexPlaneCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + swig_r = (BtConvexPlaneCollisionAlgorithm)(SwigcptrBtConvexPlaneCollisionAlgorithm(C._wrap_new_btConvexPlaneCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4), C.swig_intgo(_swig_i_5), C.swig_intgo(_swig_i_6)))) + return swig_r +} + +func DeleteBtConvexPlaneCollisionAlgorithm(arg1 BtConvexPlaneCollisionAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexPlaneCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexPlaneCollisionAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btConvexPlaneCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtConvexPlaneCollisionAlgorithm) CollideSingleContact(arg2 BtQuaternion, arg3 BtCollisionObjectWrapper, arg4 BtCollisionObjectWrapper, arg5 BtDispatcherInfo, arg6 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btConvexPlaneCollisionAlgorithm_collideSingleContact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtConvexPlaneCollisionAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btConvexPlaneCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtConvexPlaneCollisionAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btConvexPlaneCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtConvexPlaneCollisionAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtConvexPlaneCollisionAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtConvexPlaneCollisionAlgorithm interface { + Swigcptr() uintptr + SwigIsBtConvexPlaneCollisionAlgorithm() + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CollideSingleContact(arg2 BtQuaternion, arg3 BtCollisionObjectWrapper, arg4 BtCollisionObjectWrapper, arg5 BtDispatcherInfo, arg6 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +type SwigcptrBtBoxBoxCollisionAlgorithm uintptr + +func (p SwigcptrBtBoxBoxCollisionAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBoxBoxCollisionAlgorithm) SwigIsBtBoxBoxCollisionAlgorithm() { +} + +func NewBtBoxBoxCollisionAlgorithm__SWIG_0(arg1 BtCollisionAlgorithmConstructionInfo) (_swig_ret BtBoxBoxCollisionAlgorithm) { + var swig_r BtBoxBoxCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtBoxBoxCollisionAlgorithm)(SwigcptrBtBoxBoxCollisionAlgorithm(C._wrap_new_btBoxBoxCollisionAlgorithm__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBoxBoxCollisionAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btBoxBoxCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtBoxBoxCollisionAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btBoxBoxCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func NewBtBoxBoxCollisionAlgorithm__SWIG_1(arg1 BtPersistentManifold, arg2 BtCollisionAlgorithmConstructionInfo, arg3 BtCollisionObjectWrapper, arg4 BtCollisionObjectWrapper) (_swig_ret BtBoxBoxCollisionAlgorithm) { + var swig_r BtBoxBoxCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtBoxBoxCollisionAlgorithm)(SwigcptrBtBoxBoxCollisionAlgorithm(C._wrap_new_btBoxBoxCollisionAlgorithm__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func NewBtBoxBoxCollisionAlgorithm(a ...interface{}) BtBoxBoxCollisionAlgorithm { + argc := len(a) + if argc == 1 { + return NewBtBoxBoxCollisionAlgorithm__SWIG_0(a[0].(BtCollisionAlgorithmConstructionInfo)) + } + if argc == 4 { + return NewBtBoxBoxCollisionAlgorithm__SWIG_1(a[0].(BtPersistentManifold), a[1].(BtCollisionAlgorithmConstructionInfo), a[2].(BtCollisionObjectWrapper), a[3].(BtCollisionObjectWrapper)) + } + panic("No match for overloaded function call") +} + +func DeleteBtBoxBoxCollisionAlgorithm(arg1 BtBoxBoxCollisionAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBoxBoxCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtBoxBoxCollisionAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBoxBoxCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (p SwigcptrBtBoxBoxCollisionAlgorithm) SwigIsBtActivatingCollisionAlgorithm() { +} + +func (p SwigcptrBtBoxBoxCollisionAlgorithm) SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm { + return SwigcptrBtActivatingCollisionAlgorithm(getSwigcptr(p)) +} + +func (p SwigcptrBtBoxBoxCollisionAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtBoxBoxCollisionAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtBoxBoxCollisionAlgorithm interface { + Swigcptr() uintptr + SwigIsBtBoxBoxCollisionAlgorithm() + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + SwigIsBtActivatingCollisionAlgorithm() + SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +type SwigcptrBtSphereSphereCollisionAlgorithm uintptr + +func (p SwigcptrBtSphereSphereCollisionAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSphereSphereCollisionAlgorithm) SwigIsBtSphereSphereCollisionAlgorithm() { +} + +func NewBtSphereSphereCollisionAlgorithm__SWIG_0(arg1 BtPersistentManifold, arg2 BtCollisionAlgorithmConstructionInfo, arg3 BtCollisionObjectWrapper, arg4 BtCollisionObjectWrapper) (_swig_ret BtSphereSphereCollisionAlgorithm) { + var swig_r BtSphereSphereCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (BtSphereSphereCollisionAlgorithm)(SwigcptrBtSphereSphereCollisionAlgorithm(C._wrap_new_btSphereSphereCollisionAlgorithm__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)))) + return swig_r +} + +func NewBtSphereSphereCollisionAlgorithm__SWIG_1(arg1 BtCollisionAlgorithmConstructionInfo) (_swig_ret BtSphereSphereCollisionAlgorithm) { + var swig_r BtSphereSphereCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtSphereSphereCollisionAlgorithm)(SwigcptrBtSphereSphereCollisionAlgorithm(C._wrap_new_btSphereSphereCollisionAlgorithm__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtSphereSphereCollisionAlgorithm(a ...interface{}) BtSphereSphereCollisionAlgorithm { + argc := len(a) + if argc == 1 { + return NewBtSphereSphereCollisionAlgorithm__SWIG_1(a[0].(BtCollisionAlgorithmConstructionInfo)) + } + if argc == 4 { + return NewBtSphereSphereCollisionAlgorithm__SWIG_0(a[0].(BtPersistentManifold), a[1].(BtCollisionAlgorithmConstructionInfo), a[2].(BtCollisionObjectWrapper), a[3].(BtCollisionObjectWrapper)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtSphereSphereCollisionAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btSphereSphereCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtSphereSphereCollisionAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btSphereSphereCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtSphereSphereCollisionAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSphereSphereCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBtSphereSphereCollisionAlgorithm(arg1 BtSphereSphereCollisionAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSphereSphereCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtSphereSphereCollisionAlgorithm) SwigIsBtActivatingCollisionAlgorithm() { +} + +func (p SwigcptrBtSphereSphereCollisionAlgorithm) SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm { + return SwigcptrBtActivatingCollisionAlgorithm(getSwigcptr(p)) +} + +func (p SwigcptrBtSphereSphereCollisionAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtSphereSphereCollisionAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtSphereSphereCollisionAlgorithm interface { + Swigcptr() uintptr + SwigIsBtSphereSphereCollisionAlgorithm() + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + SwigIsBtActivatingCollisionAlgorithm() + SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +type SwigcptrBtSphereBoxCollisionAlgorithm uintptr + +func (p SwigcptrBtSphereBoxCollisionAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSphereBoxCollisionAlgorithm) SwigIsBtSphereBoxCollisionAlgorithm() { +} + +func NewBtSphereBoxCollisionAlgorithm(arg1 BtPersistentManifold, arg2 BtCollisionAlgorithmConstructionInfo, arg3 BtCollisionObjectWrapper, arg4 BtCollisionObjectWrapper, arg5 bool) (_swig_ret BtSphereBoxCollisionAlgorithm) { + var swig_r BtSphereBoxCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (BtSphereBoxCollisionAlgorithm)(SwigcptrBtSphereBoxCollisionAlgorithm(C._wrap_new_btSphereBoxCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4)))) + return swig_r +} + +func DeleteBtSphereBoxCollisionAlgorithm(arg1 BtSphereBoxCollisionAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSphereBoxCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSphereBoxCollisionAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btSphereBoxCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtSphereBoxCollisionAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btSphereBoxCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtSphereBoxCollisionAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSphereBoxCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSphereBoxCollisionAlgorithm) GetSphereDistance(arg2 BtCollisionObjectWrapper, arg3 BtVector3, arg4 BtVector3, arg5 *float32, arg6 BtVector3, arg7 float32, arg8 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := arg7 + _swig_i_7 := arg8 + swig_r = (bool)(C._wrap_btSphereBoxCollisionAlgorithm_getSphereDistance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_voidp(_swig_i_4), C.uintptr_t(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7))) + return swig_r +} + +func (arg1 SwigcptrBtSphereBoxCollisionAlgorithm) GetSpherePenetration(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btSphereBoxCollisionAlgorithm_getSpherePenetration_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (p SwigcptrBtSphereBoxCollisionAlgorithm) SwigIsBtActivatingCollisionAlgorithm() { +} + +func (p SwigcptrBtSphereBoxCollisionAlgorithm) SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm { + return SwigcptrBtActivatingCollisionAlgorithm(getSwigcptr(p)) +} + +func (p SwigcptrBtSphereBoxCollisionAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtSphereBoxCollisionAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtSphereBoxCollisionAlgorithm interface { + Swigcptr() uintptr + SwigIsBtSphereBoxCollisionAlgorithm() + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + GetSphereDistance(arg2 BtCollisionObjectWrapper, arg3 BtVector3, arg4 BtVector3, arg5 *float32, arg6 BtVector3, arg7 float32, arg8 float32) (_swig_ret bool) + GetSpherePenetration(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3) (_swig_ret float32) + SwigIsBtActivatingCollisionAlgorithm() + SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +type SwigcptrBtSphereTriangleCollisionAlgorithm uintptr + +func (p SwigcptrBtSphereTriangleCollisionAlgorithm) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSphereTriangleCollisionAlgorithm) SwigIsBtSphereTriangleCollisionAlgorithm() { +} + +func NewBtSphereTriangleCollisionAlgorithm__SWIG_0(arg1 BtPersistentManifold, arg2 BtCollisionAlgorithmConstructionInfo, arg3 BtCollisionObjectWrapper, arg4 BtCollisionObjectWrapper, arg5 bool) (_swig_ret BtSphereTriangleCollisionAlgorithm) { + var swig_r BtSphereTriangleCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (BtSphereTriangleCollisionAlgorithm)(SwigcptrBtSphereTriangleCollisionAlgorithm(C._wrap_new_btSphereTriangleCollisionAlgorithm__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4)))) + return swig_r +} + +func NewBtSphereTriangleCollisionAlgorithm__SWIG_1(arg1 BtCollisionAlgorithmConstructionInfo) (_swig_ret BtSphereTriangleCollisionAlgorithm) { + var swig_r BtSphereTriangleCollisionAlgorithm + _swig_i_0 := getSwigcptr(arg1) + swig_r = (BtSphereTriangleCollisionAlgorithm)(SwigcptrBtSphereTriangleCollisionAlgorithm(C._wrap_new_btSphereTriangleCollisionAlgorithm__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtSphereTriangleCollisionAlgorithm(a ...interface{}) BtSphereTriangleCollisionAlgorithm { + argc := len(a) + if argc == 1 { + return NewBtSphereTriangleCollisionAlgorithm__SWIG_1(a[0].(BtCollisionAlgorithmConstructionInfo)) + } + if argc == 5 { + return NewBtSphereTriangleCollisionAlgorithm__SWIG_0(a[0].(BtPersistentManifold), a[1].(BtCollisionAlgorithmConstructionInfo), a[2].(BtCollisionObjectWrapper), a[3].(BtCollisionObjectWrapper), a[4].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtSphereTriangleCollisionAlgorithm) ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btSphereTriangleCollisionAlgorithm_processCollision_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtSphereTriangleCollisionAlgorithm) CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (float32)(C._wrap_btSphereTriangleCollisionAlgorithm_calculateTimeOfImpact_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func (arg1 SwigcptrBtSphereTriangleCollisionAlgorithm) GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSphereTriangleCollisionAlgorithm_getAllContactManifolds_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func DeleteBtSphereTriangleCollisionAlgorithm(arg1 BtSphereTriangleCollisionAlgorithm) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSphereTriangleCollisionAlgorithm_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtSphereTriangleCollisionAlgorithm) SwigIsBtActivatingCollisionAlgorithm() { +} + +func (p SwigcptrBtSphereTriangleCollisionAlgorithm) SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm { + return SwigcptrBtActivatingCollisionAlgorithm(getSwigcptr(p)) +} + +func (p SwigcptrBtSphereTriangleCollisionAlgorithm) SwigIsBtCollisionAlgorithm() { +} + +func (p SwigcptrBtSphereTriangleCollisionAlgorithm) SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm { + return SwigcptrBtCollisionAlgorithm(getSwigcptr(p)) +} + +type BtSphereTriangleCollisionAlgorithm interface { + Swigcptr() uintptr + SwigIsBtSphereTriangleCollisionAlgorithm() + ProcessCollision(arg2 BtCollisionObjectWrapper, arg3 BtCollisionObjectWrapper, arg4 BtDispatcherInfo, arg5 BtManifoldResult) + CalculateTimeOfImpact(arg2 BtCollisionObject, arg3 BtCollisionObject, arg4 BtDispatcherInfo, arg5 BtManifoldResult) (_swig_ret float32) + GetAllContactManifolds(arg2 BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) + SwigIsBtActivatingCollisionAlgorithm() + SwigGetBtActivatingCollisionAlgorithm() BtActivatingCollisionAlgorithm + SwigIsBtCollisionAlgorithm() + SwigGetBtCollisionAlgorithm() BtCollisionAlgorithm +} + +type SwigcptrBtConvexPenetrationDepthSolver uintptr + +func (p SwigcptrBtConvexPenetrationDepthSolver) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtConvexPenetrationDepthSolver) SwigIsBtConvexPenetrationDepthSolver() { +} + +func DeleteBtConvexPenetrationDepthSolver(arg1 BtConvexPenetrationDepthSolver) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btConvexPenetrationDepthSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtConvexPenetrationDepthSolver) CalcPenDepth(arg2 BtVoronoiSimplexSolver, arg3 BtConvexShape, arg4 BtConvexShape, arg5 BtTransform, arg6 BtTransform, arg7 BtVector3, arg8 BtVector3, arg9 BtVector3, arg10 BtIDebugDraw) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := getSwigcptr(arg10) + swig_r = (bool)(C._wrap_btConvexPenetrationDepthSolver_calcPenDepth_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7), C.uintptr_t(_swig_i_8), C.uintptr_t(_swig_i_9))) + return swig_r +} + +type BtConvexPenetrationDepthSolver interface { + Swigcptr() uintptr + SwigIsBtConvexPenetrationDepthSolver() + CalcPenDepth(arg2 BtVoronoiSimplexSolver, arg3 BtConvexShape, arg4 BtConvexShape, arg5 BtTransform, arg6 BtTransform, arg7 BtVector3, arg8 BtVector3, arg9 BtVector3, arg10 BtIDebugDraw) (_swig_ret bool) +} + +type SwigcptrBtMinkowskiPenetrationDepthSolver uintptr + +func (p SwigcptrBtMinkowskiPenetrationDepthSolver) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMinkowskiPenetrationDepthSolver) SwigIsBtMinkowskiPenetrationDepthSolver() { +} + +func (arg1 SwigcptrBtMinkowskiPenetrationDepthSolver) CalcPenDepth(arg2 BtVoronoiSimplexSolver, arg3 BtConvexShape, arg4 BtConvexShape, arg5 BtTransform, arg6 BtTransform, arg7 BtVector3, arg8 BtVector3, arg9 BtVector3, arg10 BtIDebugDraw) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := getSwigcptr(arg10) + swig_r = (bool)(C._wrap_btMinkowskiPenetrationDepthSolver_calcPenDepth_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7), C.uintptr_t(_swig_i_8), C.uintptr_t(_swig_i_9))) + return swig_r +} + +func NewBtMinkowskiPenetrationDepthSolver() (_swig_ret BtMinkowskiPenetrationDepthSolver) { + var swig_r BtMinkowskiPenetrationDepthSolver + swig_r = (BtMinkowskiPenetrationDepthSolver)(SwigcptrBtMinkowskiPenetrationDepthSolver(C._wrap_new_btMinkowskiPenetrationDepthSolver_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtMinkowskiPenetrationDepthSolver(arg1 BtMinkowskiPenetrationDepthSolver) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMinkowskiPenetrationDepthSolver_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtMinkowskiPenetrationDepthSolver) SwigIsBtConvexPenetrationDepthSolver() { +} + +func (p SwigcptrBtMinkowskiPenetrationDepthSolver) SwigGetBtConvexPenetrationDepthSolver() BtConvexPenetrationDepthSolver { + return SwigcptrBtConvexPenetrationDepthSolver(getSwigcptr(p)) +} + +type BtMinkowskiPenetrationDepthSolver interface { + Swigcptr() uintptr + SwigIsBtMinkowskiPenetrationDepthSolver() + CalcPenDepth(arg2 BtVoronoiSimplexSolver, arg3 BtConvexShape, arg4 BtConvexShape, arg5 BtTransform, arg6 BtTransform, arg7 BtVector3, arg8 BtVector3, arg9 BtVector3, arg10 BtIDebugDraw) (_swig_ret bool) + SwigIsBtConvexPenetrationDepthSolver() + SwigGetBtConvexPenetrationDepthSolver() BtConvexPenetrationDepthSolver +} + +type SwigcptrBtPoolAllocator uintptr + +func (p SwigcptrBtPoolAllocator) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtPoolAllocator) SwigIsBtPoolAllocator() { +} + +func NewBtPoolAllocator(arg1 int, arg2 int) (_swig_ret BtPoolAllocator) { + var swig_r BtPoolAllocator + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtPoolAllocator)(SwigcptrBtPoolAllocator(C._wrap_new_btPoolAllocator_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func DeleteBtPoolAllocator(arg1 BtPoolAllocator) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btPoolAllocator_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtPoolAllocator) GetFreeCount() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPoolAllocator_getFreeCount_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPoolAllocator) GetUsedCount() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPoolAllocator_getUsedCount_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPoolAllocator) GetMaxCount() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPoolAllocator_getMaxCount_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPoolAllocator) Allocate(arg2 int) (_swig_ret uintptr) { + var swig_r uintptr + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (uintptr)(C._wrap_btPoolAllocator_allocate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtPoolAllocator) ValidPtr(arg2 uintptr) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btPoolAllocator_validPtr_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtPoolAllocator) FreeMemory(arg2 uintptr) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btPoolAllocator_freeMemory_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtPoolAllocator) GetElementSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btPoolAllocator_getElementSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPoolAllocator) GetPoolAddress__SWIG_0() (_swig_ret *byte) { + var swig_r *byte + _swig_i_0 := arg1 + swig_r = (*byte)(C._wrap_btPoolAllocator_getPoolAddress__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtPoolAllocator) GetPoolAddress__SWIG_1() (_swig_ret *byte) { + var swig_r *byte + _swig_i_0 := arg1 + swig_r = (*byte)(C._wrap_btPoolAllocator_getPoolAddress__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (p SwigcptrBtPoolAllocator) GetPoolAddress(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetPoolAddress__SWIG_0() + } + if argc == 0 { + return p.GetPoolAddress__SWIG_1() + } + panic("No match for overloaded function call") +} + +type BtPoolAllocator interface { + Swigcptr() uintptr + SwigIsBtPoolAllocator() + GetFreeCount() (_swig_ret int) + GetUsedCount() (_swig_ret int) + GetMaxCount() (_swig_ret int) + Allocate(arg2 int) (_swig_ret uintptr) + ValidPtr(arg2 uintptr) (_swig_ret bool) + FreeMemory(arg2 uintptr) + GetElementSize() (_swig_ret int) + GetPoolAddress(a ...interface{}) interface{} +} + +type SwigcptrBtMultiIndex uintptr + +func (p SwigcptrBtMultiIndex) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMultiIndex) SwigIsBtMultiIndex() { +} + +func (arg1 SwigcptrBtMultiIndex) SetIjk(arg2 *uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btMultiIndex_ijk_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtMultiIndex) GetIjk() (_swig_ret *uint) { + var swig_r *uint + _swig_i_0 := arg1 + swig_r = (*uint)(C._wrap_btMultiIndex_ijk_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtMultiIndex() (_swig_ret BtMultiIndex) { + var swig_r BtMultiIndex + swig_r = (BtMultiIndex)(SwigcptrBtMultiIndex(C._wrap_new_btMultiIndex_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtMultiIndex(arg1 BtMultiIndex) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMultiIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtMultiIndex interface { + Swigcptr() uintptr + SwigIsBtMultiIndex() + SetIjk(arg2 *uint) + GetIjk() (_swig_ret *uint) +} + +type SwigcptrBtAlignedBox3d uintptr + +func (p SwigcptrBtAlignedBox3d) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtAlignedBox3d) SwigIsBtAlignedBox3d() { +} + +func (arg1 SwigcptrBtAlignedBox3d) SetM_min(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btAlignedBox3d_m_min_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtAlignedBox3d) GetM_min() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btAlignedBox3d_m_min_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtAlignedBox3d) SetM_max(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btAlignedBox3d_m_max_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtAlignedBox3d) GetM_max() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btAlignedBox3d_m_max_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtAlignedBox3d) Min() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btAlignedBox3d_min_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtAlignedBox3d) Max() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btAlignedBox3d_max_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtAlignedBox3d) Contains(arg2 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (bool)(C._wrap_btAlignedBox3d_contains_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func NewBtAlignedBox3d__SWIG_0(arg1 BtVector3, arg2 BtVector3) (_swig_ret BtAlignedBox3d) { + var swig_r BtAlignedBox3d + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtAlignedBox3d)(SwigcptrBtAlignedBox3d(C._wrap_new_btAlignedBox3d__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func NewBtAlignedBox3d__SWIG_1() (_swig_ret BtAlignedBox3d) { + var swig_r BtAlignedBox3d + swig_r = (BtAlignedBox3d)(SwigcptrBtAlignedBox3d(C._wrap_new_btAlignedBox3d__SWIG_1_mbt_e879218550ba2e2b())) + return swig_r +} + +func NewBtAlignedBox3d(a ...interface{}) BtAlignedBox3d { + argc := len(a) + if argc == 0 { + return NewBtAlignedBox3d__SWIG_1() + } + if argc == 2 { + return NewBtAlignedBox3d__SWIG_0(a[0].(BtVector3), a[1].(BtVector3)) + } + panic("No match for overloaded function call") +} + +func DeleteBtAlignedBox3d(arg1 BtAlignedBox3d) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btAlignedBox3d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtAlignedBox3d interface { + Swigcptr() uintptr + SwigIsBtAlignedBox3d() + SetM_min(arg2 BtVector3) + GetM_min() (_swig_ret BtVector3) + SetM_max(arg2 BtVector3) + GetM_max() (_swig_ret BtVector3) + Min() (_swig_ret BtVector3) + Max() (_swig_ret BtVector3) + Contains(arg2 BtVector3) (_swig_ret bool) +} + +type SwigcptrBtShapeMatrix uintptr + +func (p SwigcptrBtShapeMatrix) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtShapeMatrix) SwigIsBtShapeMatrix() { +} + +func (arg1 SwigcptrBtShapeMatrix) SetM_vec(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btShapeMatrix_m_vec_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtShapeMatrix) GetM_vec() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btShapeMatrix_m_vec_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtShapeMatrix() (_swig_ret BtShapeMatrix) { + var swig_r BtShapeMatrix + swig_r = (BtShapeMatrix)(SwigcptrBtShapeMatrix(C._wrap_new_btShapeMatrix_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtShapeMatrix(arg1 BtShapeMatrix) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btShapeMatrix_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtShapeMatrix interface { + Swigcptr() uintptr + SwigIsBtShapeMatrix() + SetM_vec(arg2 *float64) + GetM_vec() (_swig_ret *float64) +} + +type SwigcptrBtShapeGradients uintptr + +func (p SwigcptrBtShapeGradients) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtShapeGradients) SwigIsBtShapeGradients() { +} + +func (arg1 SwigcptrBtShapeGradients) SetM_vec(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btShapeGradients_m_vec_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtShapeGradients) GetM_vec() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btShapeGradients_m_vec_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtShapeGradients) TopRowsDivide(arg2 int, arg3 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btShapeGradients_topRowsDivide_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.double(_swig_i_2)) +} + +func (arg1 SwigcptrBtShapeGradients) BottomRowsMul(arg2 int, arg3 float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btShapeGradients_bottomRowsMul_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.double(_swig_i_2)) +} + +func NewBtShapeGradients() (_swig_ret BtShapeGradients) { + var swig_r BtShapeGradients + swig_r = (BtShapeGradients)(SwigcptrBtShapeGradients(C._wrap_new_btShapeGradients_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtShapeGradients(arg1 BtShapeGradients) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btShapeGradients_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtShapeGradients interface { + Swigcptr() uintptr + SwigIsBtShapeGradients() + SetM_vec(arg2 BtVector3) + GetM_vec() (_swig_ret BtVector3) + TopRowsDivide(arg2 int, arg3 float64) + BottomRowsMul(arg2 int, arg3 float64) +} + +type SwigcptrBtCell32 uintptr + +func (p SwigcptrBtCell32) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtCell32) SwigIsBtCell32() { +} + +func (arg1 SwigcptrBtCell32) SetM_cells(arg2 *uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btCell32_m_cells_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtCell32) GetM_cells() (_swig_ret *uint) { + var swig_r *uint + _swig_i_0 := arg1 + swig_r = (*uint)(C._wrap_btCell32_m_cells_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtCell32() (_swig_ret BtCell32) { + var swig_r BtCell32 + swig_r = (BtCell32)(SwigcptrBtCell32(C._wrap_new_btCell32_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtCell32(arg1 BtCell32) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btCell32_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtCell32 interface { + Swigcptr() uintptr + SwigIsBtCell32() + SetM_cells(arg2 *uint) + GetM_cells() (_swig_ret *uint) +} + +type SwigcptrBtMiniSDF uintptr + +func (p SwigcptrBtMiniSDF) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMiniSDF) SwigIsBtMiniSDF() { +} + +func (arg1 SwigcptrBtMiniSDF) SetM_domain(arg2 BtAlignedBox3d) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMiniSDF_m_domain_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMiniSDF) GetM_domain() (_swig_ret BtAlignedBox3d) { + var swig_r BtAlignedBox3d + _swig_i_0 := arg1 + swig_r = (BtAlignedBox3d)(SwigcptrBtAlignedBox3d(C._wrap_btMiniSDF_m_domain_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) SetM_resolution(arg2 *uint) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btMiniSDF_m_resolution_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtMiniSDF) GetM_resolution() (_swig_ret *uint) { + var swig_r *uint + _swig_i_0 := arg1 + swig_r = (*uint)(C._wrap_btMiniSDF_m_resolution_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) SetM_cell_size(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMiniSDF_m_cell_size_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMiniSDF) GetM_cell_size() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btMiniSDF_m_cell_size_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) SetM_inv_cell_size(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMiniSDF_m_inv_cell_size_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMiniSDF) GetM_inv_cell_size() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btMiniSDF_m_inv_cell_size_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) SetM_n_cells(arg2 Std_size_t) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMiniSDF_m_n_cells_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMiniSDF) GetM_n_cells() (_swig_ret Std_size_t) { + var swig_r Std_size_t + _swig_i_0 := arg1 + swig_r = (Std_size_t)(SwigcptrStd_size_t(C._wrap_btMiniSDF_m_n_cells_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) SetM_n_fields(arg2 Std_size_t) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMiniSDF_m_n_fields_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMiniSDF) GetM_n_fields() (_swig_ret Std_size_t) { + var swig_r Std_size_t + _swig_i_0 := arg1 + swig_r = (Std_size_t)(SwigcptrStd_size_t(C._wrap_btMiniSDF_m_n_fields_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) SetM_isValid(arg2 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btMiniSDF_m_isValid_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C._Bool(_swig_i_1)) +} + +func (arg1 SwigcptrBtMiniSDF) GetM_isValid() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btMiniSDF_m_isValid_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) SetM_nodes(arg2 BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_double_Sg__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMiniSDF_m_nodes_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMiniSDF) GetM_nodes() (_swig_ret BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_double_Sg__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_double_Sg__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_double_Sg__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_double_Sg__Sg_(C._wrap_btMiniSDF_m_nodes_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) SetM_cells(arg2 BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btCell32_Sg__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMiniSDF_m_cells_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMiniSDF) GetM_cells() (_swig_ret BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btCell32_Sg__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btCell32_Sg__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btCell32_Sg__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btCell32_Sg__Sg_(C._wrap_btMiniSDF_m_cells_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) SetM_cell_map(arg2 BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_unsigned_SS_int_Sg__Sg_) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMiniSDF_m_cell_map_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMiniSDF) GetM_cell_map() (_swig_ret BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_unsigned_SS_int_Sg__Sg_) { + var swig_r BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_unsigned_SS_int_Sg__Sg_ + _swig_i_0 := arg1 + swig_r = (BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_unsigned_SS_int_Sg__Sg_)(SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_unsigned_SS_int_Sg__Sg_(C._wrap_btMiniSDF_m_cell_map_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtMiniSDF() (_swig_ret BtMiniSDF) { + var swig_r BtMiniSDF + swig_r = (BtMiniSDF)(SwigcptrBtMiniSDF(C._wrap_new_btMiniSDF_mbt_e879218550ba2e2b())) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) Load(arg2 string, arg3 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (bool)(C._wrap_btMiniSDF_load_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_165)(unsafe.Pointer(&_swig_i_1)), C.swig_intgo(_swig_i_2))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) IsValid() (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btMiniSDF_isValid_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) MultiToSingleIndex(arg2 BtMultiIndex) (_swig_ret uint) { + var swig_r uint + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (uint)(C._wrap_btMiniSDF_multiToSingleIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) Subdomain__SWIG_0(arg2 BtMultiIndex) (_swig_ret BtAlignedBox3d) { + var swig_r BtAlignedBox3d + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtAlignedBox3d)(SwigcptrBtAlignedBox3d(C._wrap_btMiniSDF_subdomain__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) SingleToMultiIndex(arg2 uint) (_swig_ret BtMultiIndex) { + var swig_r BtMultiIndex + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtMultiIndex)(SwigcptrBtMultiIndex(C._wrap_btMiniSDF_singleToMultiIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) Subdomain__SWIG_1(arg2 uint) (_swig_ret BtAlignedBox3d) { + var swig_r BtAlignedBox3d + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (BtAlignedBox3d)(SwigcptrBtAlignedBox3d(C._wrap_btMiniSDF_subdomain__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)))) + return swig_r +} + +func (p SwigcptrBtMiniSDF) Subdomain(a ...interface{}) BtAlignedBox3d { + argc := len(a) + if argc == 1 { + if _, ok := a[0].(BtMultiIndex); !ok { + goto check_1 + } + return p.Subdomain__SWIG_0(a[0].(BtMultiIndex)) + } +check_1: + if argc == 1 { + return p.Subdomain__SWIG_1(a[0].(uint)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMiniSDF) Shape_function___SWIG_0(arg2 BtVector3, arg3 BtShapeGradients) (_swig_ret BtShapeMatrix) { + var swig_r BtShapeMatrix + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + swig_r = (BtShapeMatrix)(SwigcptrBtShapeMatrix(C._wrap_btMiniSDF_shape_function___SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)))) + return swig_r +} + +func (arg1 SwigcptrBtMiniSDF) Shape_function___SWIG_1(arg2 BtVector3) (_swig_ret BtShapeMatrix) { + var swig_r BtShapeMatrix + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtShapeMatrix)(SwigcptrBtShapeMatrix(C._wrap_btMiniSDF_shape_function___SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func (p SwigcptrBtMiniSDF) Shape_function_(a ...interface{}) BtShapeMatrix { + argc := len(a) + if argc == 1 { + return p.Shape_function___SWIG_1(a[0].(BtVector3)) + } + if argc == 2 { + return p.Shape_function___SWIG_0(a[0].(BtVector3), a[1].(BtShapeGradients)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMiniSDF) Interpolate(arg2 uint, arg3 *float64, arg4 BtVector3, arg5 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + swig_r = (bool)(C._wrap_btMiniSDF_interpolate_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_voidp(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4))) + return swig_r +} + +func DeleteBtMiniSDF(arg1 BtMiniSDF) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMiniSDF_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtMiniSDF interface { + Swigcptr() uintptr + SwigIsBtMiniSDF() + SetM_domain(arg2 BtAlignedBox3d) + GetM_domain() (_swig_ret BtAlignedBox3d) + SetM_resolution(arg2 *uint) + GetM_resolution() (_swig_ret *uint) + SetM_cell_size(arg2 BtVector3) + GetM_cell_size() (_swig_ret BtVector3) + SetM_inv_cell_size(arg2 BtVector3) + GetM_inv_cell_size() (_swig_ret BtVector3) + SetM_n_cells(arg2 Std_size_t) + GetM_n_cells() (_swig_ret Std_size_t) + SetM_n_fields(arg2 Std_size_t) + GetM_n_fields() (_swig_ret Std_size_t) + SetM_isValid(arg2 bool) + GetM_isValid() (_swig_ret bool) + SetM_nodes(arg2 BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_double_Sg__Sg_) + GetM_nodes() (_swig_ret BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_double_Sg__Sg_) + SetM_cells(arg2 BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btCell32_Sg__Sg_) + GetM_cells() (_swig_ret BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btCell32_Sg__Sg_) + SetM_cell_map(arg2 BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_unsigned_SS_int_Sg__Sg_) + GetM_cell_map() (_swig_ret BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_unsigned_SS_int_Sg__Sg_) + Load(arg2 string, arg3 int) (_swig_ret bool) + IsValid() (_swig_ret bool) + MultiToSingleIndex(arg2 BtMultiIndex) (_swig_ret uint) + SingleToMultiIndex(arg2 uint) (_swig_ret BtMultiIndex) + Subdomain(a ...interface{}) BtAlignedBox3d + Shape_function_(a ...interface{}) BtShapeMatrix + Interpolate(arg2 uint, arg3 *float64, arg4 BtVector3, arg5 BtVector3) (_swig_ret bool) +} + +type SwigcptrBtBoxBoxDetector uintptr + +func (p SwigcptrBtBoxBoxDetector) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtBoxBoxDetector) SwigIsBtBoxBoxDetector() { +} + +func (arg1 SwigcptrBtBoxBoxDetector) SetM_box1(arg2 BtBoxShape) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBoxBoxDetector_m_box1_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBoxBoxDetector) GetM_box1() (_swig_ret BtBoxShape) { + var swig_r BtBoxShape + _swig_i_0 := arg1 + swig_r = (BtBoxShape)(SwigcptrBtBoxShape(C._wrap_btBoxBoxDetector_m_box1_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtBoxBoxDetector) SetM_box2(arg2 BtBoxShape) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btBoxBoxDetector_m_box2_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtBoxBoxDetector) GetM_box2() (_swig_ret BtBoxShape) { + var swig_r BtBoxShape + _swig_i_0 := arg1 + swig_r = (BtBoxShape)(SwigcptrBtBoxShape(C._wrap_btBoxBoxDetector_m_box2_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtBoxBoxDetector(arg1 BtBoxShape, arg2 BtBoxShape) (_swig_ret BtBoxBoxDetector) { + var swig_r BtBoxBoxDetector + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + swig_r = (BtBoxBoxDetector)(SwigcptrBtBoxBoxDetector(C._wrap_new_btBoxBoxDetector_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)))) + return swig_r +} + +func DeleteBtBoxBoxDetector(arg1 BtBoxBoxDetector) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btBoxBoxDetector_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtBoxBoxDetector) GetClosestPoints__SWIG_0(arg2 BtDiscreteCollisionDetectorInterface_ClosestPointInput, arg3 BtDiscreteCollisionDetectorInterface_Result, arg4 BtIDebugDraw, arg5 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + C._wrap_btBoxBoxDetector_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4)) +} + +func (arg1 SwigcptrBtBoxBoxDetector) GetClosestPoints__SWIG_1(arg2 BtDiscreteCollisionDetectorInterface_ClosestPointInput, arg3 BtDiscreteCollisionDetectorInterface_Result, arg4 BtIDebugDraw) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btBoxBoxDetector_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtBoxBoxDetector) GetClosestPoints(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.GetClosestPoints__SWIG_1(a[0].(BtDiscreteCollisionDetectorInterface_ClosestPointInput), a[1].(BtDiscreteCollisionDetectorInterface_Result), a[2].(BtIDebugDraw)) + return + } + if argc == 4 { + p.GetClosestPoints__SWIG_0(a[0].(BtDiscreteCollisionDetectorInterface_ClosestPointInput), a[1].(BtDiscreteCollisionDetectorInterface_Result), a[2].(BtIDebugDraw), a[3].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (p SwigcptrBtBoxBoxDetector) SwigIsBtDiscreteCollisionDetectorInterface() { +} + +func (p SwigcptrBtBoxBoxDetector) SwigGetBtDiscreteCollisionDetectorInterface() BtDiscreteCollisionDetectorInterface { + return SwigcptrBtDiscreteCollisionDetectorInterface(getSwigcptr(p)) +} + +type BtBoxBoxDetector interface { + Swigcptr() uintptr + SwigIsBtBoxBoxDetector() + SetM_box1(arg2 BtBoxShape) + GetM_box1() (_swig_ret BtBoxShape) + SetM_box2(arg2 BtBoxShape) + GetM_box2() (_swig_ret BtBoxShape) + GetClosestPoints(a ...interface{}) + SwigIsBtDiscreteCollisionDetectorInterface() + SwigGetBtDiscreteCollisionDetectorInterface() BtDiscreteCollisionDetectorInterface +} + +func DDOT(arg1 *float32, arg2 *float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_dDOT_mbt_e879218550ba2e2b(C.swig_voidp(_swig_i_0), C.swig_voidp(_swig_i_1))) + return swig_r +} + +func DDOT44(arg1 *float32, arg2 *float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_dDOT44_mbt_e879218550ba2e2b(C.swig_voidp(_swig_i_0), C.swig_voidp(_swig_i_1))) + return swig_r +} + +func DDOT41(arg1 *float32, arg2 *float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_dDOT41_mbt_e879218550ba2e2b(C.swig_voidp(_swig_i_0), C.swig_voidp(_swig_i_1))) + return swig_r +} + +func DDOT14(arg1 *float32, arg2 *float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_dDOT14_mbt_e879218550ba2e2b(C.swig_voidp(_swig_i_0), C.swig_voidp(_swig_i_1))) + return swig_r +} + +func DLineClosestApproach(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 *float32, arg6 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + C._wrap_dLineClosestApproach_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_voidp(_swig_i_4), C.swig_voidp(_swig_i_5)) +} + +func IntersectRectQuad2(arg1 *float32, arg2 *float32, arg3 *float32) (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (int)(C._wrap_intersectRectQuad2_mbt_e879218550ba2e2b(C.swig_voidp(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_voidp(_swig_i_2))) + return swig_r +} + +const M__PI float32 = 3.14159265 + +func CullPoints2(arg1 int, arg2 *float32, arg3 int, arg4 int, arg5 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := arg5 + C._wrap_cullPoints2_mbt_e879218550ba2e2b(C.swig_intgo(_swig_i_0), C.swig_voidp(_swig_i_1), C.swig_intgo(_swig_i_2), C.swig_intgo(_swig_i_3), C.swig_voidp(_swig_i_4)) +} + +func DBoxBox2(arg1 BtVector3, arg2 *float32, arg3 BtVector3, arg4 BtVector3, arg5 *float32, arg6 BtVector3, arg7 BtVector3, arg8 *float32, arg9 *int, arg10 int, arg11 DContactGeom, arg12 int, arg13 BtDiscreteCollisionDetectorInterface_Result) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := arg8 + _swig_i_8 := arg9 + _swig_i_9 := arg10 + _swig_i_10 := getSwigcptr(arg11) + _swig_i_11 := arg12 + _swig_i_12 := getSwigcptr(arg13) + swig_r = (int)(C._wrap_dBoxBox2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_voidp(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.swig_voidp(_swig_i_7), C.swig_voidp(_swig_i_8), C.swig_intgo(_swig_i_9), C.uintptr_t(_swig_i_10), C.swig_intgo(_swig_i_11), C.uintptr_t(_swig_i_12))) + return swig_r +} + +type SwigcptrBtSdfCollisionShape uintptr + +func (p SwigcptrBtSdfCollisionShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSdfCollisionShape) SwigIsBtSdfCollisionShape() { +} + +func NewBtSdfCollisionShape() (_swig_ret BtSdfCollisionShape) { + var swig_r BtSdfCollisionShape + swig_r = (BtSdfCollisionShape)(SwigcptrBtSdfCollisionShape(C._wrap_new_btSdfCollisionShape_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtSdfCollisionShape(arg1 BtSdfCollisionShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSdfCollisionShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtSdfCollisionShape) InitializeSDF(arg2 string, arg3 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + swig_r = (bool)(C._wrap_btSdfCollisionShape_initializeSDF_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_166)(unsafe.Pointer(&_swig_i_1)), C.swig_intgo(_swig_i_2))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } + return swig_r +} + +func (arg1 SwigcptrBtSdfCollisionShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btSdfCollisionShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtSdfCollisionShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSdfCollisionShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSdfCollisionShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSdfCollisionShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSdfCollisionShape) CalculateLocalInertia(arg2 float32, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btSdfCollisionShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtSdfCollisionShape) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btSdfCollisionShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtSdfCollisionShape) SetMargin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSdfCollisionShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSdfCollisionShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSdfCollisionShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSdfCollisionShape) ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btSdfCollisionShape_processAllTriangles_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtSdfCollisionShape) QueryPoint(arg2 BtVector3, arg3 *float32, arg4 BtVector3) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + swig_r = (bool)(C._wrap_btSdfCollisionShape_queryPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.swig_voidp(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btSdfCollisionShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtSdfCollisionShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btSdfCollisionShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSdfCollisionShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btSdfCollisionShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtSdfCollisionShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSdfCollisionShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSdfCollisionShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSdfCollisionShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSdfCollisionShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSdfCollisionShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSdfCollisionShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSdfCollisionShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btSdfCollisionShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btSdfCollisionShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSdfCollisionShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btSdfCollisionShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSdfCollisionShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btSdfCollisionShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btSdfCollisionShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSdfCollisionShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btSdfCollisionShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btSdfCollisionShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtSdfCollisionShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btSdfCollisionShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btSdfCollisionShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtSdfCollisionShape) Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + swig_r_p := C._wrap_btSdfCollisionShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtSdfCollisionShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btSdfCollisionShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtSdfCollisionShape) SwigIsBtConcaveShape() { +} + +func (p SwigcptrBtSdfCollisionShape) SwigGetBtConcaveShape() BtConcaveShape { + return SwigcptrBtConcaveShape(getSwigcptr(p)) +} + +func (p SwigcptrBtSdfCollisionShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtSdfCollisionShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtSdfCollisionShape interface { + Swigcptr() uintptr + SwigIsBtSdfCollisionShape() + InitializeSDF(arg2 string, arg3 int) (_swig_ret bool) + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + SetLocalScaling(arg2 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + CalculateLocalInertia(arg2 float32, arg3 BtVector3) + GetName() (_swig_ret string) + SetMargin(arg2 float32) + GetMargin() (_swig_ret float32) + ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) + QueryPoint(arg2 BtVector3, arg3 *float32, arg4 BtVector3) (_swig_ret bool) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg1 uintptr, arg2 BtSerializer) (_swig_ret string) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtConcaveShape() + SwigGetBtConcaveShape() BtConcaveShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtSdfCollisionShapeInternalData uintptr + +func (p SwigcptrBtSdfCollisionShapeInternalData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtSdfCollisionShapeInternalData) SwigIsBtSdfCollisionShapeInternalData() { +} + +func (arg1 SwigcptrBtSdfCollisionShapeInternalData) SetM_localScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSdfCollisionShapeInternalData_m_localScaling_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSdfCollisionShapeInternalData) GetM_localScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btSdfCollisionShapeInternalData_m_localScaling_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtSdfCollisionShapeInternalData) SetM_margin(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btSdfCollisionShapeInternalData_m_margin_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtSdfCollisionShapeInternalData) GetM_margin() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btSdfCollisionShapeInternalData_m_margin_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtSdfCollisionShapeInternalData) SetM_sdf(arg2 BtMiniSDF) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btSdfCollisionShapeInternalData_m_sdf_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtSdfCollisionShapeInternalData) GetM_sdf() (_swig_ret BtMiniSDF) { + var swig_r BtMiniSDF + _swig_i_0 := arg1 + swig_r = (BtMiniSDF)(SwigcptrBtMiniSDF(C._wrap_btSdfCollisionShapeInternalData_m_sdf_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func NewBtSdfCollisionShapeInternalData() (_swig_ret BtSdfCollisionShapeInternalData) { + var swig_r BtSdfCollisionShapeInternalData + swig_r = (BtSdfCollisionShapeInternalData)(SwigcptrBtSdfCollisionShapeInternalData(C._wrap_new_btSdfCollisionShapeInternalData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtSdfCollisionShapeInternalData(arg1 BtSdfCollisionShapeInternalData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btSdfCollisionShapeInternalData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtSdfCollisionShapeInternalData interface { + Swigcptr() uintptr + SwigIsBtSdfCollisionShapeInternalData() + SetM_localScaling(arg2 BtVector3) + GetM_localScaling() (_swig_ret BtVector3) + SetM_margin(arg2 float32) + GetM_margin() (_swig_ret float32) + SetM_sdf(arg2 BtMiniSDF) + GetM_sdf() (_swig_ret BtMiniSDF) +} + +type SwigcptrSphereTriangleDetector uintptr + +func (p SwigcptrSphereTriangleDetector) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrSphereTriangleDetector) SwigIsSphereTriangleDetector() { +} + +func (arg1 SwigcptrSphereTriangleDetector) GetClosestPoints__SWIG_0(arg2 BtDiscreteCollisionDetectorInterface_ClosestPointInput, arg3 BtDiscreteCollisionDetectorInterface_Result, arg4 BtIDebugDraw, arg5 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + C._wrap_SphereTriangleDetector_getClosestPoints__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4)) +} + +func (arg1 SwigcptrSphereTriangleDetector) GetClosestPoints__SWIG_1(arg2 BtDiscreteCollisionDetectorInterface_ClosestPointInput, arg3 BtDiscreteCollisionDetectorInterface_Result, arg4 BtIDebugDraw) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_SphereTriangleDetector_getClosestPoints__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrSphereTriangleDetector) GetClosestPoints(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.GetClosestPoints__SWIG_1(a[0].(BtDiscreteCollisionDetectorInterface_ClosestPointInput), a[1].(BtDiscreteCollisionDetectorInterface_Result), a[2].(BtIDebugDraw)) + return + } + if argc == 4 { + p.GetClosestPoints__SWIG_0(a[0].(BtDiscreteCollisionDetectorInterface_ClosestPointInput), a[1].(BtDiscreteCollisionDetectorInterface_Result), a[2].(BtIDebugDraw), a[3].(bool)) + return + } + panic("No match for overloaded function call") +} + +func NewSphereTriangleDetector(arg1 BtSphereShape, arg2 BtTriangleShape, arg3 float32) (_swig_ret SphereTriangleDetector) { + var swig_r SphereTriangleDetector + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (SphereTriangleDetector)(SwigcptrSphereTriangleDetector(C._wrap_new_SphereTriangleDetector_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)))) + return swig_r +} + +func DeleteSphereTriangleDetector(arg1 SphereTriangleDetector) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_SphereTriangleDetector_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrSphereTriangleDetector) Collide(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 *float32, arg6 *float32, arg7 float32) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + swig_r = (bool)(C._wrap_SphereTriangleDetector_collide_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.swig_voidp(_swig_i_4), C.swig_voidp(_swig_i_5), C.float(_swig_i_6))) + return swig_r +} + +func (p SwigcptrSphereTriangleDetector) SwigIsBtDiscreteCollisionDetectorInterface() { +} + +func (p SwigcptrSphereTriangleDetector) SwigGetBtDiscreteCollisionDetectorInterface() BtDiscreteCollisionDetectorInterface { + return SwigcptrBtDiscreteCollisionDetectorInterface(getSwigcptr(p)) +} + +type SphereTriangleDetector interface { + Swigcptr() uintptr + SwigIsSphereTriangleDetector() + GetClosestPoints(a ...interface{}) + Collide(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 *float32, arg6 *float32, arg7 float32) (_swig_ret bool) + SwigIsBtDiscreteCollisionDetectorInterface() + SwigGetBtDiscreteCollisionDetectorInterface() BtDiscreteCollisionDetectorInterface +} + +func SegmentSqrDistance(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + swig_r = (float32)(C._wrap_SegmentSqrDistance_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3))) + return swig_r +} + +type SwigcptrBtStaticPlaneShape uintptr + +func (p SwigcptrBtStaticPlaneShape) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtStaticPlaneShape) SwigIsBtStaticPlaneShape() { +} + +func NewBtStaticPlaneShape(arg1 BtVector3, arg2 float32) (_swig_ret BtStaticPlaneShape) { + var swig_r BtStaticPlaneShape + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + swig_r = (BtStaticPlaneShape)(SwigcptrBtStaticPlaneShape(C._wrap_new_btStaticPlaneShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)))) + return swig_r +} + +func DeleteBtStaticPlaneShape(arg1 BtStaticPlaneShape) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btStaticPlaneShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtStaticPlaneShape) GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btStaticPlaneShape_getAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtStaticPlaneShape) ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btStaticPlaneShape_processAllTriangles_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtStaticPlaneShape) CalculateLocalInertia(arg2 float32, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btStaticPlaneShape_calculateLocalInertia_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtStaticPlaneShape) SetLocalScaling(arg2 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btStaticPlaneShape_setLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtStaticPlaneShape) GetLocalScaling() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btStaticPlaneShape_getLocalScaling_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtStaticPlaneShape) GetPlaneNormal() (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btStaticPlaneShape_getPlaneNormal_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtStaticPlaneShape) GetPlaneConstant() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btStaticPlaneShape_getPlaneConstant_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtStaticPlaneShape) GetName() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btStaticPlaneShape_getName_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (arg1 SwigcptrBtStaticPlaneShape) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btStaticPlaneShape_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtStaticPlaneShape) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btStaticPlaneShape_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func (_swig_base SwigcptrBtStaticPlaneShape) GetMargin() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btStaticPlaneShape_getMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) SetMargin(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btStaticPlaneShape_setMargin_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtStaticPlaneShape) GetBoundingSphere(arg1 BtVector3, arg2 *float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + C._wrap_btStaticPlaneShape_getBoundingSphere_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (_swig_base SwigcptrBtStaticPlaneShape) GetAngularMotionDisc() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btStaticPlaneShape_getAngularMotionDisc_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btStaticPlaneShape_getContactBreakingThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btStaticPlaneShape_calculateTemporalAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (_swig_base SwigcptrBtStaticPlaneShape) IsPolyhedral() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btStaticPlaneShape_isPolyhedral_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) IsConvex2d() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btStaticPlaneShape_isConvex2d_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) IsConvex() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btStaticPlaneShape_isConvex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) IsNonMoving() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btStaticPlaneShape_isNonMoving_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) IsConcave() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btStaticPlaneShape_isConcave_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) IsCompound() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btStaticPlaneShape_isCompound_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) IsSoftBody() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btStaticPlaneShape_isSoftBody_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) IsInfinite() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btStaticPlaneShape_isInfinite_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) GetShapeType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btStaticPlaneShape_getShapeType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) { + var swig_r BtVector3 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btStaticPlaneShape_getAnisotropicRollingFrictionDirection_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) SetUserPointer(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btStaticPlaneShape_setUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtStaticPlaneShape) GetUserPointer() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btStaticPlaneShape_getUserPointer_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) SetUserIndex(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btStaticPlaneShape_setUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtStaticPlaneShape) GetUserIndex() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btStaticPlaneShape_getUserIndex_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) SetUserIndex2(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btStaticPlaneShape_setUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtStaticPlaneShape) GetUserIndex2() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btStaticPlaneShape_getUserIndex2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtStaticPlaneShape) SerializeSingleShape(arg1 BtSerializer) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btStaticPlaneShape_serializeSingleShape_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtStaticPlaneShape) SwigIsBtConcaveShape() { +} + +func (p SwigcptrBtStaticPlaneShape) SwigGetBtConcaveShape() BtConcaveShape { + return SwigcptrBtConcaveShape(getSwigcptr(p)) +} + +func (p SwigcptrBtStaticPlaneShape) SwigIsBtCollisionShape() { +} + +func (p SwigcptrBtStaticPlaneShape) SwigGetBtCollisionShape() BtCollisionShape { + return SwigcptrBtCollisionShape(getSwigcptr(p)) +} + +type BtStaticPlaneShape interface { + Swigcptr() uintptr + SwigIsBtStaticPlaneShape() + GetAabb(arg2 BtTransform, arg3 BtVector3, arg4 BtVector3) + ProcessAllTriangles(arg2 BtTriangleCallback, arg3 BtVector3, arg4 BtVector3) + CalculateLocalInertia(arg2 float32, arg3 BtVector3) + SetLocalScaling(arg2 BtVector3) + GetLocalScaling() (_swig_ret BtVector3) + GetPlaneNormal() (_swig_ret BtVector3) + GetPlaneConstant() (_swig_ret float32) + GetName() (_swig_ret string) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + GetMargin() (_swig_ret float32) + SetMargin(arg1 float32) + GetBoundingSphere(arg1 BtVector3, arg2 *float32) + GetAngularMotionDisc() (_swig_ret float32) + GetContactBreakingThreshold(arg1 float32) (_swig_ret float32) + CalculateTemporalAabb(arg1 BtTransform, arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 BtVector3, arg6 BtVector3) + IsPolyhedral() (_swig_ret bool) + IsConvex2d() (_swig_ret bool) + IsConvex() (_swig_ret bool) + IsNonMoving() (_swig_ret bool) + IsConcave() (_swig_ret bool) + IsCompound() (_swig_ret bool) + IsSoftBody() (_swig_ret bool) + IsInfinite() (_swig_ret bool) + GetShapeType() (_swig_ret int) + GetAnisotropicRollingFrictionDirection() (_swig_ret BtVector3) + SetUserPointer(arg1 uintptr) + GetUserPointer() (_swig_ret uintptr) + SetUserIndex(arg1 int) + GetUserIndex() (_swig_ret int) + SetUserIndex2(arg1 int) + GetUserIndex2() (_swig_ret int) + SerializeSingleShape(arg1 BtSerializer) + SwigIsBtConcaveShape() + SwigGetBtConcaveShape() BtConcaveShape + SwigIsBtCollisionShape() + SwigGetBtCollisionShape() BtCollisionShape +} + +type SwigcptrBtStaticPlaneShapeData uintptr + +func (p SwigcptrBtStaticPlaneShapeData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtStaticPlaneShapeData) SwigIsBtStaticPlaneShapeData() { +} + +func (arg1 SwigcptrBtStaticPlaneShapeData) SetM_collisionShapeData(arg2 BtCollisionShapeData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btStaticPlaneShapeData_m_collisionShapeData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtStaticPlaneShapeData) GetM_collisionShapeData() (_swig_ret BtCollisionShapeData) { + var swig_r BtCollisionShapeData + _swig_i_0 := arg1 + swig_r = (BtCollisionShapeData)(SwigcptrBtCollisionShapeData(C._wrap_btStaticPlaneShapeData_m_collisionShapeData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtStaticPlaneShapeData) SetM_localScaling(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btStaticPlaneShapeData_m_localScaling_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtStaticPlaneShapeData) GetM_localScaling() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btStaticPlaneShapeData_m_localScaling_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtStaticPlaneShapeData) SetM_planeNormal(arg2 BtVector3FloatData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btStaticPlaneShapeData_m_planeNormal_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtStaticPlaneShapeData) GetM_planeNormal() (_swig_ret BtVector3FloatData) { + var swig_r BtVector3FloatData + _swig_i_0 := arg1 + swig_r = (BtVector3FloatData)(SwigcptrBtVector3FloatData(C._wrap_btStaticPlaneShapeData_m_planeNormal_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtStaticPlaneShapeData) SetM_planeConstant(arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btStaticPlaneShapeData_m_planeConstant_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1)) +} + +func (arg1 SwigcptrBtStaticPlaneShapeData) GetM_planeConstant() (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btStaticPlaneShapeData_m_planeConstant_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtStaticPlaneShapeData) SetM_pad(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btStaticPlaneShapeData_m_pad_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_171)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtStaticPlaneShapeData) GetM_pad() (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + swig_r_p := C._wrap_btStaticPlaneShapeData_m_pad_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func NewBtStaticPlaneShapeData() (_swig_ret BtStaticPlaneShapeData) { + var swig_r BtStaticPlaneShapeData + swig_r = (BtStaticPlaneShapeData)(SwigcptrBtStaticPlaneShapeData(C._wrap_new_btStaticPlaneShapeData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtStaticPlaneShapeData(arg1 BtStaticPlaneShapeData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btStaticPlaneShapeData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtStaticPlaneShapeData interface { + Swigcptr() uintptr + SwigIsBtStaticPlaneShapeData() + SetM_collisionShapeData(arg2 BtCollisionShapeData) + GetM_collisionShapeData() (_swig_ret BtCollisionShapeData) + SetM_localScaling(arg2 BtVector3FloatData) + GetM_localScaling() (_swig_ret BtVector3FloatData) + SetM_planeNormal(arg2 BtVector3FloatData) + GetM_planeNormal() (_swig_ret BtVector3FloatData) + SetM_planeConstant(arg2 float32) + GetM_planeConstant() (_swig_ret float32) + SetM_pad(arg2 string) + GetM_pad() (_swig_ret string) +} + +const BtGeneric6DofSpringConstraintDataName string = "btGeneric6DofSpringConstraintData" + +type SwigcptrBtGeneric6DofSpringConstraint uintptr + +func (p SwigcptrBtGeneric6DofSpringConstraint) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) SwigIsBtGeneric6DofSpringConstraint() { +} + +func NewBtGeneric6DofSpringConstraint__SWIG_0(arg1 BtRigidBody, arg2 BtRigidBody, arg3 BtTransform, arg4 BtTransform, arg5 bool) (_swig_ret BtGeneric6DofSpringConstraint) { + var swig_r BtGeneric6DofSpringConstraint + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + swig_r = (BtGeneric6DofSpringConstraint)(SwigcptrBtGeneric6DofSpringConstraint(C._wrap_new_btGeneric6DofSpringConstraint__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C._Bool(_swig_i_4)))) + return swig_r +} + +func NewBtGeneric6DofSpringConstraint__SWIG_1(arg1 BtRigidBody, arg2 BtTransform, arg3 bool) (_swig_ret BtGeneric6DofSpringConstraint) { + var swig_r BtGeneric6DofSpringConstraint + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + swig_r = (BtGeneric6DofSpringConstraint)(SwigcptrBtGeneric6DofSpringConstraint(C._wrap_new_btGeneric6DofSpringConstraint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C._Bool(_swig_i_2)))) + return swig_r +} + +func NewBtGeneric6DofSpringConstraint(a ...interface{}) BtGeneric6DofSpringConstraint { + argc := len(a) + if argc == 3 { + return NewBtGeneric6DofSpringConstraint__SWIG_1(a[0].(BtRigidBody), a[1].(BtTransform), a[2].(bool)) + } + if argc == 5 { + return NewBtGeneric6DofSpringConstraint__SWIG_0(a[0].(BtRigidBody), a[1].(BtRigidBody), a[2].(BtTransform), a[3].(BtTransform), a[4].(bool)) + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) EnableSpring(arg2 int, arg3 bool) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btGeneric6DofSpringConstraint_enableSpring_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C._Bool(_swig_i_2)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) SetStiffness(arg2 int, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btGeneric6DofSpringConstraint_setStiffness_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) SetDamping(arg2 int, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btGeneric6DofSpringConstraint_setDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) SetEquilibriumPoint__SWIG_0() { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_setEquilibriumPoint__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) SetEquilibriumPoint__SWIG_1(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofSpringConstraint_setEquilibriumPoint__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) SetEquilibriumPoint__SWIG_2(arg2 int, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btGeneric6DofSpringConstraint_setEquilibriumPoint__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.float(_swig_i_2)) +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) SetEquilibriumPoint(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.SetEquilibriumPoint__SWIG_0() + return + } + if argc == 1 { + p.SetEquilibriumPoint__SWIG_1(a[0].(int)) + return + } + if argc == 2 { + p.SetEquilibriumPoint__SWIG_2(a[0].(int), a[1].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) IsSpringEnabled(arg2 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (bool)(C._wrap_btGeneric6DofSpringConstraint_isSpringEnabled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) GetStiffness(arg2 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_getStiffness_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) GetDamping(arg2 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_getDamping_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) GetEquilibriumPoint(arg2 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_getEquilibriumPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) SetAxis(arg2 BtVector3, arg3 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + C._wrap_btGeneric6DofSpringConstraint_setAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) GetInfo2(arg2 BtTypedConstraint_btConstraintInfo2) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofSpringConstraint_getInfo2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) CalculateSerializeBufferSize() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btGeneric6DofSpringConstraint_calculateSerializeBufferSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraint) Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) { + var swig_r string + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + swig_r_p := C._wrap_btGeneric6DofSpringConstraint_serialize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2)) + swig_r = *(*string)(unsafe.Pointer(&swig_r_p)) + var swig_r_1 string + swig_r_1 = swigCopyString(swig_r) + return swig_r_1 +} + +func DeleteBtGeneric6DofSpringConstraint(arg1 BtGeneric6DofSpringConstraint) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGeneric6DofSpringConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetM_useSolveConstraintObsolete(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_SetbtGeneric6DofSpringConstraint_M_useSolveConstraintObsolete_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetM_useSolveConstraintObsolete() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_GetbtGeneric6DofSpringConstraint_M_useSolveConstraintObsolete_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) CalculateTransforms__SWIG_0(arg1 BtTransform, arg2 BtTransform) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofSpringConstraint_calculateTransforms__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) CalculateTransforms__SWIG_1() { + C._wrap_btGeneric6DofSpringConstraint_calculateTransforms__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) CalculateTransforms(a ...interface{}) { + argc := len(a) + if argc == 0 { + p.CalculateTransforms__SWIG_1() + return + } + if argc == 2 { + p.CalculateTransforms__SWIG_0(a[0].(BtTransform), a[1].(BtTransform)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetCalculatedTransformA() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofSpringConstraint_getCalculatedTransformA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetCalculatedTransformB() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofSpringConstraint_getCalculatedTransformB_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetFrameOffsetA__SWIG_0() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofSpringConstraint_getFrameOffsetA__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetFrameOffsetA__SWIG_1() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofSpringConstraint_getFrameOffsetA__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) GetFrameOffsetA(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetFrameOffsetA__SWIG_0() + } + if argc == 0 { + return p.GetFrameOffsetA__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetFrameOffsetB__SWIG_0() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofSpringConstraint_getFrameOffsetB__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetFrameOffsetB__SWIG_1() (_swig_ret BtTransform) { + var swig_r BtTransform + swig_r = (BtTransform)(SwigcptrBtTransform(C._wrap_btGeneric6DofSpringConstraint_getFrameOffsetB__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) GetFrameOffsetB(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetFrameOffsetB__SWIG_0() + } + if argc == 0 { + return p.GetFrameOffsetB__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) BuildJacobian() { + C._wrap_btGeneric6DofSpringConstraint_buildJacobian_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetInfo1(arg1 BtTypedConstraint_btConstraintInfo1) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_getInfo1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetInfo1NonVirtual(arg1 BtTypedConstraint_btConstraintInfo1) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_getInfo1NonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetInfo2NonVirtual(arg1 BtTypedConstraint_btConstraintInfo2, arg2 BtTransform, arg3 BtTransform, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + C._wrap_btGeneric6DofSpringConstraint_getInfo2NonVirtual_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) UpdateRHS(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_updateRHS_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetAxis(arg1 int) (_swig_ret BtVector3) { + var swig_r BtVector3 + _swig_i_0 := arg1 + swig_r = (BtVector3)(SwigcptrBtVector3(C._wrap_btGeneric6DofSpringConstraint_getAxis_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetAngle(arg1 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_getAngle_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetRelativePivotPosition(arg1 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_getRelativePivotPosition_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetFrames(arg1 BtTransform, arg2 BtTransform) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofSpringConstraint_setFrames_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) TestAngularLimitMotor(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btGeneric6DofSpringConstraint_testAngularLimitMotor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetLinearLowerLimit(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_setLinearLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetLinearLowerLimit(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_getLinearLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetLinearUpperLimit(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_setLinearUpperLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetLinearUpperLimit(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_getLinearUpperLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetAngularLowerLimit(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_setAngularLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetAngularLowerLimit(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_getAngularLowerLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetAngularUpperLimit(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_setAngularUpperLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetAngularUpperLimit(arg1 BtVector3) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_getAngularUpperLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetRotationalLimitMotor(arg1 int) (_swig_ret BtRotationalLimitMotor) { + var swig_r BtRotationalLimitMotor + _swig_i_0 := arg1 + swig_r = (BtRotationalLimitMotor)(SwigcptrBtRotationalLimitMotor(C._wrap_btGeneric6DofSpringConstraint_getRotationalLimitMotor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetTranslationalLimitMotor() (_swig_ret BtTranslationalLimitMotor) { + var swig_r BtTranslationalLimitMotor + swig_r = (BtTranslationalLimitMotor)(SwigcptrBtTranslationalLimitMotor(C._wrap_btGeneric6DofSpringConstraint_getTranslationalLimitMotor_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetLimit(arg1 int, arg2 float32, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btGeneric6DofSpringConstraint_setLimit_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) IsLimited(arg1 int) (_swig_ret bool) { + var swig_r bool + _swig_i_0 := arg1 + swig_r = (bool)(C._wrap_btGeneric6DofSpringConstraint_isLimited_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) CalcAnchorPos() { + C._wrap_btGeneric6DofSpringConstraint_calcAnchorPos_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) Get_limit_motor_info2__SWIG_0(arg1 BtRotationalLimitMotor, arg2 BtTransform, arg3 BtTransform, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3, arg8 BtTypedConstraint_btConstraintInfo2, arg9 int, arg10 BtVector3, arg11 int, arg12 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := arg9 + _swig_i_9 := getSwigcptr(arg10) + _swig_i_10 := arg11 + _swig_i_11 := arg12 + swig_r = (int)(C._wrap_btGeneric6DofSpringConstraint_get_limit_motor_info2__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7), C.swig_intgo(_swig_i_8), C.uintptr_t(_swig_i_9), C.swig_intgo(_swig_i_10), C.swig_intgo(_swig_i_11))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) Get_limit_motor_info2__SWIG_1(arg1 BtRotationalLimitMotor, arg2 BtTransform, arg3 BtTransform, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3, arg8 BtTypedConstraint_btConstraintInfo2, arg9 int, arg10 BtVector3, arg11 int) (_swig_ret int) { + var swig_r int + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := arg9 + _swig_i_9 := getSwigcptr(arg10) + _swig_i_10 := arg11 + swig_r = (int)(C._wrap_btGeneric6DofSpringConstraint_get_limit_motor_info2__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7), C.swig_intgo(_swig_i_8), C.uintptr_t(_swig_i_9), C.swig_intgo(_swig_i_10))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) Get_limit_motor_info2(a ...interface{}) int { + argc := len(a) + if argc == 11 { + return p.Get_limit_motor_info2__SWIG_1(a[0].(BtRotationalLimitMotor), a[1].(BtTransform), a[2].(BtTransform), a[3].(BtVector3), a[4].(BtVector3), a[5].(BtVector3), a[6].(BtVector3), a[7].(BtTypedConstraint_btConstraintInfo2), a[8].(int), a[9].(BtVector3), a[10].(int)) + } + if argc == 12 { + return p.Get_limit_motor_info2__SWIG_0(a[0].(BtRotationalLimitMotor), a[1].(BtTransform), a[2].(BtTransform), a[3].(BtVector3), a[4].(BtVector3), a[5].(BtVector3), a[6].(BtVector3), a[7].(BtTypedConstraint_btConstraintInfo2), a[8].(int), a[9].(BtVector3), a[10].(int), a[11].(int)) + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetUseFrameOffset() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btGeneric6DofSpringConstraint_getUseFrameOffset_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetUseFrameOffset(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_setUseFrameOffset_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetUseLinearReferenceFrameA() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btGeneric6DofSpringConstraint_getUseLinearReferenceFrameA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetUseLinearReferenceFrameA(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_setUseLinearReferenceFrameA_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetParam__SWIG_0(arg1 int, arg2 float32, arg3 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + C._wrap_btGeneric6DofSpringConstraint_setParam__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.float(_swig_i_1), C.swig_intgo(_swig_i_2)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetParam__SWIG_1(arg1 int, arg2 float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofSpringConstraint_setParam__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.float(_swig_i_1)) +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) SetParam(a ...interface{}) { + argc := len(a) + if argc == 2 { + p.SetParam__SWIG_1(a[0].(int), a[1].(float32)) + return + } + if argc == 3 { + p.SetParam__SWIG_0(a[0].(int), a[1].(float32), a[2].(int)) + return + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetParam__SWIG_0(arg1 int, arg2 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + _swig_i_1 := arg2 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_getParam__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0), C.swig_intgo(_swig_i_1))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetParam__SWIG_1(arg1 int) (_swig_ret float32) { + var swig_r float32 + _swig_i_0 := arg1 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_getParam__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) GetParam(a ...interface{}) float32 { + argc := len(a) + if argc == 1 { + return p.GetParam__SWIG_1(a[0].(int)) + } + if argc == 2 { + return p.GetParam__SWIG_0(a[0].(int), a[1].(int)) + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetFlags() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofSpringConstraint_getFlags_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func BtGeneric6DofSpringConstraintGetFixedBody() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btGeneric6DofSpringConstraint_getFixedBody_mbt_e879218550ba2e2b())) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetOverrideNumSolverIterations() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofSpringConstraint_getOverrideNumSolverIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetOverrideNumSolverIterations(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_setOverrideNumSolverIterations_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetupSolverConstraint(arg1 BtAlignedObjectArray_Sl_btSolverConstraint_Sg_, arg2 int, arg3 int, arg4 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + C._wrap_btGeneric6DofSpringConstraint_setupSolverConstraint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1), C.swig_intgo(_swig_i_2), C.float(_swig_i_3)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) InternalSetAppliedImpulse(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_internalSetAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) InternalGetAppliedImpulse() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_internalGetAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetBreakingImpulseThreshold() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_getBreakingImpulseThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetBreakingImpulseThreshold(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_setBreakingImpulseThreshold_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) IsEnabled() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btGeneric6DofSpringConstraint_isEnabled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetEnabled(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_setEnabled_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SolveConstraintObsolete(arg1 BtSolverBody, arg2 BtSolverBody, arg3 float32) { + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btGeneric6DofSpringConstraint_solveConstraintObsolete_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetRigidBodyA__SWIG_0() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btGeneric6DofSpringConstraint_getRigidBodyA__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetRigidBodyA__SWIG_1() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btGeneric6DofSpringConstraint_getRigidBodyA__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) GetRigidBodyA(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetRigidBodyA__SWIG_0() + } + if argc == 0 { + return p.GetRigidBodyA__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetRigidBodyB__SWIG_0() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btGeneric6DofSpringConstraint_getRigidBodyB__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetRigidBodyB__SWIG_1() (_swig_ret BtRigidBody) { + var swig_r BtRigidBody + swig_r = (BtRigidBody)(SwigcptrBtRigidBody(C._wrap_btGeneric6DofSpringConstraint_getRigidBodyB__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) GetRigidBodyB(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetRigidBodyB__SWIG_0() + } + if argc == 0 { + return p.GetRigidBodyB__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetUserConstraintType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofSpringConstraint_getUserConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetUserConstraintType(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_setUserConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetUserConstraintId(arg1 int) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_setUserConstraintId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetUserConstraintId() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofSpringConstraint_getUserConstraintId_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetUserConstraintPtr(arg1 uintptr) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_setUserConstraintPtr_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetUserConstraintPtr() (_swig_ret uintptr) { + var swig_r uintptr + swig_r = (uintptr)(C._wrap_btGeneric6DofSpringConstraint_getUserConstraintPtr_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetJointFeedback(arg1 BtJointFeedback) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btGeneric6DofSpringConstraint_setJointFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetJointFeedback__SWIG_0() (_swig_ret BtJointFeedback) { + var swig_r BtJointFeedback + swig_r = (BtJointFeedback)(SwigcptrBtJointFeedback(C._wrap_btGeneric6DofSpringConstraint_getJointFeedback__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetJointFeedback__SWIG_1() (_swig_ret BtJointFeedback) { + var swig_r BtJointFeedback + swig_r = (BtJointFeedback)(SwigcptrBtJointFeedback(C._wrap_btGeneric6DofSpringConstraint_getJointFeedback__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base)))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) GetJointFeedback(a ...interface{}) interface{} { + argc := len(a) + if argc == 0 { + return p.GetJointFeedback__SWIG_0() + } + if argc == 0 { + return p.GetJointFeedback__SWIG_1() + } + panic("No match for overloaded function call") +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetUid() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofSpringConstraint_getUid_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) NeedsFeedback() (_swig_ret bool) { + var swig_r bool + swig_r = (bool)(C._wrap_btGeneric6DofSpringConstraint_needsFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) EnableFeedback(arg1 bool) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_enableFeedback_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C._Bool(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetAppliedImpulse() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_getAppliedImpulse_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetConstraintType() (_swig_ret BtTypedConstraintType) { + var swig_r BtTypedConstraintType + swig_r = (BtTypedConstraintType)(C._wrap_btGeneric6DofSpringConstraint_getConstraintType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetDbgDrawSize(arg1 float32) { + _swig_i_0 := arg1 + C._wrap_btGeneric6DofSpringConstraint_setDbgDrawSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.float(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetDbgDrawSize() (_swig_ret float32) { + var swig_r float32 + swig_r = (float32)(C._wrap_btGeneric6DofSpringConstraint_getDbgDrawSize_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) SetM_objectType(arg1 int) { + _swig_i_0 := arg1 + C._wrap_SetbtGeneric6DofSpringConstraint_M_objectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.swig_intgo(_swig_i_0)) +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetM_objectType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_GetbtGeneric6DofSpringConstraint_M_objectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (_swig_base SwigcptrBtGeneric6DofSpringConstraint) GetObjectType() (_swig_ret int) { + var swig_r int + swig_r = (int)(C._wrap_btGeneric6DofSpringConstraint_getObjectType_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base))) + return swig_r +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) SwigIsBtGeneric6DofConstraint() { +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) SwigGetBtGeneric6DofConstraint() BtGeneric6DofConstraint { + return SwigcptrBtGeneric6DofConstraint(getSwigcptr(p)) +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) SwigIsBtTypedConstraint() { +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) SwigGetBtTypedConstraint() BtTypedConstraint { + return SwigcptrBtTypedConstraint(getSwigcptr(p)) +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) SwigIsBtTypedObject() { +} + +func (p SwigcptrBtGeneric6DofSpringConstraint) SwigGetBtTypedObject() BtTypedObject { + return SwigcptrBtTypedObject(getSwigcptr(p)) +} + +type BtGeneric6DofSpringConstraint interface { + Swigcptr() uintptr + SwigIsBtGeneric6DofSpringConstraint() + EnableSpring(arg2 int, arg3 bool) + SetStiffness(arg2 int, arg3 float32) + SetDamping(arg2 int, arg3 float32) + SetEquilibriumPoint(a ...interface{}) + IsSpringEnabled(arg2 int) (_swig_ret bool) + GetStiffness(arg2 int) (_swig_ret float32) + GetDamping(arg2 int) (_swig_ret float32) + GetEquilibriumPoint(arg2 int) (_swig_ret float32) + SetAxis(arg2 BtVector3, arg3 BtVector3) + GetInfo2(arg2 BtTypedConstraint_btConstraintInfo2) + CalculateSerializeBufferSize() (_swig_ret int) + Serialize(arg2 uintptr, arg3 BtSerializer) (_swig_ret string) + SetM_useSolveConstraintObsolete(arg1 bool) + GetM_useSolveConstraintObsolete() (_swig_ret bool) + CalculateTransforms(a ...interface{}) + GetCalculatedTransformA() (_swig_ret BtTransform) + GetCalculatedTransformB() (_swig_ret BtTransform) + GetFrameOffsetA(a ...interface{}) interface{} + GetFrameOffsetB(a ...interface{}) interface{} + BuildJacobian() + GetInfo1(arg1 BtTypedConstraint_btConstraintInfo1) + GetInfo1NonVirtual(arg1 BtTypedConstraint_btConstraintInfo1) + GetInfo2NonVirtual(arg1 BtTypedConstraint_btConstraintInfo2, arg2 BtTransform, arg3 BtTransform, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3) + UpdateRHS(arg1 float32) + GetAxis(arg1 int) (_swig_ret BtVector3) + GetAngle(arg1 int) (_swig_ret float32) + GetRelativePivotPosition(arg1 int) (_swig_ret float32) + SetFrames(arg1 BtTransform, arg2 BtTransform) + TestAngularLimitMotor(arg1 int) (_swig_ret bool) + SetLinearLowerLimit(arg1 BtVector3) + GetLinearLowerLimit(arg1 BtVector3) + SetLinearUpperLimit(arg1 BtVector3) + GetLinearUpperLimit(arg1 BtVector3) + SetAngularLowerLimit(arg1 BtVector3) + GetAngularLowerLimit(arg1 BtVector3) + SetAngularUpperLimit(arg1 BtVector3) + GetAngularUpperLimit(arg1 BtVector3) + GetRotationalLimitMotor(arg1 int) (_swig_ret BtRotationalLimitMotor) + GetTranslationalLimitMotor() (_swig_ret BtTranslationalLimitMotor) + SetLimit(arg1 int, arg2 float32, arg3 float32) + IsLimited(arg1 int) (_swig_ret bool) + CalcAnchorPos() + Get_limit_motor_info2(a ...interface{}) int + GetUseFrameOffset() (_swig_ret bool) + SetUseFrameOffset(arg1 bool) + GetUseLinearReferenceFrameA() (_swig_ret bool) + SetUseLinearReferenceFrameA(arg1 bool) + SetParam(a ...interface{}) + GetParam(a ...interface{}) float32 + GetFlags() (_swig_ret int) + GetOverrideNumSolverIterations() (_swig_ret int) + SetOverrideNumSolverIterations(arg1 int) + SetupSolverConstraint(arg1 BtAlignedObjectArray_Sl_btSolverConstraint_Sg_, arg2 int, arg3 int, arg4 float32) + InternalSetAppliedImpulse(arg1 float32) + InternalGetAppliedImpulse() (_swig_ret float32) + GetBreakingImpulseThreshold() (_swig_ret float32) + SetBreakingImpulseThreshold(arg1 float32) + IsEnabled() (_swig_ret bool) + SetEnabled(arg1 bool) + SolveConstraintObsolete(arg1 BtSolverBody, arg2 BtSolverBody, arg3 float32) + GetRigidBodyA(a ...interface{}) interface{} + GetRigidBodyB(a ...interface{}) interface{} + GetUserConstraintType() (_swig_ret int) + SetUserConstraintType(arg1 int) + SetUserConstraintId(arg1 int) + GetUserConstraintId() (_swig_ret int) + SetUserConstraintPtr(arg1 uintptr) + GetUserConstraintPtr() (_swig_ret uintptr) + SetJointFeedback(arg1 BtJointFeedback) + GetJointFeedback(a ...interface{}) interface{} + GetUid() (_swig_ret int) + NeedsFeedback() (_swig_ret bool) + EnableFeedback(arg1 bool) + GetAppliedImpulse() (_swig_ret float32) + GetConstraintType() (_swig_ret BtTypedConstraintType) + SetDbgDrawSize(arg1 float32) + GetDbgDrawSize() (_swig_ret float32) + SetM_objectType(arg1 int) + GetM_objectType() (_swig_ret int) + GetObjectType() (_swig_ret int) + SwigIsBtGeneric6DofConstraint() + SwigGetBtGeneric6DofConstraint() BtGeneric6DofConstraint + SwigIsBtTypedConstraint() + SwigGetBtTypedConstraint() BtTypedConstraint + SwigIsBtTypedObject() + SwigGetBtTypedObject() BtTypedObject +} + +type SwigcptrBtGeneric6DofSpringConstraintData uintptr + +func (p SwigcptrBtGeneric6DofSpringConstraintData) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGeneric6DofSpringConstraintData) SwigIsBtGeneric6DofSpringConstraintData() { +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintData) SetM_6dofData(arg2 BtGeneric6DofConstraintData) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofSpringConstraintData_m_6dofData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintData) GetM_6dofData() (_swig_ret BtGeneric6DofConstraintData) { + var swig_r BtGeneric6DofConstraintData + _swig_i_0 := arg1 + swig_r = (BtGeneric6DofConstraintData)(SwigcptrBtGeneric6DofConstraintData(C._wrap_btGeneric6DofSpringConstraintData_m_6dofData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintData) SetM_springEnabled(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofSpringConstraintData_m_springEnabled_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintData) GetM_springEnabled() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btGeneric6DofSpringConstraintData_m_springEnabled_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintData) SetM_equilibriumPoint(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofSpringConstraintData_m_equilibriumPoint_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintData) GetM_equilibriumPoint() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btGeneric6DofSpringConstraintData_m_equilibriumPoint_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintData) SetM_springStiffness(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofSpringConstraintData_m_springStiffness_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintData) GetM_springStiffness() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btGeneric6DofSpringConstraintData_m_springStiffness_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintData) SetM_springDamping(arg2 *float32) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofSpringConstraintData_m_springDamping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintData) GetM_springDamping() (_swig_ret *float32) { + var swig_r *float32 + _swig_i_0 := arg1 + swig_r = (*float32)(C._wrap_btGeneric6DofSpringConstraintData_m_springDamping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtGeneric6DofSpringConstraintData() (_swig_ret BtGeneric6DofSpringConstraintData) { + var swig_r BtGeneric6DofSpringConstraintData + swig_r = (BtGeneric6DofSpringConstraintData)(SwigcptrBtGeneric6DofSpringConstraintData(C._wrap_new_btGeneric6DofSpringConstraintData_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtGeneric6DofSpringConstraintData(arg1 BtGeneric6DofSpringConstraintData) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGeneric6DofSpringConstraintData_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtGeneric6DofSpringConstraintData interface { + Swigcptr() uintptr + SwigIsBtGeneric6DofSpringConstraintData() + SetM_6dofData(arg2 BtGeneric6DofConstraintData) + GetM_6dofData() (_swig_ret BtGeneric6DofConstraintData) + SetM_springEnabled(arg2 *int) + GetM_springEnabled() (_swig_ret *int) + SetM_equilibriumPoint(arg2 *float32) + GetM_equilibriumPoint() (_swig_ret *float32) + SetM_springStiffness(arg2 *float32) + GetM_springStiffness() (_swig_ret *float32) + SetM_springDamping(arg2 *float32) + GetM_springDamping() (_swig_ret *float32) +} + +type SwigcptrBtGeneric6DofSpringConstraintDoubleData2 uintptr + +func (p SwigcptrBtGeneric6DofSpringConstraintDoubleData2) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtGeneric6DofSpringConstraintDoubleData2) SwigIsBtGeneric6DofSpringConstraintDoubleData2() { +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintDoubleData2) SetM_6dofData(arg2 BtGeneric6DofConstraintDoubleData2) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btGeneric6DofSpringConstraintDoubleData2_m_6dofData_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintDoubleData2) GetM_6dofData() (_swig_ret BtGeneric6DofConstraintDoubleData2) { + var swig_r BtGeneric6DofConstraintDoubleData2 + _swig_i_0 := arg1 + swig_r = (BtGeneric6DofConstraintDoubleData2)(SwigcptrBtGeneric6DofConstraintDoubleData2(C._wrap_btGeneric6DofSpringConstraintDoubleData2_m_6dofData_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintDoubleData2) SetM_springEnabled(arg2 *int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofSpringConstraintDoubleData2_m_springEnabled_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintDoubleData2) GetM_springEnabled() (_swig_ret *int) { + var swig_r *int + _swig_i_0 := arg1 + swig_r = (*int)(C._wrap_btGeneric6DofSpringConstraintDoubleData2_m_springEnabled_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintDoubleData2) SetM_equilibriumPoint(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofSpringConstraintDoubleData2_m_equilibriumPoint_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintDoubleData2) GetM_equilibriumPoint() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btGeneric6DofSpringConstraintDoubleData2_m_equilibriumPoint_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintDoubleData2) SetM_springStiffness(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofSpringConstraintDoubleData2_m_springStiffness_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintDoubleData2) GetM_springStiffness() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btGeneric6DofSpringConstraintDoubleData2_m_springStiffness_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintDoubleData2) SetM_springDamping(arg2 *float64) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btGeneric6DofSpringConstraintDoubleData2_m_springDamping_set_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_voidp(_swig_i_1)) +} + +func (arg1 SwigcptrBtGeneric6DofSpringConstraintDoubleData2) GetM_springDamping() (_swig_ret *float64) { + var swig_r *float64 + _swig_i_0 := arg1 + swig_r = (*float64)(C._wrap_btGeneric6DofSpringConstraintDoubleData2_m_springDamping_get_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func NewBtGeneric6DofSpringConstraintDoubleData2() (_swig_ret BtGeneric6DofSpringConstraintDoubleData2) { + var swig_r BtGeneric6DofSpringConstraintDoubleData2 + swig_r = (BtGeneric6DofSpringConstraintDoubleData2)(SwigcptrBtGeneric6DofSpringConstraintDoubleData2(C._wrap_new_btGeneric6DofSpringConstraintDoubleData2_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtGeneric6DofSpringConstraintDoubleData2(arg1 BtGeneric6DofSpringConstraintDoubleData2) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btGeneric6DofSpringConstraintDoubleData2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtGeneric6DofSpringConstraintDoubleData2 interface { + Swigcptr() uintptr + SwigIsBtGeneric6DofSpringConstraintDoubleData2() + SetM_6dofData(arg2 BtGeneric6DofConstraintDoubleData2) + GetM_6dofData() (_swig_ret BtGeneric6DofConstraintDoubleData2) + SetM_springEnabled(arg2 *int) + GetM_springEnabled() (_swig_ret *int) + SetM_equilibriumPoint(arg2 *float64) + GetM_equilibriumPoint() (_swig_ret *float64) + SetM_springStiffness(arg2 *float64) + GetM_springStiffness() (_swig_ret *float64) + SetM_springDamping(arg2 *float64) + GetM_springDamping() (_swig_ret *float64) +} + +type SwigcptrBtMDefaultColors uintptr + +func (p SwigcptrBtMDefaultColors) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMDefaultColors) SwigIsBtMDefaultColors() { +} + +func NewBtMDefaultColors(arg1 BtVector3, arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3) (_swig_ret BtMDefaultColors) { + var swig_r BtMDefaultColors + _swig_i_0 := getSwigcptr(arg1) + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + swig_r = (BtMDefaultColors)(SwigcptrBtMDefaultColors(C._wrap_new_btMDefaultColors_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6)))) + return swig_r +} + +func DeleteBtMDefaultColors(arg1 BtMDefaultColors) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMDefaultColors_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +type BtMDefaultColors interface { + Swigcptr() uintptr + SwigIsBtMDefaultColors() +} + +type _swig_DirectorBtMDebugDrawLiner struct { + SwigcptrBtMDebugDrawLiner + v interface{} +} + +func (p *_swig_DirectorBtMDebugDrawLiner) Swigcptr() uintptr { + return getSwigcptr(p.SwigcptrBtMDebugDrawLiner) +} + +func (p *_swig_DirectorBtMDebugDrawLiner) SwigIsBtMDebugDrawLiner() { +} + +func (p *_swig_DirectorBtMDebugDrawLiner) DirectorInterface() interface{} { + return p.v +} + +func NewDirectorBtMDebugDrawLiner(v interface{}) BtMDebugDrawLiner { + p := &_swig_DirectorBtMDebugDrawLiner{0, v} + p.SwigcptrBtMDebugDrawLiner = SwigcptrBtMDebugDrawLiner(C._wrap__swig_NewDirectorBtMDebugDrawLinerBtMDebugDrawLiner_mbt_e879218550ba2e2b(C.int(swigDirectorAdd(p)))) + return p +} + +func DeleteDirectorBtMDebugDrawLiner(arg1 BtMDebugDrawLiner) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_DeleteDirectorBtMDebugDrawLiner_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +//export Swiggo_DeleteDirector_btMDebugDrawLiner_mbt_e879218550ba2e2b +func Swiggo_DeleteDirector_btMDebugDrawLiner_mbt_e879218550ba2e2b(c int) { + swigDirectorLookup(c).(*_swig_DirectorBtMDebugDrawLiner).SwigcptrBtMDebugDrawLiner = 0 + swigDirectorDelete(c) +} + +type _swig_DirectorInterfaceBtMDebugDrawLinerDrawLine interface { + DrawLine(BtVector3, BtVector3, BtVector3) +} + +func (swig_p *_swig_DirectorBtMDebugDrawLiner) DrawLine(from BtVector3, to BtVector3, color BtVector3) { + if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceBtMDebugDrawLinerDrawLine); swig_ok { + swig_g.DrawLine(from, to, color) + return + } + panic("call to pure virtual method") +} + +//export Swig_DirectorBtMDebugDrawLiner_callback_drawLine_mbt_e879218550ba2e2b +func Swig_DirectorBtMDebugDrawLiner_callback_drawLine_mbt_e879218550ba2e2b(swig_c int, from uintptr, to uintptr, color uintptr) { + swig_p := swigDirectorLookup(swig_c).(*_swig_DirectorBtMDebugDrawLiner) + swig_p.DrawLine(SwigcptrBtVector3(from), SwigcptrBtVector3(to), SwigcptrBtVector3(color)) +} + +type SwigcptrBtMDebugDrawLiner uintptr + +func (p SwigcptrBtMDebugDrawLiner) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMDebugDrawLiner) SwigIsBtMDebugDrawLiner() { +} + +func (p SwigcptrBtMDebugDrawLiner) DirectorInterface() interface{} { + return nil +} + +func NewBtMDebugDrawLiner() (_swig_ret BtMDebugDrawLiner) { + var swig_r BtMDebugDrawLiner + swig_r = (BtMDebugDrawLiner)(SwigcptrBtMDebugDrawLiner(C._wrap_new_btMDebugDrawLiner_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtMDebugDrawLiner(arg1 BtMDebugDrawLiner) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMDebugDrawLiner_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtMDebugDrawLiner) DrawLine(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btMDebugDrawLiner_drawLine_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +type BtMDebugDrawLiner interface { + Swigcptr() uintptr + SwigIsBtMDebugDrawLiner() + DirectorInterface() interface{} + DrawLine(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) +} + +type SwigcptrBtMDebugDraw uintptr + +func (p SwigcptrBtMDebugDraw) Swigcptr() uintptr { + return (uintptr)(p) +} + +func (p SwigcptrBtMDebugDraw) SwigIsBtMDebugDraw() { +} + +func NewBtMDebugDraw() (_swig_ret BtMDebugDraw) { + var swig_r BtMDebugDraw + swig_r = (BtMDebugDraw)(SwigcptrBtMDebugDraw(C._wrap_new_btMDebugDraw_mbt_e879218550ba2e2b())) + return swig_r +} + +func DeleteBtMDebugDraw(arg1 BtMDebugDraw) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_delete_btMDebugDraw_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawLine__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btMDebugDraw_drawLine__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawSphere__SWIG_0(arg2 float32, arg3 BtTransform, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btMDebugDraw_drawSphere__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawSphere__SWIG_1(arg2 BtVector3, arg3 float32, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btMDebugDraw_drawSphere__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtMDebugDraw) DrawSphere(a ...interface{}) { + argc := len(a) + if argc == 3 { + if _, ok := a[0].(BtVector3); !ok { + goto check_1 + } + if _, ok := a[1].(float32); !ok { + goto check_1 + } + p.DrawSphere__SWIG_1(a[0].(BtVector3), a[1].(float32), a[2].(BtVector3)) + return + } +check_1: + if argc == 3 { + p.DrawSphere__SWIG_0(a[0].(float32), a[1].(BtTransform), a[2].(BtVector3)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMDebugDraw) DrawTriangle__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 BtVector3, arg7 BtVector3, arg8 BtVector3, arg9 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + _swig_i_6 := getSwigcptr(arg7) + _swig_i_7 := getSwigcptr(arg8) + _swig_i_8 := arg9 + C._wrap_btMDebugDraw_drawTriangle__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5), C.uintptr_t(_swig_i_6), C.uintptr_t(_swig_i_7), C.float(_swig_i_8)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawTriangle__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 BtVector3, arg6 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := arg6 + C._wrap_btMDebugDraw_drawTriangle__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4), C.float(_swig_i_5)) +} + +func (p SwigcptrBtMDebugDraw) DrawTriangle(a ...interface{}) { + argc := len(a) + if argc == 5 { + p.DrawTriangle__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(BtVector3), a[4].(float32)) + return + } + if argc == 8 { + p.DrawTriangle__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(BtVector3), a[4].(BtVector3), a[5].(BtVector3), a[6].(BtVector3), a[7].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMDebugDraw) DrawAabb(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btMDebugDraw_drawAabb_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawTransform(arg2 BtTransform, arg3 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btMDebugDraw_drawTransform_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawArc__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 BtVector3, arg10 bool, arg11 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := arg10 + _swig_i_10 := arg11 + C._wrap_btMDebugDraw_drawArc__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.uintptr_t(_swig_i_8), C._Bool(_swig_i_9), C.float(_swig_i_10)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawArc__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 BtVector3, arg10 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := getSwigcptr(arg9) + _swig_i_9 := arg10 + C._wrap_btMDebugDraw_drawArc__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.uintptr_t(_swig_i_8), C._Bool(_swig_i_9)) +} + +func (p SwigcptrBtMDebugDraw) DrawArc(a ...interface{}) { + argc := len(a) + if argc == 9 { + p.DrawArc__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(BtVector3), a[8].(bool)) + return + } + if argc == 10 { + p.DrawArc__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(BtVector3), a[8].(bool), a[9].(float32)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMDebugDraw) DrawSpherePatch__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 float32, arg10 BtVector3, arg11 float32, arg12 bool) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + _swig_i_9 := getSwigcptr(arg10) + _swig_i_10 := arg11 + _swig_i_11 := arg12 + C._wrap_btMDebugDraw_drawSpherePatch__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.float(_swig_i_8), C.uintptr_t(_swig_i_9), C.float(_swig_i_10), C._Bool(_swig_i_11)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawSpherePatch__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 float32, arg10 BtVector3, arg11 float32) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + _swig_i_9 := getSwigcptr(arg10) + _swig_i_10 := arg11 + C._wrap_btMDebugDraw_drawSpherePatch__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.float(_swig_i_8), C.uintptr_t(_swig_i_9), C.float(_swig_i_10)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawSpherePatch__SWIG_2(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3, arg5 float32, arg6 float32, arg7 float32, arg8 float32, arg9 float32, arg10 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := arg5 + _swig_i_5 := arg6 + _swig_i_6 := arg7 + _swig_i_7 := arg8 + _swig_i_8 := arg9 + _swig_i_9 := getSwigcptr(arg10) + C._wrap_btMDebugDraw_drawSpherePatch__SWIG_2_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.float(_swig_i_4), C.float(_swig_i_5), C.float(_swig_i_6), C.float(_swig_i_7), C.float(_swig_i_8), C.uintptr_t(_swig_i_9)) +} + +func (p SwigcptrBtMDebugDraw) DrawSpherePatch(a ...interface{}) { + argc := len(a) + if argc == 9 { + p.DrawSpherePatch__SWIG_2(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(float32), a[8].(BtVector3)) + return + } + if argc == 10 { + p.DrawSpherePatch__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(float32), a[8].(BtVector3), a[9].(float32)) + return + } + if argc == 11 { + p.DrawSpherePatch__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(float32), a[4].(float32), a[5].(float32), a[6].(float32), a[7].(float32), a[8].(BtVector3), a[9].(float32), a[10].(bool)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMDebugDraw) DrawBox__SWIG_0(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btMDebugDraw_drawBox__SWIG_0_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawBox__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtTransform, arg5 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btMDebugDraw_drawBox__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (p SwigcptrBtMDebugDraw) DrawBox(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.DrawBox__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3)) + return + } + if argc == 4 { + p.DrawBox__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtTransform), a[3].(BtVector3)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMDebugDraw) DrawCapsule(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btMDebugDraw_drawCapsule_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawCylinder(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btMDebugDraw_drawCylinder_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawCone(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + _swig_i_2 := arg3 + _swig_i_3 := arg4 + _swig_i_4 := getSwigcptr(arg5) + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btMDebugDraw_drawCone_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.float(_swig_i_1), C.float(_swig_i_2), C.swig_intgo(_swig_i_3), C.uintptr_t(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtMDebugDraw) DrawPlane(arg2 BtVector3, arg3 float32, arg4 BtTransform, arg5 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + _swig_i_3 := getSwigcptr(arg4) + _swig_i_4 := getSwigcptr(arg5) + C._wrap_btMDebugDraw_drawPlane_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.float(_swig_i_2), C.uintptr_t(_swig_i_3), C.uintptr_t(_swig_i_4)) +} + +func (arg1 SwigcptrBtMDebugDraw) ClearLines() { + _swig_i_0 := arg1 + C._wrap_btMDebugDraw_clearLines_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtMDebugDraw) FlushLines() { + _swig_i_0 := arg1 + C._wrap_btMDebugDraw_flushLines_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)) +} + +func (arg1 SwigcptrBtMDebugDraw) GetDefaultColors() (_swig_ret BtIDebugDraw_DefaultColors) { + var swig_r BtIDebugDraw_DefaultColors + _swig_i_0 := arg1 + swig_r = (BtIDebugDraw_DefaultColors)(SwigcptrBtIDebugDraw_DefaultColors(C._wrap_btMDebugDraw_getDefaultColors_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMDebugDraw) SetMDefaultColors(arg2 BtMDefaultColors) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMDebugDraw_setMDefaultColors_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMDebugDraw) SetLiner(arg2 BtMDebugDrawLiner) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + C._wrap_btMDebugDraw_setLiner_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1)) +} + +func (arg1 SwigcptrBtMDebugDraw) GetLiner() (_swig_ret BtMDebugDrawLiner) { + var swig_r BtMDebugDrawLiner + _swig_i_0 := arg1 + swig_r = (BtMDebugDrawLiner)(SwigcptrBtMDebugDrawLiner(C._wrap_btMDebugDraw_getLiner_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0)))) + return swig_r +} + +func (arg1 SwigcptrBtMDebugDraw) SetDebugMode(arg2 int) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btMDebugDraw_setDebugMode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.swig_intgo(_swig_i_1)) +} + +func (arg1 SwigcptrBtMDebugDraw) GetDebugMode() (_swig_ret int) { + var swig_r int + _swig_i_0 := arg1 + swig_r = (int)(C._wrap_btMDebugDraw_getDebugMode_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0))) + return swig_r +} + +func (arg1 SwigcptrBtMDebugDraw) DrawLine__SWIG_1(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := getSwigcptr(arg4) + C._wrap_btMDebugDraw_drawLine__SWIG_1_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.uintptr_t(_swig_i_3)) +} + +func (p SwigcptrBtMDebugDraw) DrawLine(a ...interface{}) { + argc := len(a) + if argc == 3 { + p.DrawLine__SWIG_1(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3)) + return + } + if argc == 4 { + p.DrawLine__SWIG_0(a[0].(BtVector3), a[1].(BtVector3), a[2].(BtVector3), a[3].(BtVector3)) + return + } + panic("No match for overloaded function call") +} + +func (arg1 SwigcptrBtMDebugDraw) DrawContactPoint(arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 int, arg6 BtVector3) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := getSwigcptr(arg3) + _swig_i_3 := arg4 + _swig_i_4 := arg5 + _swig_i_5 := getSwigcptr(arg6) + C._wrap_btMDebugDraw_drawContactPoint_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), C.uintptr_t(_swig_i_2), C.float(_swig_i_3), C.swig_intgo(_swig_i_4), C.uintptr_t(_swig_i_5)) +} + +func (arg1 SwigcptrBtMDebugDraw) ReportErrorWarning(arg2 string) { + _swig_i_0 := arg1 + _swig_i_1 := arg2 + C._wrap_btMDebugDraw_reportErrorWarning_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), *(*C.swig_type_174)(unsafe.Pointer(&_swig_i_1))) + if Swig_escape_always_false { + Swig_escape_val = arg2 + } +} + +func (arg1 SwigcptrBtMDebugDraw) Draw3dText(arg2 BtVector3, arg3 string) { + _swig_i_0 := arg1 + _swig_i_1 := getSwigcptr(arg2) + _swig_i_2 := arg3 + C._wrap_btMDebugDraw_draw3dText_mbt_e879218550ba2e2b(C.uintptr_t(_swig_i_0), C.uintptr_t(_swig_i_1), *(*C.swig_type_175)(unsafe.Pointer(&_swig_i_2))) + if Swig_escape_always_false { + Swig_escape_val = arg3 + } +} + +func (_swig_base SwigcptrBtMDebugDraw) SetDefaultColors(arg1 BtIDebugDraw_DefaultColors) { + _swig_i_0 := getSwigcptr(arg1) + C._wrap_btMDebugDraw_setDefaultColors_mbt_e879218550ba2e2b(C.uintptr_t(_swig_base), C.uintptr_t(_swig_i_0)) +} + +func (p SwigcptrBtMDebugDraw) SwigIsBtIDebugDraw() { +} + +func (p SwigcptrBtMDebugDraw) SwigGetBtIDebugDraw() BtIDebugDraw { + return SwigcptrBtIDebugDraw(getSwigcptr(p)) +} + +type BtMDebugDraw interface { + Swigcptr() uintptr + SwigIsBtMDebugDraw() + DrawSphere(a ...interface{}) + DrawTriangle(a ...interface{}) + DrawAabb(arg2 BtVector3, arg3 BtVector3, arg4 BtVector3) + DrawTransform(arg2 BtTransform, arg3 float32) + DrawArc(a ...interface{}) + DrawSpherePatch(a ...interface{}) + DrawBox(a ...interface{}) + DrawCapsule(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) + DrawCylinder(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) + DrawCone(arg2 float32, arg3 float32, arg4 int, arg5 BtTransform, arg6 BtVector3) + DrawPlane(arg2 BtVector3, arg3 float32, arg4 BtTransform, arg5 BtVector3) + ClearLines() + FlushLines() + GetDefaultColors() (_swig_ret BtIDebugDraw_DefaultColors) + SetMDefaultColors(arg2 BtMDefaultColors) + SetLiner(arg2 BtMDebugDrawLiner) + GetLiner() (_swig_ret BtMDebugDrawLiner) + SetDebugMode(arg2 int) + GetDebugMode() (_swig_ret int) + DrawLine(a ...interface{}) + DrawContactPoint(arg2 BtVector3, arg3 BtVector3, arg4 float32, arg5 int, arg6 BtVector3) + ReportErrorWarning(arg2 string) + Draw3dText(arg2 BtVector3, arg3 string) + SetDefaultColors(arg1 BtIDebugDraw_DefaultColors) + SwigIsBtIDebugDraw() + SwigGetBtIDebugDraw() BtIDebugDraw +} + +type SwigcptrBtRigidBody_btRigidBodyConstructionInfo uintptr +type BtRigidBody_btRigidBodyConstructionInfo interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtRigidBody_btRigidBodyConstructionInfo) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrGjkepa2_impl_EPA_eStatus__ uintptr +type Gjkepa2_impl_EPA_eStatus__ interface { + Swigcptr() uintptr +} + +func (p SwigcptrGjkepa2_impl_EPA_eStatus__) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrGjkepa2_impl_GJK_sSimplex uintptr +type Gjkepa2_impl_GJK_sSimplex interface { + Swigcptr() uintptr +} + +func (p SwigcptrGjkepa2_impl_GJK_sSimplex) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btTypedConstraintData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btTypedConstraintData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btTypedConstraintData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrDContactGeom uintptr +type DContactGeom interface { + Swigcptr() uintptr +} + +func (p SwigcptrDContactGeom) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtDbvt_IWriter uintptr +type BtDbvt_IWriter interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtDbvt_IWriter) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtTriangleShape uintptr +type BtTriangleShape interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtTriangleShape) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtCollisionWorld_ConvexResultCallback uintptr +type BtCollisionWorld_ConvexResultCallback interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtCollisionWorld_ConvexResultCallback) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btCollisionObject_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrGjkepa2_impl_EPA_sList uintptr +type Gjkepa2_impl_EPA_sList interface { + Swigcptr() uintptr +} + +func (p SwigcptrGjkepa2_impl_EPA_sList) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_unsigned_SS_int_Sg__Sg_ uintptr +type BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_unsigned_SS_int_Sg__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_unsigned_SS_int_Sg__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtConvexCast_CastResult uintptr +type BtConvexCast_CastResult interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtConvexCast_CastResult) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btDbvt_sStkNN_Sg_ uintptr +type BtAlignedObjectArray_Sl_btDbvt_sStkNN_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btDbvt_sStkNN_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btRigidBodyDoubleData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btRigidBodyDoubleData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btRigidBodyDoubleData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtIDebugDraw_DefaultColors uintptr +type BtIDebugDraw_DefaultColors interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtIDebugDraw_DefaultColors) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtConvexHullInternal_Vertex uintptr +type BtConvexHullInternal_Vertex interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtConvexHullInternal_Vertex) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btCollisionObjectDoubleData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btCollisionObjectDoubleData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btCollisionObjectDoubleData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtDbvt_sStkNPS uintptr +type BtDbvt_sStkNPS interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtDbvt_sStkNPS) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrGjkepa2_impl_GJK_eStatus__ uintptr +type Gjkepa2_impl_GJK_eStatus__ interface { + Swigcptr() uintptr +} + +func (p SwigcptrGjkepa2_impl_GJK_eStatus__) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtTypedConstraint_btConstraintInfo1 uintptr +type BtTypedConstraint_btConstraintInfo1 interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtTypedConstraint_btConstraintInfo1) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btBroadphasePair_Sg_ uintptr +type BtAlignedObjectArray_Sl_btBroadphasePair_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btBroadphasePair_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtTypedConstraint_btConstraintInfo2 uintptr +type BtTypedConstraint_btConstraintInfo2 interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtTypedConstraint_btConstraintInfo2) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrVoid uintptr +type Void interface { + Swigcptr() uintptr +} + +func (p SwigcptrVoid) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btDynamicsWorldDoubleData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btDynamicsWorldDoubleData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btDynamicsWorldDoubleData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtDiscreteCollisionDetectorInterface_ClosestPointInput uintptr +type BtDiscreteCollisionDetectorInterface_ClosestPointInput interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtDiscreteCollisionDetectorInterface_ClosestPointInput) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtCollisionWorld_RayResultCallback uintptr +type BtCollisionWorld_RayResultCallback interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtCollisionWorld_RayResultCallback) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btSoftBodyDoubleData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btSoftBodyDoubleData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btSoftBodyDoubleData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtCollisionWorld_LocalConvexResult uintptr +type BtCollisionWorld_LocalConvexResult interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtCollisionWorld_LocalConvexResult) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btCell32_Sg__Sg_ uintptr +type BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btCell32_Sg__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btCell32_Sg__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_GrahamVector3_Sg_ uintptr +type BtAlignedObjectArray_Sl_GrahamVector3_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_GrahamVector3_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btConvexHullComputer_Edge_Sg_ uintptr +type BtAlignedObjectArray_Sl_btConvexHullComputer_Edge_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btConvexHullComputer_Edge_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btTypedConstraint_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btTypedConstraint_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btTypedConstraint_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btDbvtNode_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btDbvtNode_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btDbvtNode_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhFloatData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btQuantizedBvhFloatData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhFloatData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrGjkepa2_impl_GJK_sSV uintptr +type Gjkepa2_impl_GJK_sSV interface { + Swigcptr() uintptr +} + +func (p SwigcptrGjkepa2_impl_GJK_sSV) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btHeightfieldTerrainShape_Range_Sg_ uintptr +type BtAlignedObjectArray_Sl_btHeightfieldTerrainShape_Range_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btHeightfieldTerrainShape_Range_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btTypedConstraintDoubleData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btTypedConstraintDoubleData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btTypedConstraintDoubleData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btFace_Sg_ uintptr +type BtAlignedObjectArray_Sl_btFace_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btFace_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btVector3_Sg_ uintptr +type BtAlignedObjectArray_Sl_btVector3_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btVector3_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_ uintptr +type BtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btBvhSubtreeInfo_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtActionInterface uintptr +type BtActionInterface interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtActionInterface) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btConvexHullInternal_Vertex_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btConvexHullInternal_Vertex_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btConvexHullInternal_Vertex_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhDoubleData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btQuantizedBvhDoubleData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhDoubleData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btPersistentManifold_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrStd_size_t uintptr +type Std_size_t interface { + Swigcptr() uintptr +} + +func (p SwigcptrStd_size_t) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrGjkepa2_impl_EPA_sFace uintptr +type Gjkepa2_impl_EPA_sFace interface { + Swigcptr() uintptr +} + +func (p SwigcptrGjkepa2_impl_EPA_sFace) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtDbvt_IClone uintptr +type BtDbvt_IClone interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtDbvt_IClone) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtSimulationIslandManager_IslandCallback uintptr +type BtSimulationIslandManager_IslandCallback interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtSimulationIslandManager_IslandCallback) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btSoftBodyFloatData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btSoftBodyFloatData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btSoftBodyFloatData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg__Sg_ uintptr +type BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_btDbvtNode_SS_const_Sm__Sg__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtStackAlloc uintptr +type BtStackAlloc interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtStackAlloc) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btRigidBody_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtDbvt_ICollide uintptr +type BtDbvt_ICollide interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtDbvt_ICollide) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btCollisionShapeData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btCollisionShapeData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btCollisionShapeData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtHeightfieldTerrainShape_Range uintptr +type BtHeightfieldTerrainShape_Range interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtHeightfieldTerrainShape_Range) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtCollisionObjectWrapper uintptr +type BtCollisionObjectWrapper interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtCollisionObjectWrapper) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtHashMap_Sl_btHashPtr_Sc_void_Sm__Sg_ uintptr +type BtHashMap_Sl_btHashPtr_Sc_void_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtHashMap_Sl_btHashPtr_Sc_void_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_int_Sg_ uintptr +type BtAlignedObjectArray_Sl_int_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_int_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrGjkepa2_impl_EPA_sHorizon uintptr +type Gjkepa2_impl_EPA_sHorizon interface { + Swigcptr() uintptr +} + +func (p SwigcptrGjkepa2_impl_EPA_sHorizon) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_double_Sg__Sg_ uintptr +type BtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_double_Sg__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btAlignedObjectArray_Sl_double_Sg__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtGjkEpaSolver2_sResults uintptr +type BtGjkEpaSolver2_sResults interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtGjkEpaSolver2_sResults) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btDbvt_sStkNPS_Sg_ uintptr +type BtAlignedObjectArray_Sl_btDbvt_sStkNPS_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btDbvt_sStkNPS_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtDiscreteCollisionDetectorInterface_Result uintptr +type BtDiscreteCollisionDetectorInterface_Result interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtDiscreteCollisionDetectorInterface_Result) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btTypedConstraintFloatData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btTypedConstraintFloatData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btTypedConstraintFloatData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btDynamicsWorldFloatData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btDynamicsWorldFloatData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btDynamicsWorldFloatData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrStd_string uintptr +type Std_string interface { + Swigcptr() uintptr +} + +func (p SwigcptrStd_string) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtCollisionWorld_ContactResultCallback uintptr +type BtCollisionWorld_ContactResultCallback interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtCollisionWorld_ContactResultCallback) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btRigidBodyFloatData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btRigidBodyFloatData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btRigidBodyFloatData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btSolverConstraint_Sg_ uintptr +type BtAlignedObjectArray_Sl_btSolverConstraint_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btSolverConstraint_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btCollisionObjectFloatData_Sm__Sg_ uintptr +type BtAlignedObjectArray_Sl_btCollisionObjectFloatData_Sm__Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btCollisionObjectFloatData_Sm__Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btSimplePair_Sg_ uintptr +type BtAlignedObjectArray_Sl_btSimplePair_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btSimplePair_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +type SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_ uintptr +type BtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_ interface { + Swigcptr() uintptr +} + +func (p SwigcptrBtAlignedObjectArray_Sl_btQuantizedBvhNode_Sg_) Swigcptr() uintptr { + return uintptr(p) +} + +var swigDirectorTrack struct { + sync.Mutex + m map[int]interface{} + c int +} + +func swigDirectorAdd(v interface{}) int { + swigDirectorTrack.Lock() + defer swigDirectorTrack.Unlock() + if swigDirectorTrack.m == nil { + swigDirectorTrack.m = make(map[int]interface{}) + } + swigDirectorTrack.c++ + ret := swigDirectorTrack.c + swigDirectorTrack.m[ret] = v + return ret +} + +func swigDirectorLookup(c int) interface{} { + swigDirectorTrack.Lock() + defer swigDirectorTrack.Unlock() + ret := swigDirectorTrack.m[c] + if ret == nil { + panic("C++ director pointer not found (possible use-after-free)") + } + return ret +} + +func swigDirectorDelete(c int) { + swigDirectorTrack.Lock() + defer swigDirectorTrack.Unlock() + if swigDirectorTrack.m[c] == nil { + if c > swigDirectorTrack.c { + panic("C++ director pointer invalid (possible memory corruption") + } else { + panic("C++ director pointer not found (possible use-after-free)") + } + } + delete(swigDirectorTrack.m, c) +} diff --git a/pkg/mphysics/mbt/mbt.h b/pkg/mphysics/mbt/mbt.h new file mode 100644 index 00000000..9504b127 --- /dev/null +++ b/pkg/mphysics/mbt/mbt.h @@ -0,0 +1,27 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.2.0 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +// source: C:\MMD\mlib_go\pkg\mbt\bullet.i + +#ifndef SWIG_mbt_WRAP_H_ +#define SWIG_mbt_WRAP_H_ + +class Swig_memory; + +class SwigDirector_btMDebugDrawLiner : public btMDebugDrawLiner +{ + public: + SwigDirector_btMDebugDrawLiner(int swig_p); + virtual ~SwigDirector_btMDebugDrawLiner(); + virtual void drawLine(btVector3 const &from,btVector3 const &to,btVector3 const &color); + private: + intgo go_val; + Swig_memory *swig_mem; +}; + +#endif diff --git a/pkg/mphysics/mbt/swig_mbt.bat b/pkg/mphysics/mbt/swig_mbt.bat new file mode 100644 index 00000000..77b45cd3 --- /dev/null +++ b/pkg/mphysics/mbt/swig_mbt.bat @@ -0,0 +1,7 @@ +swig -c++ -go -cgo -I"C:\MMD\mlib_go\pkg\mbt\bullet\src" ^ + -I"C:\development\TDM-GCC-64\lib\gcc\x86_64-w64-mingw32\10.3.0\include\c++\x86_64-w64-mingw32" ^ + -I"C:\development\TDM-GCC-64\x86_64-w64-mingw32\include" ^ + -I"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include" ^ + -cpperraswarn -o "C:\MMD\mlib_go\pkg\mbt\mbt.cxx" "C:\MMD\mlib_go\pkg\mbt\bullet.i" + +go clean --cache diff --git a/pkg/mphysics/physics.go b/pkg/mphysics/physics.go new file mode 100644 index 00000000..34bb23bb --- /dev/null +++ b/pkg/mphysics/physics.go @@ -0,0 +1,232 @@ +//go:build windows +// +build windows + +package mphysics + +import ( + "github.com/miu200521358/mlib_go/pkg/mphysics/mbt" + "github.com/miu200521358/mlib_go/pkg/mview" +) + +type MPhysics struct { + world mbt.BtDiscreteDynamicsWorld + drawer mbt.BtMDebugDraw + liner *MDebugDrawLiner + MaxSubSteps int + DeformFps float32 + DeformSpf float32 + PhysicsFps float32 + PhysicsSpf float32 + FixedTimeStep float32 + joints map[jointKey]mbt.BtTypedConstraint + rigidBodies map[rigidbodyKey]rigidbodyValue + visibleRigidBody bool + visibleJoint bool +} + +type rigidbodyKey struct { + ModelIndex int + RigidBodyIndex int +} + +type rigidbodyValue struct { + RigidBody mbt.BtRigidBody + Transform mbt.BtTransform + Mask int + Group int +} + +type jointKey struct { + ModelIndex int + JointIndex int +} + +func NewMPhysics(shader *mview.MShader) *MPhysics { + world := createWorld() + + p := &MPhysics{ + world: world, + MaxSubSteps: 2, + DeformFps: 30.0, + PhysicsFps: 60.0, + rigidBodies: make(map[rigidbodyKey]rigidbodyValue), + joints: make(map[jointKey]mbt.BtTypedConstraint), + } + + // デバッグビューワー + liner := NewMDebugDrawLiner(shader) + drawer := mbt.NewBtMDebugDraw() + drawer.SetLiner(liner) + drawer.SetMDefaultColors(NewConstBtMDefaultColors()) + world.SetDebugDrawer(drawer) + // mlog.D("world.GetDebugDrawer()=%+v\n", world.GetDebugDrawer()) + + p.drawer = drawer + p.liner = liner + p.DeformSpf = 1.0 / p.DeformFps + p.PhysicsSpf = 1.0 / p.PhysicsFps + p.FixedTimeStep = 1 / 60.0 + + p.VisibleRigidBody(false) + p.VisibleJoint(false) + + return p +} + +func createWorld() mbt.BtDiscreteDynamicsWorld { + broadphase := mbt.NewBtDbvtBroadphase() + collisionConfiguration := mbt.NewBtDefaultCollisionConfiguration() + dispatcher := mbt.NewBtCollisionDispatcher(collisionConfiguration) + solver := mbt.NewBtSequentialImpulseConstraintSolver() + // solver.GetM_analyticsData().SetM_numIterationsUsed(200) + world := mbt.NewBtDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration) + world.SetGravity(mbt.NewBtVector3(float32(0), float32(-9.8*10), float32(0))) + // world.GetSolverInfo().(mbt.BtContactSolverInfo).SetM_numIterations(100) + // world.GetSolverInfo().(mbt.BtContactSolverInfo).SetM_splitImpulse(1) + + groundShape := mbt.NewBtStaticPlaneShape(mbt.NewBtVector3(float32(0), float32(1), float32(0)), float32(0)) + groundTransform := mbt.NewBtTransform() + groundTransform.SetIdentity() + groundTransform.SetOrigin(mbt.NewBtVector3(float32(0), float32(0), float32(0))) + groundMotionState := mbt.NewBtDefaultMotionState(groundTransform) + groundRigidBody := mbt.NewBtRigidBody(float32(0), groundMotionState, groundShape) + + world.AddRigidBody(groundRigidBody, 1<<15, 0xFFFF) + + return world +} + +func (p *MPhysics) ResetWorld() { + world := createWorld() + world.SetDebugDrawer(p.drawer) + p.world = world + for _, r := range p.rigidBodies { + rigidBody := r.RigidBody + group := r.Group + mask := r.Mask + p.world.AddRigidBody(rigidBody, group, mask) + } + for _, joint := range p.joints { + p.world.AddConstraint(joint, true) + } +} + +func (p *MPhysics) VisibleRigidBody(enable bool) { + if enable { + p.world.GetDebugDrawer().SetDebugMode( + p.world.GetDebugDrawer().GetDebugMode() | int( + mbt.BtIDebugDrawDBG_DrawWireframe| + mbt.BtIDebugDrawDBG_DrawContactPoints, + )) + } else { + p.world.GetDebugDrawer().SetDebugMode( + p.world.GetDebugDrawer().GetDebugMode() & ^int( + mbt.BtIDebugDrawDBG_DrawWireframe| + mbt.BtIDebugDrawDBG_DrawContactPoints, + )) + } + p.visibleRigidBody = enable +} + +func (p *MPhysics) VisibleJoint(enable bool) { + if enable { + p.world.GetDebugDrawer().SetDebugMode( + p.world.GetDebugDrawer().GetDebugMode() | int( + mbt.BtIDebugDrawDBG_DrawConstraints| + mbt.BtIDebugDrawDBG_DrawConstraintLimits, + )) + } else { + p.world.GetDebugDrawer().SetDebugMode( + p.world.GetDebugDrawer().GetDebugMode() & ^int( + mbt.BtIDebugDrawDBG_DrawConstraints| + mbt.BtIDebugDrawDBG_DrawConstraintLimits, + )) + } + p.visibleJoint = enable +} + +func (p *MPhysics) DrawDebugLines() { + if p.visibleRigidBody || p.visibleJoint { + p.liner.DrawDebugLines() + p.liner.vertices = []float32{} + } +} + +func (p *MPhysics) DebugDrawWorld() { + // mlog.D("DrawWorld p.world=%+v\n", p.world) + + // // 標準出力を一時的にリダイレクトする + // old := os.Stdout // keep backup of the real stdout + // r, w, _ := os.Pipe() + // os.Stdout = w + + p.world.DebugDrawWorld() + + // // 標準出力を元に戻す + // w.Close() + // os.Stdout = old // restoring the real stdout + + // var buf bytes.Buffer + // buf.ReadFrom(r) + // fmt.Print(buf.String()) +} + +func (p *MPhysics) GetRigidBody(modelIndex, rigidBodyIndex int) (mbt.BtRigidBody, mbt.BtTransform) { + r := p.rigidBodies[rigidbodyKey{ModelIndex: modelIndex, RigidBodyIndex: rigidBodyIndex}] + return r.RigidBody, r.Transform +} + +func (p *MPhysics) AddRigidBody(rigidBody mbt.BtRigidBody, rigidBodyTransform mbt.BtTransform, + modelIndex, rigidBodyIndex, group, mask int) { + p.world.AddRigidBody(rigidBody, group, mask) + rigidBodyKey := rigidbodyKey{ModelIndex: modelIndex, RigidBodyIndex: rigidBodyIndex} + p.rigidBodies[rigidBodyKey] = rigidbodyValue{ + RigidBody: rigidBody, Transform: rigidBodyTransform, Mask: mask, Group: group} +} + +func (p *MPhysics) DeleteRigidBodies(modelIndex int) { + for k, r := range p.rigidBodies { + rigidBody := r.RigidBody + if k.ModelIndex == modelIndex { + p.world.RemoveRigidBody(rigidBody) + delete(p.rigidBodies, k) + } + } +} + +func (p *MPhysics) AddJoint(modelIndex, jointIndex int, joint mbt.BtTypedConstraint) { + p.world.AddConstraint(joint, true) + key := jointKey{ModelIndex: modelIndex, JointIndex: jointIndex} + p.joints[key] = joint +} + +func (p *MPhysics) DeleteJoints(modelIndex int) { + for k, joint := range p.joints { + if k.ModelIndex == modelIndex { + p.world.RemoveConstraint(joint) + delete(p.joints, k) + } + } +} + +func (p *MPhysics) Update(timeStep float32) { + // // 標準出力を一時的にリダイレクトする + // old := os.Stdout // keep backup of the real stdout + // r, w, _ := os.Pipe() + // os.Stdout = w + // for range int(timeStep / p.Spf) { + // mlog.I("timeStep=%.8f, spf: %.8f", timeStep, p.Spf) + p.world.StepSimulation(timeStep, p.MaxSubSteps, p.FixedTimeStep) + // } + + // // p.frame += float32(elapsed) + // mlog.D("timeStep: %.8f [p.world.StepSimulation]\n", timeStep) + + // // 標準出力を元に戻す + // w.Close() + // os.Stdout = old // restoring the real stdout + + // var buf bytes.Buffer + // buf.ReadFrom(r) + // fmt.Print(buf.String()) +} diff --git a/pkg/mutils/mconfig/config_app.go b/pkg/mutils/mconfig/config_app.go new file mode 100644 index 00000000..46599195 --- /dev/null +++ b/pkg/mutils/mconfig/config_app.go @@ -0,0 +1,46 @@ +package mconfig + +import ( + "embed" + "encoding/json" + "image" + "io/fs" + + "github.com/miu200521358/mlib_go/pkg/mutils" +) + +type AppConfig struct { + Name string `json:"Name"` + Version string `json:"Version"` + Env string `json:"Env"` +} + +func (ac *AppConfig) IsEnvProd() bool { + if ac == nil { + return false + } + return ac.Env == "prod" +} + +func (ac *AppConfig) IsEnvDev() bool { + if ac == nil { + return false + } + return ac.Env == "dev" +} + +// LoadAppConfig アプリ設定ファイルの読み込み +func LoadAppConfig(appFiles embed.FS) *AppConfig { + fileData, err := fs.ReadFile(appFiles, "app/app_config.json") + if err != nil { + return &AppConfig{} + } + var appConfigData AppConfig + json.Unmarshal(fileData, &appConfigData) + return &appConfigData +} + +// LoadIconFile アイコンファイルの読み込み +func LoadIconFile(resources embed.FS) (*image.Image, error) { + return mutils.LoadImageFromResources(resources, "app/app.png") +} diff --git a/pkg/mutils/mconfig/config_user.go b/pkg/mutils/mconfig/config_user.go new file mode 100644 index 00000000..44e0e436 --- /dev/null +++ b/pkg/mutils/mconfig/config_user.go @@ -0,0 +1,121 @@ +package mconfig + +import ( + "encoding/json" + "os" + "path/filepath" + + "github.com/miu200521358/mlib_go/pkg/mutils" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" +) + +const USER_CONFIG_FILE_NAME = "user_config.json" +const USER_CONFIG_OLD_FILE_NAME = "history.json" + +const ( + FRAME_DROP = "FrameDrop" + HIGH_SPEC_MODE = "HighSpecMode" + PHYSICS = "Physics" +) + +// 設定の保存 +func SaveUserConfig(key string, value string, limit int) error { + if value == "" { + return nil + } + + // UserConfigファイルをロードする + existingValues, config := LoadUserConfigAll(key) + values := []string{value} + + // Determine the upper limit based on the smaller value between len(existingValues) and limit + upperLimit := len(existingValues) + 1 + if limit < upperLimit { + upperLimit = limit + } + + // Remove the value if it already exists in existingValues + for i := 0; i < (upperLimit - 1); i++ { + if existingValues[i] != value { + values = append(values, existingValues[i:i+1]...) + } + } + + // 同じ値があって、結果件数が変わらない場合、再設定 + if len(values) < upperLimit { + upperLimit = len(values) + } + + // Add key-value elements to the config map + config[key] = values[:upperLimit] + + // Create a JSON representation of the config map without newlines and indentation + updatedData, err := json.Marshal(config) + if err != nil { + updatedData = []byte("{}") + } + + // ファイルのフルパスを取得 + configFilePath := filepath.Join(mutils.GetAppRootDir(), USER_CONFIG_FILE_NAME) + + // Overwrite the config.json file with the updated JSON data + err = os.WriteFile(configFilePath, updatedData, 0644) + if err != nil { + return err + } + + return nil +} + +func LoadUserConfig(key string) []string { + existingValues, _ := LoadUserConfigAll(key) + return existingValues +} + +// 設定の読み込み +func LoadUserConfigAll(key string) ([]string, map[string]interface{}) { + // Configファイルのフルパスを取得 + configFilePath := filepath.Join(mutils.GetAppRootDir(), USER_CONFIG_FILE_NAME) + mlog.D("LoadConfig: %s: %s", key, configFilePath) + + // Read the config.json file + data, err := os.ReadFile(configFilePath) + if err != nil { + // user_config.jsonがない場合、history.jsonを読み込む(次回以降はuser_config.jsonに保存される) + configFilePath = filepath.Join(mutils.GetAppRootDir(), USER_CONFIG_OLD_FILE_NAME) + data, err = os.ReadFile(configFilePath) + if err != nil { + data = []byte("{}") + } + } + + // Unmarshal the JSON data into a map + config := make(map[string]interface{}) + err = json.Unmarshal(data, &config) + if err != nil { + return []string{}, config + } + + // Check if the value is nil and initialize it as an empty slice of strings + if config[key] == nil { + return []string{}, config + } + + // Convert the interface{} type to []interface{} + values, ok := config[key].([]interface{}) + if !ok { + return []string{}, config + } + + // Convert each element to string + result := make([]string, len(values)) + for i, v := range values { + if str, ok := v.(string); ok { + result[i] = str + } else { + return []string{}, config + } + } + + return result, config +} diff --git a/pkg/mutils/mi18n/i18n/common.en.json b/pkg/mutils/mi18n/i18n/common.en.json new file mode 100644 index 00000000..31dbc4f4 --- /dev/null +++ b/pkg/mutils/mi18n/i18n/common.en.json @@ -0,0 +1,370 @@ +[ + { + "id": "&ビューワー", + "translation": "&Viewer" + }, + { + "id": "&フレームドロップON", + "translation": "&Frame Drop ON" + }, + { + "id": "&物理ON/OFF", + "translation": "&Physics ON/OFF" + }, + { + "id": "&物理リセット", + "translation": "&Physics Reset" + }, + { + "id": "&法線表示", + "translation": "&Normal Display" + }, + { + "id": "&ボーン表示", + "translation": "&Bone Display" + }, + { + "id": "&全ボーン", + "translation": "&All Bones" + }, + { + "id": "&IKボーン", + "translation": "&IK Bones" + }, + { + "id": "&付与親ボーン", + "translation": "&Assigned Parent Bones" + }, + { + "id": "&軸制限ボーン", + "translation": "&Axis Restricted Bones" + }, + { + "id": "&回転ボーン", + "translation": "&Rotation Bones" + }, + { + "id": "&移動ボーン", + "translation": "&Move Bones" + }, + { + "id": "&表示ボーン", + "translation": "&Display Bones" + }, + { + "id": "&剛体表示", + "translation": "&Rigid Body Display" + }, + { + "id": "&ジョイント表示", + "translation": "&Joint Display" + }, + { + "id": "背景色生成エラー", + "translation": "Background Color Generation Error" + }, + { + "id": "&言語", + "translation": "&Language" + }, + { + "id": "LanguageChanged.Title", + "translation": "Language Change" + }, + { + "id": "LanguageChanged.Message", + "translation": "The language change will take effect after restarting\nThe app will now close" + }, + { + "id": "未設定", + "translation": "Not Set" + }, + { + "id": "開く", + "translation": "Open" + }, + { + "id": "履歴", + "translation": "History" + }, + { + "id": "ファイルが存在しません", + "translation": "File Does Not Exist" + }, + { + "id": "読み込み失敗", + "translation": "Load Failed" + }, + { + "id": "履歴ダイアログ生成エラー", + "translation": "History Dialog Generation Error" + }, + { + "id": "履歴ダイアログタイトル", + "translation": "History of {{.Title}}" + }, + { + "id": "履歴リスト生成エラー", + "translation": "History List Generation Error" + }, + { + "id": "ボタンBox生成エラー", + "translation": "Button Box Generation Error" + }, + { + "id": "OKボタン生成エラー", + "translation": "OK Button Generation Error" + }, + { + "id": "Cancelボタン生成エラー", + "translation": "Cancel Button Generation Error" + }, + { + "id": "ファイル選択ダイアログタイトル", + "translation": "Please Select {{.Title}}" + }, + { + "id": "ファイル選択ダイアログ選択エラー", + "translation": "File Selection Dialog Error" + }, + { + "id": "タブウィジェット生成エラー", + "translation": "Tab Widget Generation Error" + }, + { + "id": "タブページ生成エラー", + "translation": "Tab Page Generation Error" + }, + { + "id": "再生", + "translation": "Play" + }, + { + "id": "一時停止", + "translation": "Pause" + }, + { + "id": "メインウィンドウ生成エラー", + "translation": "Main Window Generation Error" + }, + { + "id": "ビューワーウィンドウ生成エラー", + "translation": "Viewer Window Generation Error" + }, + { + "id": "コンソール生成エラー", + "translation": "Console Generation Error" + }, + { + "id": "ファイル", + "translation": "File" + }, + { + "id": "Pmxファイル", + "translation": "PMX File" + }, + { + "id": "Pmxファイルピッカー生成エラー", + "translation": "PMX File Picker Generation Error" + }, + { + "id": "Vmdファイル", + "translation": "VMD File" + }, + { + "id": "Vmdファイルピッカー生成エラー", + "translation": "VMD File Picker Generation Error" + }, + { + "id": "セパレータ生成エラー", + "translation": "Separator Generation Error" + }, + { + "id": "モーションプレイヤー生成エラー", + "translation": "Motion Player Generation Error" + }, + { + "id": "Pmxファイル読み込みエラー", + "translation": "PMX File Loading Error" + }, + { + "id": "Vmdファイル読み込みエラー", + "translation": "VMD File Loading Error" + }, + { + "id": "ビューワー", + "translation": "Viewer" + }, + { + "id": "&メイン画面", + "translation": "&Message" + }, + { + "id": "&デバッグログ表示", + "translation": "&Display Debug Messages" + }, + { + "id": "&冗長ログ表示", + "translation": "&Display Verbose Messages" + }, + { + "id": "予期せぬエラーが発生しました", + "translation": "An unexpected error has occurred" + }, + { + "id": "有効なPmxファイルが入力されていません", + "translation": "A valid Pmx file has not been entered" + }, + { + "id": "&使い方", + "translation": "&How to use" + }, + { + "id": "ビューワーの使い方", + "translation": "How to use the viewer" + }, + { + "id": "ビューワーの使い方メッセージ", + "translation": "・Use the mouse wheel to zoom in and out.\n・Hold down the mouse wheel and move to change the camera position.\n・Hold down the right mouse button and move to change the camera angle.\n・Hold Shift while using the mouse to increase movement sensitivity.\n・Hold Ctrl while using the mouse to decrease movement sensitivity.\n・Press '0' on the keypad to set the camera view to the bottom.\n・Press '2' on the keypad to set the camera view to the front.\n・Press '4' on the keypad to set the camera view to the left.\n・Press '5' on the keypad to set the camera view to the top.\n・Press '6' on the keypad to set the camera view to the right.\n・Press '8' on the keypad to set the camera view to the back.\n・Use the right or up arrow keys on the keyboard to move forward a frame.\n・Use the left or down arrow keys on the keyboard to move back a frame." + }, + { + "id": "&再生フォームの使い方", + "translation": "&How to use the playback form" + }, + { + "id": "再生フォームの使い方", + "translation": "How to use the playback form" + }, + { + "id": "再生ウィジェットの使い方メッセージ", + "translation": "・The 'Play' button becomes clickable when a PMX model is set\n・Setting a VMD motion is optional\n・Clicking the 'Play' button starts the rendering. The button label changes to 'Pause'\n・Clicking the 'Pause' button pauses the rendering. The button label changes to 'Play'\n・While paused, you can change the keyframe position with the keyframe number field or slider\n・The keyframe number field and slider can adjust the number up and down with the middle mouse wheel" + }, + { + "id": "メイン画面の使い方", + "translation": "How to use the main screen" + }, + { + "id": "メイン画面の使い方メッセージ", + "translation": "・Clicking above the name of each form part outputs how to use that part in the message field" + }, + { + "id": "予期せぬエラーヘッダー", + "translation": "The app will close due to an unexpected error.\nPlease contact the community if this happens again." + }, + { + "id": "コミュニティ報告", + "translation": "Copy the error and report it in the community" + }, + { + "id": "アプリを終了", + "translation": "Close the app" + }, + { + "id": "エラーダイアログ起動失敗", + "translation": "Failed to launch error dialog" + }, + { + "id": "クリップボードコピー失敗", + "translation": "Failed to copy to clipboard" + }, + { + "id": "&ハイスペックモード", + "translation": "&High Spec Mode" + }, + { + "id": "モデル名エンコードエラー", + "translation": "Since the model name ({{.Name}}) contains characters that are unreadable in Japanese or English (environment-dependent characters, foreign language characters, etc.), a temporary model name will be set." + }, + { + "id": "ボーン名エンコードエラー", + "translation": "Since the bone name ({{.Name}}) contains characters that are unreadable in Japanese or English (environment-dependent characters, foreign language characters, etc.), it will be skipped." + }, + { + "id": "ファイルクローズエラー", + "translation": "Failed to output the file to the file path ({{.Path}})." + }, + { + "id": "ボーンフレーム書き込みエラー", + "translation": "Failed to write the bone data." + }, + { + "id": "モーフフレーム書き込みエラー", + "translation": "Failed to write the morph data." + }, + { + "id": "&IK冗長ログ表示", + "translation": "&IK verbose log display" + }, + { + "id": "固定ビュー表示", + "translation": "Fixed view display" + }, + { + "id": "固定ビュー非表示", + "translation": "Hide fixed view" + }, + { + "id": "固定ビューウィジェット生成エラー", + "translation": "Fixed view widget generation error" + }, + { + "id": "正面", + "translation": "Front" + }, + { + "id": "左面", + "translation": "Left" + }, + { + "id": "右面", + "translation": "Right" + }, + { + "id": "背面", + "translation": "Back" + }, + { + "id": "&ワイヤーフレーム表示", + "translation": "&Wireframe Display" + }, + { + "id": "&前面表示", + "translation": "&Front Display" + }, + { + "id": "&埋め込み表示", + "translation": "&Embedded Display" + }, + { + "id": "&情報表示", + "translation": "&Display Information" + }, + { + "id": "&fps制限", + "translation": "&FPS Limit" + }, + { + "id": "&30fps制限", + "translation": "&30 FPS Limit" + }, + { + "id": "&60fps制限", + "translation": "&60 FPS Limit" + }, + { + "id": "&fps無制限", + "translation": "&Unlimited FPS" + }, + { + "id": "&選択頂点表示", + "translation": "&Selected Vertex Display" + }, + { + "id": "ミップマップ生成エラー", + "translation": "Mipmaps will not be generated because the texture size is not a power of two. Texture name: {{.Name}}" + }, + { + "id": "アイコン生成エラー", + "translation": "Icon generation error" + } +] \ No newline at end of file diff --git a/pkg/mutils/mi18n/i18n/common.ja.json b/pkg/mutils/mi18n/i18n/common.ja.json new file mode 100644 index 00000000..7ce7082c --- /dev/null +++ b/pkg/mutils/mi18n/i18n/common.ja.json @@ -0,0 +1,370 @@ +[ + { + "id": "&ビューワー", + "translation": "&ビューワー" + }, + { + "id": "&フレームドロップON", + "translation": "&フレームドロップON" + }, + { + "id": "&物理ON/OFF", + "translation": "&物理ON/OFF" + }, + { + "id": "&物理リセット", + "translation": "&物理リセット" + }, + { + "id": "&法線表示", + "translation": "&法線表示" + }, + { + "id": "&ボーン表示", + "translation": "&ボーン表示" + }, + { + "id": "&全ボーン", + "translation": "&全ボーン" + }, + { + "id": "&IKボーン", + "translation": "&IKボーン" + }, + { + "id": "&付与親ボーン", + "translation": "&付与親ボーン" + }, + { + "id": "&軸制限ボーン", + "translation": "&軸制限ボーン" + }, + { + "id": "&回転ボーン", + "translation": "&回転ボーン" + }, + { + "id": "&移動ボーン", + "translation": "&移動ボーン" + }, + { + "id": "&表示ボーン", + "translation": "&表示ボーン" + }, + { + "id": "&剛体表示", + "translation": "&剛体表示" + }, + { + "id": "&ジョイント表示", + "translation": "&ジョイント表示" + }, + { + "id": "背景色生成エラー", + "translation": "背景色生成エラー" + }, + { + "id": "&言語", + "translation": "&言語" + }, + { + "id": "LanguageChanged.Title", + "translation": "言語変更" + }, + { + "id": "LanguageChanged.Message", + "translation": "画面上の言語の変更は再起動後に有効になります\nアプリを終了します" + }, + { + "id": "未設定", + "translation": "未設定" + }, + { + "id": "開く", + "translation": "開く" + }, + { + "id": "履歴", + "translation": "履歴" + }, + { + "id": "ファイルが存在しません", + "translation": "ファイルが存在しません" + }, + { + "id": "読み込み失敗", + "translation": "読み込み失敗" + }, + { + "id": "履歴ダイアログ生成エラー", + "translation": "履歴ダイアログ生成エラー" + }, + { + "id": "履歴ダイアログタイトル", + "translation": "{{.Title}}の履歴" + }, + { + "id": "履歴リスト生成エラー", + "translation": "履歴リスト生成エラー" + }, + { + "id": "ボタンBox生成エラー", + "translation": "ボタンBox生成エラー" + }, + { + "id": "OKボタン生成エラー", + "translation": "OKボタン生成エラー" + }, + { + "id": "Cancelボタン生成エラー", + "translation": "Cancelボタン生成エラー" + }, + { + "id": "ファイル選択ダイアログタイトル", + "translation": "{{.Title}}を選択してください" + }, + { + "id": "ファイル選択ダイアログ選択エラー", + "translation": "ファイル選択ダイアログ選択エラー" + }, + { + "id": "タブウィジェット生成エラー", + "translation": "タブウィジェット生成エラー" + }, + { + "id": "タブページ生成エラー", + "translation": "タブページ生成エラー" + }, + { + "id": "再生", + "translation": "再生" + }, + { + "id": "一時停止", + "translation": "一時停止" + }, + { + "id": "メインウィンドウ生成エラー", + "translation": "メインウィンドウ生成エラー" + }, + { + "id": "ビューワーウィンドウ生成エラー", + "translation": "ビューワーウィンドウ生成エラー" + }, + { + "id": "コンソール生成エラー", + "translation": "コンソール生成エラー" + }, + { + "id": "ファイル", + "translation": "ファイル" + }, + { + "id": "Pmxファイル", + "translation": "Pmxファイル" + }, + { + "id": "Pmxファイルピッカー生成エラー", + "translation": "Pmxファイルピッカー生成エラー" + }, + { + "id": "Vmdファイル", + "translation": "Vmdファイル" + }, + { + "id": "Vmdファイルピッカー生成エラー", + "translation": "Vmdファイルピッカー生成エラー" + }, + { + "id": "セパレータ生成エラー", + "translation": "セパレータ生成エラー" + }, + { + "id": "モーションプレイヤー生成エラー", + "translation": "モーションプレイヤー生成エラー" + }, + { + "id": "Pmxファイル読み込みエラー", + "translation": "Pmxファイル読み込みエラー" + }, + { + "id": "Vmdファイル読み込みエラー", + "translation": "Vmdファイル読み込みエラー" + }, + { + "id": "ビューワー", + "translation": "ビューワー" + }, + { + "id": "&メイン画面", + "translation": "&メイン画面" + }, + { + "id": "&デバッグログ表示", + "translation": "&デバッグログ表示" + }, + { + "id": "&冗長ログ表示", + "translation": "&冗長ログ表示" + }, + { + "id": "予期せぬエラーが発生しました", + "translation": "予期せぬエラーが発生しました" + }, + { + "id": "有効なPmxファイルが入力されていません", + "translation": "有効なPmxファイルが入力されていません" + }, + { + "id": "&使い方", + "translation": "&使い方" + }, + { + "id": "ビューワーの使い方", + "translation": "ビューワーの使い方" + }, + { + "id": "ビューワーの使い方メッセージ", + "translation": "・マウス中ホイールの上下で距離の遠近が変えられます\n・マウス中ホイールをクリックしたまま動かすと、カメラの位置が変えられます\n・マウス右ボタンをクリックしたまま動かすと、カメラの向きが変えられます\n・Shiftを押しながらマウスを操作すると変動量が大きくなります\n・Ctrlを押しながらマウスを操作すると変動量が小さくなります\n・キーパッド欄の「0」を入力すると、下面を映すカメラの向きになります\n・キーパッド欄の「2」を入力すると、正面を映すカメラの向きになります\n・キーパッド欄の「4」を入力すると、左面を映すカメラの向きになります\n・キーパッド欄の「5」を入力すると、上面を映すカメラの向きになります\n・キーパッド欄の「6」を入力すると、右面を映すカメラの向きになります\n・キーパッド欄の「8」を入力すると、背面を映すカメラの向きになります\n・キーボードの右矢印もしくは上矢印でフレームを進められます\n・キーボードの左矢印もしくは下矢印でフレームを戻せます" + }, + { + "id": "&再生フォームの使い方", + "translation": "&再生フォームの使い方" + }, + { + "id": "再生フォームの使い方", + "translation": "再生フォームの使い方" + }, + { + "id": "再生ウィジェットの使い方メッセージ", + "translation": "・「再生」ボタンはPMXモデルを設定するとクリックできるようになります\n・VMDモーションの設定は任意です\n・「再生」ボタンをクリックすると描画が開始されます。ボタンラベルが「一時停止」に変わります\n・「一時停止」ボタンをクリックすると描画が一時停止します。ボタンラベルが「再生」に変わります\n・一時停止中はキーフレ番号欄やスライダーでキーフレ位置を変更できます\n・キーフレ番号欄とスライダーはマウス中ホイールで数値を上下に変更できます" + }, + { + "id": "メイン画面の使い方", + "translation": "メイン画面の使い方" + }, + { + "id": "メイン画面の使い方メッセージ", + "translation": "・各フォームパーツの名前の上でクリックすると、そのパーツの使い方をメッセージ欄に出力します" + }, + { + "id": "予期せぬエラーヘッダー", + "translation": "予期せぬエラーが発生したため、アプリを終了します。\n再発する場合、コミュニティよりご連絡ください" + }, + { + "id": "コミュニティ報告", + "translation": "エラーをコピーしてコミュニティで報告" + }, + { + "id": "アプリを終了", + "translation": "アプリを終了" + }, + { + "id": "エラーダイアログ起動失敗", + "translation": "エラーダイアログ起動失敗" + }, + { + "id": "クリップボードコピー失敗", + "translation": "クリップボードコピー失敗" + }, + { + "id": "&ハイスペックモード", + "translation": "&ハイスペックモード" + }, + { + "id": "モデル名エンコードエラー", + "translation": "モデル名 ({{.Name}}) に日本語・英語で判読できない文字（環境依存文字・他言語文字等）が含まれているため、仮モデル名を設定します。" + }, + { + "id": "ボーン名エンコードエラー", + "translation": "ボーン名 ({{.Name}}) に日本語・英語で判読できない文字（環境依存文字・他言語文字等）が含まれているため、スキップします。" + }, + { + "id": "ファイルクローズエラー", + "translation": "ファイルパス ({{.Path}}) にファイルを出力する事ができませんでした。" + }, + { + "id": "ボーンフレーム書き込みエラー", + "translation": "ボーンデータを書き込む事ができませんでした。" + }, + { + "id": "モーフフレーム書き込みエラー", + "translation": "モーフデータを書き込む事ができませんでした。" + }, + { + "id": "&IK冗長ログ表示", + "translation": "&IK冗長ログ表示" + }, + { + "id": "固定ビュー表示", + "translation": "固定ビュー表示" + }, + { + "id": "固定ビュー非表示", + "translation": "固定ビュー非表示" + }, + { + "id": "固定ビューウィジェット生成エラー", + "translation": "固定ビューウィジェット生成エラー" + }, + { + "id": "正面", + "translation": "正面" + }, + { + "id": "左面", + "translation": "左面" + }, + { + "id": "右面", + "translation": "右面" + }, + { + "id": "背面", + "translation": "背面" + }, + { + "id": "&ワイヤーフレーム表示", + "translation": "&ワイヤーフレーム表示" + }, + { + "id": "&前面表示", + "translation": "&前面表示" + }, + { + "id": "&埋め込み表示", + "translation": "&埋め込み表示" + }, + { + "id": "&情報表示", + "translation": "&情報表示" + }, + { + "id": "&fps制限", + "translation": "&fps制限" + }, + { + "id": "&30fps制限", + "translation": "&30fps制限" + }, + { + "id": "&60fps制限", + "translation": "&60fps制限" + }, + { + "id": "&fps無制限", + "translation": "&fps無制限" + }, + { + "id": "&選択頂点表示", + "translation": "&選択頂点表示" + }, + { + "id": "ミップマップ生成エラー", + "translation": "テクスチャサイズが2のべき乗ではないため、ミップマップを生成しません。 テクスチャ名: {{.Name}}" + }, + { + "id": "アイコン生成エラー", + "translation": "アイコン生成エラー" + } +] \ No newline at end of file diff --git a/pkg/mutils/mi18n/i18n/common.ko.json b/pkg/mutils/mi18n/i18n/common.ko.json new file mode 100644 index 00000000..b49a4f89 --- /dev/null +++ b/pkg/mutils/mi18n/i18n/common.ko.json @@ -0,0 +1,370 @@ +[ + { + "id": "&ビューワー", + "translation": "&뷰어" + }, + { + "id": "&フレームドロップON", + "translation": "&프레임 드롭 ON" + }, + { + "id": "&物理ON/OFF", + "translation": "&물리 ON/OFF" + }, + { + "id": "&物理リセット", + "translation": "&물리 리셋" + }, + { + "id": "&法線表示", + "translation": "&노멀 표시" + }, + { + "id": "&ボーン表示", + "translation": "&본 표시" + }, + { + "id": "&全ボーン", + "translation": "&전체 뼈대" + }, + { + "id": "&IKボーン", + "translation": "&IK 뼈대" + }, + { + "id": "&付与親ボーン", + "translation": "&할당된 부모 뼈대" + }, + { + "id": "&軸制限ボーン", + "translation": "&축 제한 뼈대" + }, + { + "id": "&回転ボーン", + "translation": "&회전 뼈대" + }, + { + "id": "&移動ボーン", + "translation": "&이동 뼈대" + }, + { + "id": "&表示ボーン", + "translation": "&표시 뼈대" + }, + { + "id": "&剛体表示", + "translation": "&강체 표시" + }, + { + "id": "&ジョイント表示", + "translation": "&조인트 표시" + }, + { + "id": "背景色生成エラー", + "translation": "배경색 생성 오류" + }, + { + "id": "&言語", + "translation": "&언어" + }, + { + "id": "LanguageChanged.Title", + "translation": "언어 변경" + }, + { + "id": "LanguageChanged.Message", + "translation": "화면의 언어 변경은 재시작 후 적용됩니다\n앱을 종료합니다" + }, + { + "id": "未設定", + "translation": "미설정" + }, + { + "id": "開く", + "translation": "열기" + }, + { + "id": "履歴", + "translation": "기록" + }, + { + "id": "ファイルが存在しません", + "translation": "파일이 존재하지 않습니다" + }, + { + "id": "読み込み失敗", + "translation": "로드 실패" + }, + { + "id": "履歴ダイアログ生成エラー", + "translation": "기록 대화상자 생성 오류" + }, + { + "id": "履歴ダイアログタイトル", + "translation": "{{.Title}}의 기록" + }, + { + "id": "履歴リスト生成エラー", + "translation": "기록 리스트 생성 오류" + }, + { + "id": "ボタンBox生成エラー", + "translation": "버튼 박스 생성 오류" + }, + { + "id": "OKボタン生成エラー", + "translation": "확인 버튼 생성 오류" + }, + { + "id": "Cancelボタン生成エラー", + "translation": "취소 버튼 생성 오류" + }, + { + "id": "ファイル選択ダイアログタイトル", + "translation": "{{.Title}}을(를) 선택해주세요" + }, + { + "id": "ファイル選択ダイアログ選択エラー", + "translation": "파일 선택 대화상자 선택 오류" + }, + { + "id": "タブウィジェット生成エラー", + "translation": "탭 위젯 생성 오류" + }, + { + "id": "タブページ生成エラー", + "translation": "탭 페이지 생성 오류" + }, + { + "id": "再生", + "translation": "재생" + }, + { + "id": "一時停止", + "translation": "일시 정지" + }, + { + "id": "メインウィンドウ生成エラー", + "translation": "메인 윈도우 생성 오류" + }, + { + "id": "ビューワーウィンドウ生成エラー", + "translation": "뷰어 윈도우 생성 오류" + }, + { + "id": "コンソール生成エラー", + "translation": "콘솔 생성 오류" + }, + { + "id": "ファイル", + "translation": "파일" + }, + { + "id": "Pmxファイル", + "translation": "PMX 파일" + }, + { + "id": "Pmxファイルピッカー生成エラー", + "translation": "PMX 파일 선택기 생성 오류" + }, + { + "id": "Vmdファイル", + "translation": "VMD 파일" + }, + { + "id": "Vmdファイルピッカー生成エラー", + "translation": "VMD 파일 선택기 생성 오류" + }, + { + "id": "セパレータ生成エラー", + "translation": "구분자 생성 오류" + }, + { + "id": "モーションプレイヤー生成エラー", + "translation": "모션 플레이어 생성 오류" + }, + { + "id": "Pmxファイル読み込みエラー", + "translation": "PMX 파일 로드 오류" + }, + { + "id": "Vmdファイル読み込みエラー", + "translation": "VMD 파일 로드 오류" + }, + { + "id": "ビューワー", + "translation": "뷰어" + }, + { + "id": "&メイン画面", + "translation": "&메시지" + }, + { + "id": "&デバッグログ表示", + "translation": "&디버그 메시지 표시" + }, + { + "id": "&冗長ログ表示", + "translation": "&상세 메시지 표시" + }, + { + "id": "予期せぬエラーが発生しました", + "translation": "예기치 않은 오류가 발생했습니다" + }, + { + "id": "有効なPmxファイルが入力されていません", + "translation": "유효한 Pmx 파일이 입력되지 않았습니다" + }, + { + "id": "&使い方", + "translation": "&사용 방법" + }, + { + "id": "ビューワーの使い方", + "translation": "뷰어 사용 방법" + }, + { + "id": "ビューワーの使い方メッセージ", + "translation": "・마우스 휠을 사용하여 확대 및 축소할 수 있습니다.\n・마우스 휠을 누른 상태에서 이동하면 카메라 위치가 변경됩니다.\n・마우스 오른쪽 버튼을 누른 상태에서 이동하면 카메라 각도가 변경됩니다.\n・Shift 키를 누른 상태에서 마우스를 사용하면 이동 민감도가 증가합니다.\n・Ctrl 키를 누른 상태에서 마우스를 사용하면 이동 민감도가 감소합니다.\n・키패드에서 '0'을 누르면 카메라 뷰가 하단으로 설정됩니다.\n・키패드에서 '2'을 누르면 카메라 뷰가 정면으로 설정됩니다.\n・키패드에서 '4'을 누르면 카메라 뷰가 왼쪽으로 설정됩니다.\n・키패드에서 '5'을 누르면 카메라 뷰가 상단으로 설정됩니다.\n・키패드에서 '6'을 누르면 카메라 뷰가 오른쪽으로 설정됩니다.\n・키패드에서 '8'을 누르면 카메라 뷰가 후면으로 설정됩니다.\n・키보드의 오른쪽 화살표 또는 위쪽 화살표 키를 사용하여 프레임을 앞으로 이동할 수 있습니다.\n・키보드의 왼쪽 화살표 또는 아래쪽 화살표 키를 사용하여 프레임을 뒤로 이동할 수 있습니다." + }, + { + "id": "&再生フォームの使い方", + "translation": "&재생 양식 사용 방법" + }, + { + "id": "再生フォームの使い方", + "translation": "재생 양식 사용 방법" + }, + { + "id": "再生ウィジェットの使い方メッセージ", + "translation": "・'재생' 버튼은 PMX 모델을 설정하면 클릭할 수 있습니다\n・VMD 모션 설정은 선택사항입니다\n・'재생' 버튼을 클릭하면 렌더링이 시작됩니다. 버튼 라벨이 '일시 정지'로 변경됩니다\n・'일시 정지' 버튼을 클릭하면 렌더링이 일시 정지됩니다. 버튼 라벨이 '재생'으로 변경됩니다\n・일시 정지 중에는 키프레임 번호 필드나 슬라이더로 키프레임 위치를 변경할 수 있습니다\n・키프레임 번호 필드와 슬라이더는 마우스 중간 휠로 숫자를 상하로 변경할 수 있습니다" + }, + { + "id": "メイン画面の使い方", + "translation": "메인 화면 사용 방법" + }, + { + "id": "メイン画面の使い方メッセージ", + "translation": "・각 폼 부품의 이름 위를 클릭하면, 해당 부품의 사용 방법이 메시지 필드에 출력됩니다" + }, + { + "id": "予期せぬエラーヘッダー", + "translation": "예기치 않은 오류로 인해 앱이 종료됩니다.\n다시 발생하면 커뮤니티에 연락해 주세요." + }, + { + "id": "コミュニティ報告", + "translation": "오류를 복사하여 커뮤니티에 보고하세요" + }, + { + "id": "アプリを終了", + "translation": "앱 종료" + }, + { + "id": "エラーダイアログ起動失敗", + "translation": "오류 대화 상자 시작 실패" + }, + { + "id": "クリップボードコピー失敗", + "translation": "클립보드 복사 실패" + }, + { + "id": "&ハイスペックモード", + "translation": "&하이 스펙 모드" + }, + { + "id": "モデル名エンコードエラー", + "translation": "모델 이름 ({{.Name}})에 일본어나 영어로 읽을 수 없는 문자(환경 의존 문자, 외국어 문자 등)가 포함되어 있으므로 임시 모델 이름이 설정됩니다." + }, + { + "id": "ボーン名エンコードエラー", + "translation": "본 이름 ({{.Name}})에 일본어나 영어로 읽을 수 없는 문자(환경 의존 문자, 외국어 문자 등)가 포함되어 있으므로 건너뜁니다." + }, + { + "id": "ファイルクローズエラー", + "translation": "파일 경로 ({{.Path}})에 파일을 출력하지 못했습니다." + }, + { + "id": "ボーンフレーム書き込みエラー", + "translation": "본 데이터를 쓰지 못했습니다." + }, + { + "id": "モーフフレーム書き込みエラー", + "translation": "모프 데이터를 쓰지 못했습니다." + }, + { + "id": "&IK冗長ログ表示", + "translation": "&IK冗長 로그 표시" + }, + { + "id": "固定ビュー表示", + "translation": "고정 보기 표시" + }, + { + "id": "固定ビュー非表示", + "translation": "고정 보기 숨기기" + }, + { + "id": "固定ビューウィジェット生成エラー", + "translation": "고정 보기 위젯 생성 오류" + }, + { + "id": "正面", + "translation": "앞면" + }, + { + "id": "左面", + "translation": "왼쪽" + }, + { + "id": "右面", + "translation": "오른쪽" + }, + { + "id": "背面", + "translation": "뒷면" + }, + { + "id": "&ワイヤーフレーム表示", + "translation": "&와이어프레임 표시" + }, + { + "id": "&前面表示", + "translation": "&앞면 표시" + }, + { + "id": "&埋め込み表示", + "translation": "&내장 표시" + }, + { + "id": "&情報表示", + "translation": "&정보 표시" + }, + { + "id": "&fps制限", + "translation": "&FPS 제한" + }, + { + "id": "&30fps制限", + "translation": "&30 FPS 제한" + }, + { + "id": "&60fps制限", + "translation": "&60 FPS 제한" + }, + { + "id": "&fps無制限", + "translation": "&FPS 무제한" + }, + { + "id": "&選択頂点表示", + "translation": "&선택된 정점 표시" + }, + { + "id": "ミップマップ生成エラー", + "translation": "텍스처 크기가 2의 제곱수가 아니므로 Mipmaps를 생성하지 않습니다. 텍스처 이름: {{.Name}}" + }, + { + "id": "アイコン生成エラー", + "translation": "아이콘 생성 오류" + } +] \ No newline at end of file diff --git a/pkg/mutils/mi18n/i18n/common.zh.json b/pkg/mutils/mi18n/i18n/common.zh.json new file mode 100644 index 00000000..ea9da687 --- /dev/null +++ b/pkg/mutils/mi18n/i18n/common.zh.json @@ -0,0 +1,370 @@ +[ + { + "id": "&ビューワー", + "translation": "&查看器" + }, + { + "id": "&フレームドロップON", + "translation": "&帧丢失开" + }, + { + "id": "&物理ON/OFF", + "translation": "&物理开/关" + }, + { + "id": "&物理リセット", + "translation": "&物理重置" + }, + { + "id": "&法線表示", + "translation": "&法线显示" + }, + { + "id": "&ボーン表示", + "translation": "&骨骼显示" + }, + { + "id": "&全ボーン", + "translation": "&全骨骼" + }, + { + "id": "&IKボーン", + "translation": "&IK 骨骼" + }, + { + "id": "&付与親ボーン", + "translation": "&赋予父骨骼" + }, + { + "id": "&軸制限ボーン", + "translation": "&轴限制骨骼" + }, + { + "id": "&回転ボーン", + "translation": "&旋转骨骼" + }, + { + "id": "&移動ボーン", + "translation": "&移动骨骼" + }, + { + "id": "&表示ボーン", + "translation": "&显示骨骼" + }, + { + "id": "&剛体表示", + "translation": "&刚体显示" + }, + { + "id": "&ジョイント表示", + "translation": "&关节显示" + }, + { + "id": "背景色生成エラー", + "translation": "背景色生成错误" + }, + { + "id": "&言語", + "translation": "&语言" + }, + { + "id": "LanguageChanged.Title", + "translation": "语言更改" + }, + { + "id": "LanguageChanged.Message", + "translation": "屏幕上的语言更改将在重新启动后生效\n现在将关闭应用程序" + }, + { + "id": "未設定", + "translation": "未设置" + }, + { + "id": "開く", + "translation": "打开" + }, + { + "id": "履歴", + "translation": "历史" + }, + { + "id": "ファイルが存在しません", + "translation": "文件不存在" + }, + { + "id": "読み込み失敗", + "translation": "加载失败" + }, + { + "id": "履歴ダイアログ生成エラー", + "translation": "历史对话框生成错误" + }, + { + "id": "履歴ダイアログタイトル", + "translation": "{{.Title}}的历史" + }, + { + "id": "履歴リスト生成エラー", + "translation": "历史列表生成错误" + }, + { + "id": "ボタンBox生成エラー", + "translation": "按钮盒生成错误" + }, + { + "id": "OKボタン生成エラー", + "translation": "OK按钮生成错误" + }, + { + "id": "Cancelボタン生成エラー", + "translation": "取消按钮生成错误" + }, + { + "id": "ファイル選択ダイアログタイトル", + "translation": "请选择{{.Title}}" + }, + { + "id": "ファイル選択ダイアログ選択エラー", + "translation": "文件选择对话框选择错误" + }, + { + "id": "タブウィジェット生成エラー", + "translation": "标签小部件生成错误" + }, + { + "id": "タブページ生成エラー", + "translation": "标签页生成错误" + }, + { + "id": "再生", + "translation": "播放" + }, + { + "id": "一時停止", + "translation": "暂停" + }, + { + "id": "メインウィンドウ生成エラー", + "translation": "主窗口生成错误" + }, + { + "id": "ビューワーウィンドウ生成エラー", + "translation": "查看器窗口生成错误" + }, + { + "id": "コンソール生成エラー", + "translation": "控制台生成错误" + }, + { + "id": "ファイル", + "translation": "文件" + }, + { + "id": "Pmxファイル", + "translation": "PMX文件" + }, + { + "id": "Pmxファイルピッカー生成エラー", + "translation": "PMX文件选择器生成错误" + }, + { + "id": "Vmdファイル", + "translation": "VMD文件" + }, + { + "id": "Vmdファイルピッカー生成エラー", + "translation": "VMD文件选择器生成错误" + }, + { + "id": "セパレータ生成エラー", + "translation": "分隔符生成错误" + }, + { + "id": "モーションプレイヤー生成エラー", + "translation": "动作播放器生成错误" + }, + { + "id": "Pmxファイル読み込みエラー", + "translation": "PMX文件加载错误" + }, + { + "id": "Vmdファイル読み込みエラー", + "translation": "VMD文件加载错误" + }, + { + "id": "ビューワー", + "translation": "查看器" + }, + { + "id": "&メイン画面", + "translation": "&消息" + }, + { + "id": "&デバッグログ表示", + "translation": "&显示调试消息" + }, + { + "id": "&冗長ログ表示", + "translation": "&显示详细消息" + }, + { + "id": "予期せぬエラーが発生しました", + "translation": "发生了意外的错误" + }, + { + "id": "有効なPmxファイルが入力されていません", + "translation": "未输入有效的Pmx文件" + }, + { + "id": "&使い方", + "translation": "&使用方法" + }, + { + "id": "ビューワーの使い方", + "translation": "如何使用查看器" + }, + { + "id": "ビューワーの使い方メッセージ", + "translation": "・使用鼠标滚轮进行缩放\n・按住鼠标滚轮并移动以更改摄像机位置\n・按住鼠标右键并移动以更改摄像机角度\n・按住Shift键并使用鼠标以增加移动灵敏度\n・按住Ctrl键并使用鼠标以降低移动灵敏度\n・按下数字键盘上的“0”将摄像机视角设为底面\n・按下数字键盘上的“2”将摄像机视角设为正面\n・按下数字键盘上的“4”将摄像机视角设为左侧\n・按下数字键盘上的“5”将摄像机视角设为顶部\n・按下数字键盘上的“6”将摄像机视角设为右侧\n・按下数字键盘上的“8”将摄像机视角设为背面\n・使用键盘上的右箭头或上箭头键向前移动一帧\n・使用键盘上的左箭头或下箭头键向后移动一帧" + }, + { + "id": "&再生フォームの使い方", + "translation": "&如何使用播放表单" + }, + { + "id": "再生フォームの使い方", + "translation": "如何使用播放表单" + }, + { + "id": "再生ウィジェットの使い方メッセージ", + "translation": "・设置PMX模型后，'播放'按钮可被点击\n・设置VMD动作是可选的\n・点击'播放'按钮开始渲染，按钮标签变为'暂停'\n・点击'暂停'按钮暂停渲染，按钮标签变为'播放'\n・暂停时，可以使用关键帧编号字段或滑块改变关键帧位置\n・关键帧编号字段和滑块可以使用鼠标中键滚轮上下调整数字" + }, + { + "id": "メイン画面の使い方", + "translation": "如何使用主屏幕" + }, + { + "id": "メイン画面の使い方メッセージ", + "translation": "・点击每个表单部件名称上方，会在消息字段输出该部件的使用方法" + }, + { + "id": "予期せぬエラーヘッダー", + "translation": "由于发生意外错误，应用程序将关闭。\n如果再次发生，请联系社区" + }, + { + "id": "コミュニティ報告", + "translation": "复制错误并在社区中报告" + }, + { + "id": "アプリを終了", + "translation": "关闭应用程序" + }, + { + "id": "エラーダイアログ起動失敗", + "translation": "错误对话框启动失败" + }, + { + "id": "クリップボードコピー失敗", + "translation": "复制到剪贴板失败" + }, + { + "id": "&ハイスペックモード", + "translation": "&高性能模式" + }, + { + "id": "モデル名エンコードエラー", + "translation": "由于模型名称 ({{.Name}}) 包含日语或英语中无法识别的字符（环境依赖字符、外语字符等），将设置一个临时模型名称。" + }, + { + "id": "ボーン名エンコードエラー", + "translation": "由于骨骼名称 ({{.Name}}) 包含日语或英语中无法识别的字符（环境依赖字符、外语字符等），将被跳过。" + }, + { + "id": "ファイルクローズエラー", + "translation": "无法将文件输出到文件路径 ({{.Path}})。" + }, + { + "id": "ボーンフレーム書き込みエラー", + "translation": "无法写入骨骼数据。" + }, + { + "id": "モーフフレーム書き込みエラー", + "translation": "无法写入变形数据。" + }, + { + "id": "&IK冗長ログ表示", + "translation": "&IK详细日志显示" + }, + { + "id": "固定ビュー表示", + "translation": "固定视图显示" + }, + { + "id": "固定ビュー非表示", + "translation": "隐藏固定视图" + }, + { + "id": "固定ビューウィジェット生成エラー", + "translation": "固定视图小部件生成错误" + }, + { + "id": "正面", + "translation": "正面" + }, + { + "id": "左面", + "translation": "左面" + }, + { + "id": "右面", + "translation": "右面" + }, + { + "id": "背面", + "translation": "背面" + }, + { + "id": "&ワイヤーフレーム表示", + "translation": "&线框显示" + }, + { + "id": "&前面表示", + "translation": "&前面显示" + }, + { + "id": "&埋め込み表示", + "translation": "&嵌入显示" + }, + { + "id": "&情報表示", + "translation": "&显示信息" + }, + { + "id": "&fps制限", + "translation": "&FPS限制" + }, + { + "id": "&30fps制限", + "translation": "&30 FPS限制" + }, + { + "id": "&60fps制限", + "translation": "&60 FPS限制" + }, + { + "id": "&fps無制限", + "translation": "&无限制FPS" + }, + { + "id": "&選択頂点表示", + "translation": "&选择顶点显示" + }, + { + "id": "ミップマップ生成エラー", + "translation": "纹理大小不是2的幂，因此不会生成Mipmaps。纹理名称：{{.Name}}" + }, + { + "id": "アイコン生成エラー", + "translation": "图标生成错误" + } +] \ No newline at end of file diff --git a/pkg/mutils/mi18n/mi18n.go b/pkg/mutils/mi18n/mi18n.go new file mode 100644 index 00000000..0b038054 --- /dev/null +++ b/pkg/mutils/mi18n/mi18n.go @@ -0,0 +1,82 @@ +package mi18n + +import ( + "embed" + "encoding/json" + + "github.com/nicksnyder/go-i18n/v2/i18n" + "golang.org/x/text/language" + + "github.com/miu200521358/mlib_go/pkg/mutils/mconfig" +) + +var bundle *i18n.Bundle +var localizer *i18n.Localizer + +//go:embed i18n/* +var commonI18nFiles embed.FS + +func Initialize(appI18nFiles embed.FS) { + langs := mconfig.LoadUserConfig("lang") + + var lang string + var langTag language.Tag + if len(langs) == 0 { + lang = "ja" + } else { + lang = langs[0] + } + + switch lang { + case "ja": + langTag = language.Japanese + case "en": + langTag = language.English + case "zh": + langTag = language.Chinese + case "ko": + langTag = language.Korean + default: + langTag = language.Japanese + } + + bundle = i18n.NewBundle(langTag) + bundle.RegisterUnmarshalFunc("json", json.Unmarshal) + bundle.LoadMessageFileFS(commonI18nFiles, "i18n/common.ja.json") + bundle.LoadMessageFileFS(commonI18nFiles, "i18n/common.en.json") + bundle.LoadMessageFileFS(commonI18nFiles, "i18n/common.zh.json") + bundle.LoadMessageFileFS(commonI18nFiles, "i18n/common.ko.json") + + bundle.LoadMessageFileFS(appI18nFiles, "i18n/app.ja.json") + bundle.LoadMessageFileFS(appI18nFiles, "i18n/app.en.json") + bundle.LoadMessageFileFS(appI18nFiles, "i18n/app.zh.json") + bundle.LoadMessageFileFS(appI18nFiles, "i18n/app.ko.json") + + localizer = i18n.NewLocalizer(bundle, lang) +} + +func SetLang(lang string) { + mconfig.SaveUserConfig("lang", lang, 1) +} + +// T メッセージIDを元にメッセージを取得する +func T(key string, params ...map[string]interface{}) string { + if localizer == nil { + return key + } + if len(params) == 0 { + return localizer.MustLocalize(&i18n.LocalizeConfig{MessageID: key}) + } + return localizer.MustLocalize(&i18n.LocalizeConfig{MessageID: key, TemplateData: params[0]}) +} + +// TWithLocale メッセージIDを元に指定ロケールでメッセージを取得する +func TWithLocale(lang string, key string, params ...map[string]interface{}) string { + if bundle == nil { + return key + } + if len(params) == 0 { + return i18n.NewLocalizer(bundle, lang).MustLocalize(&i18n.LocalizeConfig{MessageID: key}) + } + return i18n.NewLocalizer(bundle, lang).MustLocalize(&i18n.LocalizeConfig{MessageID: key, TemplateData: params}) +} diff --git a/pkg/mutils/miter/miter.go b/pkg/mutils/miter/miter.go new file mode 100644 index 00000000..f6a7c413 --- /dev/null +++ b/pkg/mutils/miter/miter.go @@ -0,0 +1,44 @@ +package miter + +import "sync" + +var blockSize = 100 + +func GetBlockSize() int { + return blockSize +} + +// SetBlockSize 並列処理のブロックサイズ +func SetBlockSize(size int) { + blockSize = size +} + +// IterParallel は指定された全件数に対して、引数で指定された処理を並列または直列で実行する関数です。 +// allCount: ループしたい全件数 +// blockSize: 並列処理を行うブロックのサイズ +// processFunc: 実行したい処理を定義した関数 +func IterParallel(allCount int, processFunc func(int)) { + if blockSize <= 1 { + // ブロックサイズが1以下の場合は直列処理 + for i := 0; i < allCount; i++ { + processFunc(i) + } + } else { + // ブロックサイズが1より大きい場合は並列処理 + var wg sync.WaitGroup + for i := 0; i < allCount; i += blockSize { + wg.Add(1) + go func(startIndex int) { + defer wg.Done() + endIndex := startIndex + blockSize + if endIndex > allCount { + endIndex = allCount + } + for j := startIndex; j < endIndex; j++ { + processFunc(j) + } + }(i) + } + wg.Wait() // すべてのgoroutineが終了するまで待機 + } +} diff --git a/pkg/mutils/miter/miter_test.go b/pkg/mutils/miter/miter_test.go new file mode 100644 index 00000000..d7c5c1c3 --- /dev/null +++ b/pkg/mutils/miter/miter_test.go @@ -0,0 +1,81 @@ +package miter + +import ( + "sync" + "testing" +) + +func TestIterParallel(t *testing.T) { + // Test case 1: Serial processing + var serialCount int + serialFunc := func(i int) { + serialCount++ + } + IterParallel(10, serialFunc) + if serialCount != 10 { + t.Errorf("Expected serialCount to be 10, got %d", serialCount) + } + + // Test case 2: Parallel processing + var parallelCount int + parallelFunc := func(i int) { + parallelCount++ + } + IterParallel(10, parallelFunc) + if parallelCount != 10 { + t.Errorf("Expected parallelCount to be 10, got %d", parallelCount) + } +} + +func TestIterParallel_BlockSize(t *testing.T) { + // Test case 1: Serial processing with block size 1 + var serialCount int + serialFunc := func(i int) { + serialCount++ + } + blockSize = 1 + IterParallel(10, serialFunc) + if serialCount != 10 { + t.Errorf("Expected serialCount to be 10, got %d", serialCount) + } + + // Test case 2: Parallel processing with block size 2 + var parallelCount int + parallelFunc := func(i int) { + parallelCount++ + } + blockSize = 2 + IterParallel(10, parallelFunc) + if parallelCount != 10 { + t.Errorf("Expected parallelCount to be 10, got %d", parallelCount) + } +} + +func TestIterParallel_Concurrency(t *testing.T) { + // Test case 1: Verify concurrency + var count int + concurrentFunc := func(i int) { + count++ + } + blockSize = 2 + IterParallel(10, concurrentFunc) + if count != 10 { + t.Errorf("Expected count to be 10, got %d", count) + } + + // Test case 2: Verify concurrent execution + var wg sync.WaitGroup + concurrentFunc2 := func(i int) { + defer wg.Done() + count++ + } + blockSize = 2 + for i := 0; i < 10; i++ { + wg.Add(1) + go concurrentFunc2(i) + } + wg.Wait() + if count != 20 { + t.Errorf("Expected count to be 20, got %d", count) + } +} diff --git a/pkg/mutils/mlog/mlog.go b/pkg/mutils/mlog/mlog.go new file mode 100644 index 00000000..930512f3 --- /dev/null +++ b/pkg/mutils/mlog/mlog.go @@ -0,0 +1,159 @@ +package mlog + +import ( + "log" + "runtime" +) + +var level = 20 + +const ( + VERBOSE = 0 + IK_VERBOSE = 1 + VERBOSE2 = 2 + VERBOSE9 = 9 + DEBUG = 10 + INFO = 20 + WARN = 30 + ERROR = 40 + FATAL = 50 +) + +func init() { + log.SetFlags(0) +} + +func IsVerbose() bool { + return level < DEBUG +} + +func IsVerbose2() bool { + return level == VERBOSE2 +} + +func IsIkVerbose() bool { + return level == IK_VERBOSE +} + +func IsVerbose9() bool { + return level < DEBUG +} + +func IsDebug() bool { + return level < INFO +} + +// SetLevel ログレベルの設定 +func SetLevel(l int) { + level = l +} + +// Verbose 冗長ログ +func V(message string, param ...interface{}) { + if level < DEBUG { + log.Printf(message, param...) + } +} + +// Verbose2 冗長ログ +func V2(message string, param ...interface{}) { + if VERBOSE2 <= level && level < DEBUG { + log.Printf(message, param...) + } +} + +// Ik Verbose2 冗長ログ +func IV(message string, param ...interface{}) { + if level == IK_VERBOSE { + log.Printf(message, param...) + } +} + +// Debug デバッグログ +func D(message string, param ...interface{}) { + if level < INFO { + log.Printf(message, param...) + } +} + +// L ログの区切り線 +func L() { + log.Println("---------------------------------") +} + +// Info 情報ログ +func I(message string, param ...interface{}) { + log.Printf(message, param...) +} + +// IL 情報ログ（区切り線付き） +func IL(message string, param ...interface{}) { + L() + I(message, param...) +} + +// IT 情報ログ（タイトル付き） +func IT(title string, message string, param ...interface{}) { + log.Printf("■■■■■ %s ■■■■■", title) + I(message, param...) +} + +// ILT 情報ログ（区切り線・タイトル付き） +func ILT(title string, message string, param ...interface{}) { + L() + IT(title, message, param...) +} + +// Warn 警告ログ +func W(message string, param ...interface{}) { + WT("WARN", message, param...) +} + +// Warn 警告ログ +func WT(title string, message string, param ...interface{}) { + log.Printf("~~~~~~~~~~ %s ~~~~~~~~~~", title) + log.Printf(message, param...) +} + +// Error エラーログ +func E(message string, param ...interface{}) { + ET("ERROR", message, param...) +} + +// Error エラーログ +func ET(title string, message string, param ...interface{}) { + log.Printf("********** %s **********", title) + log.Printf(message, param...) +} + +// Fatal 致命的エラーログ +func F(message string, param ...interface{}) { + FT("FATAL ERROR", message, param...) +} + +// Error エラーログ +func FT(title string, message string, param ...interface{}) { + log.Printf("!!!!!!!!!! %s !!!!!!!!!!", title) + log.Printf(message, param...) +} + +var prevMem uint64 + +func Memory(prefix string) { + var m runtime.MemStats + runtime.ReadMemStats(&m) + mem := bToMb(m.Alloc) + if prevMem != mem { + log.Printf("[%s] Alloc = %v -> %v MiB, HeapAlloc = %v MiB, HeapSys = %v MiB, HeapIdle = %v MiB, "+ + "HeapInuse = %v MiB, HeapReleased = %v MiB, TotalAlloc = %v MiB, Sys = %v MiB, NumGC = %v\n", + prefix, prevMem, mem, bToMb(m.HeapAlloc), bToMb(m.HeapSys), bToMb(m.HeapIdle), + bToMb(m.HeapInuse), bToMb(m.HeapReleased), bToMb(m.TotalAlloc), bToMb(m.Sys), m.NumGC) + prevMem = mem + } + // log.Printf("[%s] Alloc = %v MiB, TotalAlloc = %v MiB, Sys = %v MiB, NumGC = %v\n", + // prefix, bToMb(m.Alloc), bToMb(m.TotalAlloc), m.NumGC, bToMb(m.Sys)) +} + +func bToMb(b uint64) uint64 { + return b / 1024 / 1024 +} diff --git a/pkg/mutils/util_file.go b/pkg/mutils/util_file.go new file mode 100644 index 00000000..90f7a561 --- /dev/null +++ b/pkg/mutils/util_file.go @@ -0,0 +1,111 @@ +package mutils + +import ( + "fmt" + "io" + "os" + "path/filepath" + "time" +) + +// 指定されたパスがファイルとして存在しているか +func ExistsFile(path string) (bool, error) { + if path == "" { + return false, fmt.Errorf("path is empty") + } + + info, err := os.Stat(path) + if os.IsNotExist(err) { + return false, err + } + return !info.IsDir(), nil +} + +// 指定されたパスをファイルとして開く +func Open(path string) (*os.File, error) { + isFile, err := ExistsFile(path) + if err != nil { + return nil, err + } + if !isFile { + return nil, fmt.Errorf("path not file: %s", path) + } + + // ファイルを開く + file, err := os.Open(path) + if err != nil { + return nil, err + } + + return file, nil +} + +// 指定されたファイルを閉じる +func Close(file *os.File) { + defer file.Close() +} + +// アプリのルートディレクトリを取得 +func GetAppRootDir() string { + // ファイルのフルパスを取得 + exePath, err := os.Executable() + if err != nil { + panic(err) + } + return filepath.Dir(exePath) +} + +// テキストファイルの全文を読み込んでひとつの文字列で返す +func ReadText(path string) (string, error) { + isExist, err := ExistsFile(path) + if err != nil { + return "", err + } + if !isExist { + return "", fmt.Errorf("path not found: %s", path) + } + + file, err := Open(path) + if err != nil { + return "", err + } + + content, err := io.ReadAll(file) + if err != nil { + return "", err + } + + defer Close(file) + + return string(content), nil +} + +// 保存可能なファイルパスであるか否か +func CanSave(path string) bool { + if path == "" { + return false + } + + // ファイルパスまでのディレクトリ + dir := filepath.Dir(path) + if dir == "" || dir == "." { + return false + } + + // ディレクトリが存在しない場合は作成不可 + if _, err := os.Stat(dir); os.IsNotExist(err) { + return false + } + + return true +} + +func CreateOutputPath(originalPath, label string) string { + originalDir, fileName := filepath.Split(originalPath) + ext := filepath.Ext(fileName) + if label != "" { + label = label + "_" + } + return filepath.Join(originalDir, fmt.Sprintf("%s_%s%s%s", fileName[:len(fileName)-len(ext)], + label, time.Now().Format("20060102_150405"), ext)) +} diff --git a/pkg/mutils/util_image.go b/pkg/mutils/util_image.go new file mode 100644 index 00000000..71541cd5 --- /dev/null +++ b/pkg/mutils/util_image.go @@ -0,0 +1,151 @@ +package mutils + +import ( + "bytes" + "embed" + "fmt" + "image" + "image/draw" + "image/gif" + "image/jpeg" + "image/png" + "io" + "io/fs" + "os" + "strings" + + "github.com/ftrvxmtrx/tga" + "github.com/miu200521358/dds/pkg/dds" + "github.com/miu200521358/walk/pkg/walk" + "golang.org/x/image/bmp" + _ "golang.org/x/image/riff" + _ "golang.org/x/image/tiff" +) + +// LoadWalkIcon 画像ファイルの読み込み +func LoadWalkIcon(resources embed.FS, imagePath string, dpi int) (*walk.Icon, error) { + image, err := LoadImageFromResources(resources, imagePath) + if err != nil { + return nil, err + } + img, err := walk.NewIconFromImageForDPI(*image, dpi) + if err != nil { + return nil, err + } + return img, nil +} + +// 指定されたパスから画像を読み込む +func LoadImage(path string) (*image.Image, error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + + return loadImage(path, file) +} + +// 指定された画像を反転させる +func FlipImage(img *image.RGBA) *image.RGBA { + bounds := img.Bounds() + width, height := bounds.Max.X, bounds.Max.Y + + flipped := image.NewRGBA(image.Rect(0, 0, width, height)) + + for y := 0; y < height; y++ { + for x := 0; x < width; x++ { + srcX := width - x - 1 + srcY := y + srcColor := img.At(srcX, srcY) + flipped.Set(x, y, srcColor) + } + } + + return flipped +} + +// ReadIconFile アイコンファイルの読み込み +func LoadImageFromResources(resources embed.FS, fileName string) (*image.Image, error) { + fileData, err := fs.ReadFile(resources, fileName) + if err != nil { + return nil, fmt.Errorf("image not found: %v", err) + } + file := bytes.NewReader(fileData) + + return loadImage(fileName, file) +} + +func ConvertToNRGBA(img image.Image) *image.NRGBA { + // 画像がすでに*image.NRGBA型の場合はそのまま返す + if rgba, ok := img.(*image.NRGBA); ok { + return rgba + } + + // それ以外の場合は、新しい*image.NRGBAイメージに描画して変換する + bounds := img.Bounds() + rgba := image.NewNRGBA(bounds) + draw.Draw(rgba, rgba.Bounds(), img, bounds.Min, draw.Src) + + return rgba +} + +func loadImage(path string, file io.Reader) (*image.Image, error) { + paths := strings.Split(path, ".") + if len(paths) < 2 { + return nil, fmt.Errorf("invalid file path: %s", path) + } + + switch paths[len(paths)-1] { + case "png": + img, err := png.Decode(file) + if err != nil { + return nil, err + } + + return &img, nil + case "tga": + img, err := tga.Decode(file) + if err != nil { + return nil, err + } + + return &img, nil + case "gif": + img, err := gif.Decode(file) + if err != nil { + return nil, err + } + + return &img, nil + case "dds": + img, err := dds.Decode(file) + if err != nil { + return nil, err + } + + return &img, nil + case "jpg", "jpeg": + img, err := jpeg.Decode(file) + if err != nil { + return nil, err + } + + return &img, nil + case "spa", "bmp": + // スフィアファイルはbmpとして読み込む + img, err := bmp.Decode(file) + if err != nil { + return nil, err + } + + return &img, nil + } + + img, _, err := image.Decode(file) + if err != nil { + return nil, err + } + + return &img, nil +} diff --git a/pkg/mutils/util_string.go b/pkg/mutils/util_string.go new file mode 100644 index 00000000..d4a12f0d --- /dev/null +++ b/pkg/mutils/util_string.go @@ -0,0 +1,49 @@ +package mutils + +import ( + "fmt" + "slices" + "strconv" + "strings" +) + +func JoinSlice(slice []interface{}) string { + // Convert each item in the slice to a string. + strSlice := make([]string, len(slice)) + for i, v := range slice { + strSlice[i] = fmt.Sprint(v) + } + + // Join the string slice into a single string with commas in between. + return "[" + strings.Join(strSlice, ", ") + "]" +} + +func RemoveFromSlice[S ~[]E, E comparable](slice S, value E) []E { + // value が含まれている index を探す + index := slices.Index(slice, value) + if index == -1 { + return slice + } + return append(slice[:index], slice[index+1:]...) +} + +func JoinIntsWithComma(ints []int) string { + var strList []string + for _, num := range ints { + strList = append(strList, strconv.Itoa(num)) + } + return strings.Join(strList, ", ") +} + +func SplitCommaSeparatedInts(s string) ([]int, error) { + var ints []int + strList := strings.Split(s, ", ") + for _, str := range strList { + num, err := strconv.Atoi(str) + if err != nil { + return nil, err + } + ints = append(ints, num) + } + return ints, nil +} diff --git a/pkg/mview/glsl/bone.frag b/pkg/mview/glsl/bone.frag new file mode 100644 index 00000000..8ca394db --- /dev/null +++ b/pkg/mview/glsl/bone.frag @@ -0,0 +1,8 @@ +#version 440 core + +in vec4 boneColor; +out vec4 outColor; + +void main() { + outColor = boneColor; +} \ No newline at end of file diff --git a/pkg/mview/glsl/bone.vert b/pkg/mview/glsl/bone.vert new file mode 100644 index 00000000..5682a9b3 --- /dev/null +++ b/pkg/mview/glsl/bone.vert @@ -0,0 +1,212 @@ +#version 440 core + +uniform mat4 modelViewProjectionMatrix; +uniform mat4 modelViewMatrix; + +// ボーン変形行列を格納するテクスチャ +uniform sampler2D boneMatrixTexture; +uniform int boneMatrixWidth; +uniform int boneMatrixHeight; + +in layout(location = 0) vec3 position; +in layout(location = 1) vec3 normal; +in layout(location = 2) vec2 uv; +in layout(location = 3) vec2 extendUv; +in layout(location = 4) float vertexEdge; +in layout(location = 5) vec4 boneIndexes; +in layout(location = 6) vec4 boneWeights; +in layout(location = 7) float isSdef; +in layout(location = 8) vec3 sdefC; +in layout(location = 9) vec3 sdefR0; +in layout(location = 10) vec3 sdefR1; +in layout(location = 11) vec3 vertexDelta; // 頂点モーフ +in layout(location = 12) vec4 uvDelta; // UVモーフ +in layout(location = 13) vec4 uv1Delta; // 拡張UV1モーフ +in layout(location = 14) vec3 afterVertexDelta; // ボーン変形後頂点モーフ + +out float totalBoneWeight; +out vec4 boneColor; + +// 球形補間 +vec4 slerp(vec4 q1, vec4 q2, float t) { + float dot = dot(q1, q2); + + if(dot < 0.0) { + q1 = -q1; // q1の向きを反転させる + dot = -dot; + } + + if(dot > 0.9995) { + // クォータニオンが非常に近い場合は線形補間を使用し、正規化する + vec4 result = q1 + t * (q2 - q1); + return normalize(result); + } + + dot = clamp(dot, -1.0, 1.0); // 数値誤差による範囲外の値を修正 + float theta_0 = acos(dot); // q1とq2の間の角度 + float theta = theta_0 * t; // 現在のtにおける角度 + + vec4 q3 = q2 - q1 * dot; + q3 = normalize(q3); // 正規直交基底を作成 + + return q1 * cos(theta) + q3 * sin(theta); +} + +// mat4からvec4(クォータニオン)への変換 +vec4 mat4ToQuat(mat4 m) { + float tr = m[0][0] + m[1][1] + m[2][2]; + float qw, qx, qy, qz; + if(tr > 0) { + float S = sqrt(tr + 1.0) * 2; // S=4*qw + qw = 0.25 * S; + qx = (m[2][1] - m[1][2]) / S; + qy = (m[0][2] - m[2][0]) / S; + qz = (m[1][0] - m[0][1]) / S; + } else if((m[0][0] > m[1][1]) && (m[0][0] > m[2][2])) { + float S = sqrt(1.0 + m[0][0] - m[1][1] - m[2][2]) * 2; // S=4*qx + qw = (m[2][1] - m[1][2]) / S; + qx = 0.25 * S; + qy = (m[0][1] + m[1][0]) / S; + qz = (m[0][2] + m[2][0]) / S; + } else if(m[1][1] > m[2][2]) { + float S = sqrt(1.0 + m[1][1] - m[0][0] - m[2][2]) * 2; // S=4*qy + qw = (m[0][2] - m[2][0]) / S; + qx = (m[0][1] + m[1][0]) / S; + qy = 0.25 * S; + qz = (m[1][2] + m[2][1]) / S; + } else { + float S = sqrt(1.0 + m[2][2] - m[0][0] - m[1][1]) * 2; // S=4*qz + qw = (m[1][0] - m[0][1]) / S; + qx = (m[0][2] + m[2][0]) / S; + qy = (m[1][2] + m[2][1]) / S; + qz = 0.25 * S; + } + return vec4(qx, qy, qz, qw); +} + +// vec4(クォータニオン)からmat4への変換 +mat4 quatToMat4(vec4 q) { + float x = q.x; + float y = q.y; + float z = q.z; + float w = q.w; + return mat4(1.0 - 2.0 * y * y - 2.0 * z * z, 2.0 * x * y - 2.0 * z * w, 2.0 * x * z + 2.0 * y * w, 0.0, 2.0 * x * y + 2.0 * z * w, 1.0 - 2.0 * x * x - 2.0 * z * z, 2.0 * y * z - 2.0 * x * w, 0.0, 2.0 * x * z - 2.0 * y * w, 2.0 * y * z + 2.0 * x * w, 1.0 - 2.0 * x * x - 2.0 * y * y, 0.0, 0.0, 0.0, 0.0, 1.0); +} + +// テクスチャからボーン変形行列を取得する +mat4 getBoneMatrix(int boneIndex) { + int rowIndex = boneIndex * 4 / boneMatrixWidth; + int colIndex = (boneIndex * 4) - (boneMatrixWidth * rowIndex); + + vec4 row0 = texelFetch(boneMatrixTexture, ivec2(colIndex + 0, rowIndex), 0); + vec4 row1 = texelFetch(boneMatrixTexture, ivec2(colIndex + 1, rowIndex), 0); + vec4 row2 = texelFetch(boneMatrixTexture, ivec2(colIndex + 2, rowIndex), 0); + vec4 row3 = texelFetch(boneMatrixTexture, ivec2(colIndex + 3, rowIndex), 0); + mat4 boneMatrix = mat4(row0, row1, row2, row3); + + return boneMatrix; +} + +// クォータニオンによるボーンの回転を計算し、頂点Pを変形させる +mat4 calculateSdefMatrix(mat4 boneMatrix0, mat4 boneMatrix1, float boneWeight0, float boneWeight1) { + // ボーンのクォータニオン回転を取得 + vec4 boneQuat0 = mat4ToQuat(boneMatrix0); + vec4 boneQuat1 = mat4ToQuat(boneMatrix1); + + // ボーンのウェイトに基づいてクォータニオンをSLERPにより補間 + vec4 slerpedQuat1 = slerp(boneQuat0, boneQuat1, boneWeight1); + + // クォータニオンを回転行列に変換 + mat4 rotationMatrix = quatToMat4(slerpedQuat1); + + return rotationMatrix; +} + +// 補間点R0/R1をBDEF2移動させて交点Cを補正する +vec4 calculateCorrectedC(mat4 boneMatrix0, mat4 boneMatrix1, float boneWeight0, float boneWeight1) { + // R0/R1影響係数算出 + float lenR0C = length(sdefR0 - sdefC); + float lenR1C = length(sdefR1 - sdefC); + + float r1Bias = 0.0; + if(lenR1C == 0.0) { + r1Bias = 0.0; + } else if(lenR0C == 0.0) { + r1Bias = 1.0; + } else if(lenR0C + lenR1C != 0.0) { + float bias = lenR0C / (lenR0C + lenR1C); + if(!isinf(bias) && !isnan(bias)) { + r1Bias = clamp(bias, 0.0, 1.0); + } + } + float r0Bias = 1.0 - r1Bias; + + // ウェイトに基づいたC (BDEF2移動させたC) + vec4 weightedC0 = boneMatrix0 * boneWeight0 * vec4(sdefC, 1.0); + vec4 weightedC1 = boneMatrix1 * boneWeight1 * vec4(sdefC, 1.0); + vec4 weightedC = weightedC0 + weightedC1; + + // 影響係数に基づいたR + vec4 biasR0 = boneMatrix0 * r0Bias * vec4(sdefR0, 1.0); + vec4 biasR1 = boneMatrix1 * r1Bias * vec4(sdefR1, 1.0); + vec4 biasR = biasR0 + biasR1; + + // return biasR; + return (weightedC + biasR) * 0.5; +} + +void main() { + vec4 position4 = vec4(position + vertexDelta, 1.0); + + // 各頂点で使用されるボーン変形行列を計算する + totalBoneWeight = 0; + mat4 boneTransformMatrix = mat4(0.0); + mat3 normalTransformMatrix = mat3(1.0); + + // ボーン変形後頂点モーフ変形量 + mat4 afterVertexTransformMatrix = mat4(1.0); + afterVertexTransformMatrix[3] = vec4(afterVertexDelta, 1.0); // 4列目に移動量を設定 + + if(isSdef == 1.0) { + // SDEFの場合は、SDEF用の頂点位置を計算する + + // ボーンインデックスからボーン変形行列を取得 + mat4 boneMatrix0 = getBoneMatrix(int(boneIndexes[0])); + mat4 boneMatrix1 = getBoneMatrix(int(boneIndexes[1])); + + float boneWeight0 = boneWeights[0]; + float boneWeight1 = boneWeights[1]; + + // ボーンの回転を適用して頂点Pを変形させる + mat4 rotationMatrix = calculateSdefMatrix(boneMatrix0, boneMatrix1, boneWeight0, boneWeight1); + + // 補正Cを求める + vec4 correctedC = calculateCorrectedC(boneMatrix0, boneMatrix1, boneWeight0, boneWeight1); + + // 回転行列を使用して頂点を変形 + vec4 rotatedPosition = rotationMatrix * vec4(position, 1.0); + vec4 rotatedC = rotationMatrix * vec4(sdefC, 1.0); + + vec4 vecPosition = rotatedPosition - rotatedC + correctedC; + + // 頂点位置 + gl_Position = modelViewProjectionMatrix * afterVertexTransformMatrix * modelViewMatrix* vec4(vecPosition.xyz, 1.0); + } else { + for(int i = 0; i < 4; i++) { + float boneWeight = boneWeights[i]; + int boneIndex = int(boneIndexes[i]); + + // テクスチャからボーン変形行列を取得する + mat4 boneMatrix = getBoneMatrix(boneIndex); + + // ボーン変形行列を加算する + boneTransformMatrix += boneMatrix * boneWeight; + } + + // 頂点位置 + gl_Position = modelViewProjectionMatrix * afterVertexTransformMatrix * modelViewMatrix * boneTransformMatrix * position4; + } + + // uv1Deltaをボーンカラーとして出力 + boneColor = uv1Delta; +} diff --git a/pkg/mview/glsl/edge.frag b/pkg/mview/glsl/edge.frag new file mode 100644 index 00000000..020f910d --- /dev/null +++ b/pkg/mview/glsl/edge.frag @@ -0,0 +1,12 @@ +#version 440 core + +uniform vec4 edgeColor; +out vec4 outColor; + +void main() { + outColor = edgeColor; + + if (outColor.a < 1e-6) { + discard; + } +} \ No newline at end of file diff --git a/pkg/mview/glsl/edge.vert b/pkg/mview/glsl/edge.vert new file mode 100644 index 00000000..37599960 --- /dev/null +++ b/pkg/mview/glsl/edge.vert @@ -0,0 +1,217 @@ +#version 440 core + +uniform mat4 modelViewProjectionMatrix; +uniform mat4 modelViewMatrix; + +// ボーン変形行列を格納するテクスチャ +uniform sampler2D boneMatrixTexture; +uniform int boneMatrixWidth; +uniform int boneMatrixHeight; + +in layout(location = 0) vec3 position; +in layout(location = 1) vec3 normal; +in layout(location = 2) vec2 uv; +in layout(location = 3) vec2 extendUv; +in layout(location = 4) float vertexEdge; +in layout(location = 5) vec4 boneIndexes; +in layout(location = 6) vec4 boneWeights; +in layout(location = 7) float isSdef; +in layout(location = 8) vec3 sdefC; +in layout(location = 9) vec3 sdefR0; +in layout(location = 10) vec3 sdefR1; +in layout(location = 11) vec3 vertexDelta; // 頂点モーフ +in layout(location = 12) vec4 uvDelta; // UVモーフ +in layout(location = 13) vec4 uv1Delta; // 拡張UV1モーフ +in layout(location = 14) vec3 afterVertexDelta; // ボーン変形後頂点モーフ + +out float totalBoneWeight; + +uniform float edgeSize; + +// 球形補間 +vec4 slerp(vec4 q1, vec4 q2, float t) { + float dot = dot(q1, q2); + + if(dot < 0.0) { + q1 = -q1; // q1の向きを反転させる + dot = -dot; + } + + if(dot > 0.9995) { + // クォータニオンが非常に近い場合は線形補間を使用し、正規化する + vec4 result = q1 + t * (q2 - q1); + return normalize(result); + } + + dot = clamp(dot, -1.0, 1.0); // 数値誤差による範囲外の値を修正 + float theta_0 = acos(dot); // q1とq2の間の角度 + float theta = theta_0 * t; // 現在のtにおける角度 + + vec4 q3 = q2 - q1 * dot; + q3 = normalize(q3); // 正規直交基底を作成 + + return q1 * cos(theta) + q3 * sin(theta); +} + +// mat4からvec4(クォータニオン)への変換 +vec4 mat4ToQuat(mat4 m) { + float tr = m[0][0] + m[1][1] + m[2][2]; + float qw, qx, qy, qz; + if(tr > 0) { + float S = sqrt(tr + 1.0) * 2; // S=4*qw + qw = 0.25 * S; + qx = (m[2][1] - m[1][2]) / S; + qy = (m[0][2] - m[2][0]) / S; + qz = (m[1][0] - m[0][1]) / S; + } else if((m[0][0] > m[1][1]) && (m[0][0] > m[2][2])) { + float S = sqrt(1.0 + m[0][0] - m[1][1] - m[2][2]) * 2; // S=4*qx + qw = (m[2][1] - m[1][2]) / S; + qx = 0.25 * S; + qy = (m[0][1] + m[1][0]) / S; + qz = (m[0][2] + m[2][0]) / S; + } else if(m[1][1] > m[2][2]) { + float S = sqrt(1.0 + m[1][1] - m[0][0] - m[2][2]) * 2; // S=4*qy + qw = (m[0][2] - m[2][0]) / S; + qx = (m[0][1] + m[1][0]) / S; + qy = 0.25 * S; + qz = (m[1][2] + m[2][1]) / S; + } else { + float S = sqrt(1.0 + m[2][2] - m[0][0] - m[1][1]) * 2; // S=4*qz + qw = (m[1][0] - m[0][1]) / S; + qx = (m[0][2] + m[2][0]) / S; + qy = (m[1][2] + m[2][1]) / S; + qz = 0.25 * S; + } + return vec4(qx, qy, qz, qw); +} + +// vec4(クォータニオン)からmat4への変換 +mat4 quatToMat4(vec4 q) { + float x = q.x; + float y = q.y; + float z = q.z; + float w = q.w; + return mat4(1.0 - 2.0 * y * y - 2.0 * z * z, 2.0 * x * y - 2.0 * z * w, 2.0 * x * z + 2.0 * y * w, 0.0, 2.0 * x * y + 2.0 * z * w, 1.0 - 2.0 * x * x - 2.0 * z * z, 2.0 * y * z - 2.0 * x * w, 0.0, 2.0 * x * z - 2.0 * y * w, 2.0 * y * z + 2.0 * x * w, 1.0 - 2.0 * x * x - 2.0 * y * y, 0.0, 0.0, 0.0, 0.0, 1.0); +} + +// テクスチャからボーン変形行列を取得する +mat4 getBoneMatrix(int boneIndex) { + int rowIndex = boneIndex * 4 / boneMatrixWidth; + int colIndex = (boneIndex * 4) - (boneMatrixWidth * rowIndex); + + vec4 row0 = texelFetch(boneMatrixTexture, ivec2(colIndex + 0, rowIndex), 0); + vec4 row1 = texelFetch(boneMatrixTexture, ivec2(colIndex + 1, rowIndex), 0); + vec4 row2 = texelFetch(boneMatrixTexture, ivec2(colIndex + 2, rowIndex), 0); + vec4 row3 = texelFetch(boneMatrixTexture, ivec2(colIndex + 3, rowIndex), 0); + mat4 boneMatrix = mat4(row0, row1, row2, row3); + + return boneMatrix; +} + +// クォータニオンによるボーンの回転を計算し、頂点Pを変形させる +mat4 calculateSdefMatrix(mat4 boneMatrix0, mat4 boneMatrix1, float boneWeight0, float boneWeight1) { + // ボーンのクォータニオン回転を取得 + vec4 boneQuat0 = mat4ToQuat(boneMatrix0); + vec4 boneQuat1 = mat4ToQuat(boneMatrix1); + + // ボーンのウェイトに基づいてクォータニオンをSLERPにより補間 + vec4 slerpedQuat1 = slerp(boneQuat0, boneQuat1, boneWeight1); + + // クォータニオンを回転行列に変換 + mat4 rotationMatrix = quatToMat4(slerpedQuat1); + + return rotationMatrix; +} + +// 補間点R0/R1をBDEF2移動させて交点Cを補正する +vec4 calculateCorrectedC(mat4 boneMatrix0, mat4 boneMatrix1, float boneWeight0, float boneWeight1) { + // R0/R1影響係数算出 + float lenR0C = length(sdefR0 - sdefC); + float lenR1C = length(sdefR1 - sdefC); + + float r1Bias = 0.0; + if(lenR1C == 0.0) { + r1Bias = 0.0; + } else if(lenR0C == 0.0) { + r1Bias = 1.0; + } else if(lenR0C + lenR1C != 0.0) { + float bias = lenR0C / (lenR0C + lenR1C); + if(!isinf(bias) && !isnan(bias)) { + r1Bias = clamp(bias, 0.0, 1.0); + } + } + float r0Bias = 1.0 - r1Bias; + + // ウェイトに基づいたC (BDEF2移動させたC) + vec4 weightedC0 = boneMatrix0 * boneWeight0 * vec4(sdefC, 1.0); + vec4 weightedC1 = boneMatrix1 * boneWeight1 * vec4(sdefC, 1.0); + vec4 weightedC = weightedC0 + weightedC1; + + // 影響係数に基づいたR + vec4 biasR0 = boneMatrix0 * r0Bias * vec4(sdefR0, 1.0); + vec4 biasR1 = boneMatrix1 * r1Bias * vec4(sdefR1, 1.0); + vec4 biasR = biasR0 + biasR1; + + // return biasR; + return (weightedC + biasR) * 0.5; +} + +void main() { + vec4 position4 = vec4(position + vertexDelta, 1.0); + + // 各頂点で使用されるボーン変形行列を計算する + totalBoneWeight = 0; + mat4 boneTransformMatrix = mat4(0.0); + + // ボーン変形後頂点モーフ変形量 + mat4 afterVertexTransformMatrix = mat4(1.0); + afterVertexTransformMatrix[3] = vec4(afterVertexDelta, 1.0); // 4列目に移動量を設定 + + // エッジサイズｘ頂点エッジ倍率ｘモーフ倍率＋モーフバイアス + float edgeWight = edgeSize * vertexEdge; + + if(isSdef == 1.0) { + // SDEFの場合は、SDEF用の頂点位置を計算する + + // ボーンインデックスからボーン変形行列を取得 + mat4 boneMatrix0 = getBoneMatrix(int(boneIndexes[0])); + mat4 boneMatrix1 = getBoneMatrix(int(boneIndexes[1])); + + float boneWeight0 = boneWeights[0]; + float boneWeight1 = boneWeights[1]; + + // ボーンの回転を適用して頂点Pを変形させる + mat4 rotationMatrix = calculateSdefMatrix(boneMatrix0, boneMatrix1, boneWeight0, boneWeight1); + + // 補正Cを求める + vec4 correctedC = calculateCorrectedC(boneMatrix0, boneMatrix1, boneWeight0, boneWeight1); + + // 回転行列を使用して頂点を変形 + vec4 rotatedPosition = rotationMatrix * vec4(position, 1.0); + vec4 rotatedC = rotationMatrix * vec4(sdefC, 1.0); + + vec4 vecPosition = rotatedPosition - rotatedC + correctedC; + + mat3 normalTransformMatrix = mat3(rotationMatrix); + + // 頂点法線 + vec3 vertexNormal = normalize(normalTransformMatrix * normalize(normal)).xyz; + + // 頂点位置 + gl_Position = modelViewProjectionMatrix * afterVertexTransformMatrix * modelViewMatrix * (vec4(vecPosition.xyz + (vertexNormal * edgeWight * 0.02), 1.0)); + } else { + for(int i = 0; i < 4; i++) { + float boneWeight = boneWeights[i]; + int boneIndex = int(boneIndexes[i]); + + // テクスチャからボーン変形行列を取得する + mat4 boneMatrix = getBoneMatrix(boneIndex); + + // ボーン変形行列を加算する + boneTransformMatrix += boneMatrix * boneWeight; + } + + // 頂点位置 + gl_Position = modelViewProjectionMatrix * afterVertexTransformMatrix * modelViewMatrix * boneTransformMatrix * (vec4(position4.xyz + (normal * edgeWight * 0.02), 1.0)); + } +} diff --git a/pkg/mview/glsl/floor.frag b/pkg/mview/glsl/floor.frag new file mode 100644 index 00000000..26683110 --- /dev/null +++ b/pkg/mview/glsl/floor.frag @@ -0,0 +1,8 @@ +#version 440 core + +in vec4 color4; +out vec4 outColor; + +void main() { + outColor = color4; +} \ No newline at end of file diff --git a/pkg/mview/glsl/floor.vert b/pkg/mview/glsl/floor.vert new file mode 100644 index 00000000..c486610b --- /dev/null +++ b/pkg/mview/glsl/floor.vert @@ -0,0 +1,15 @@ +#version 440 core + +uniform mat4 modelViewProjectionMatrix; +uniform mat4 modelViewMatrix; + +in layout(location = 0) vec3 position; +in layout(location = 1) vec4 color; + +out vec4 color4; + +void main() { + gl_Position = modelViewProjectionMatrix * modelViewMatrix * vec4(position, 1.0); + + color4 = color; +} diff --git a/pkg/mview/glsl/model.frag b/pkg/mview/glsl/model.frag new file mode 100644 index 00000000..414dacbb --- /dev/null +++ b/pkg/mview/glsl/model.frag @@ -0,0 +1,70 @@ +#version 440 core + +uniform int useTexture; +uniform sampler2D textureSampler; + +uniform int useToon; +uniform sampler2D toonSampler; + +uniform int useSphere; +uniform int sphereMode; +uniform sampler2D sphereSampler; + +uniform vec3 lightDirection; +uniform vec4 textureMulFactor; +uniform vec4 textureAddFactor; +uniform vec4 sphereMulFactor; +uniform vec4 sphereAddFactor; +uniform vec4 toonMulFactor; +uniform vec4 toonAddFactor; + +in vec4 vertexColor; +in vec3 vertexSpecular; +in vec2 vertexUv; +in vec3 vertexNormal; +in vec2 sphereUv; +in vec3 eye; +in float totalBoneWeight; + +out vec4 outColor; + +void main() { + outColor = vertexColor; + + if (1 == useTexture) { + // テクスチャ適用 + vec4 texColor = texture(textureSampler, vertexUv); + // texColor = texColor * textureMulFactor + textureAddFactor; + outColor *= texColor; + } + + if (1 == useSphere) { + // Sphere適用 + vec4 sphColor = texture(sphereSampler, sphereUv); + // sphColor = sphColor * sphereMulFactor + sphereAddFactor; + if (2 == sphereMode) { + // スフィア加算 + outColor.rgb += sphColor.rgb; + } + else { + // スフィア乗算 + outColor.rgb *= sphColor.rgb; + } + outColor.a *= sphColor.a; + } + + if (1 == useToon) { + // Toon適用 + float lightNormal = dot( vertexNormal, -lightDirection ); + vec4 toonColor = texture(toonSampler, vec2(0, 0.5 - lightNormal * 0.5)); + // toonColor = toonColor * toonMulFactor + toonAddFactor; + outColor *= toonColor; + } + + if (outColor.a < 1e-6) { + discard; + } + + // スペキュラ適用 + outColor.rgb += vertexSpecular; +} \ No newline at end of file diff --git a/pkg/mview/glsl/model.vert b/pkg/mview/glsl/model.vert new file mode 100644 index 00000000..92f93fcd --- /dev/null +++ b/pkg/mview/glsl/model.vert @@ -0,0 +1,268 @@ +#version 440 core + +uniform mat4 modelViewProjectionMatrix; +uniform mat4 modelViewMatrix; + +// ボーン変形行列を格納するテクスチャ +uniform sampler2D boneMatrixTexture; +uniform int boneMatrixWidth; +uniform int boneMatrixHeight; + +in layout(location = 0) vec3 position; +in layout(location = 1) vec3 normal; +in layout(location = 2) vec2 uv; +in layout(location = 3) vec2 extendUv; +in layout(location = 4) float vertexEdge; +in layout(location = 5) vec4 boneIndexes; +in layout(location = 6) vec4 boneWeights; +in layout(location = 7) float isSdef; +in layout(location = 8) vec3 sdefC; +in layout(location = 9) vec3 sdefR0; +in layout(location = 10) vec3 sdefR1; +in layout(location = 11) vec3 vertexDelta; // 頂点モーフ +in layout(location = 12) vec4 uvDelta; // UVモーフ +in layout(location = 13) vec4 uv1Delta; // 拡張UV1モーフ +in layout(location = 14) vec3 afterVertexDelta; // ボーン変形後頂点モーフ + +uniform vec4 diffuse; +uniform vec3 ambient; +uniform vec4 specular; + +uniform vec3 cameraPosition; +uniform vec3 lightDirection; + +uniform int useToon; +uniform int useSphere; +uniform int sphereMode; + +out vec4 vertexColor; +out vec3 vertexSpecular; +out vec2 vertexUv; +out vec3 vertexNormal; +out vec2 sphereUv; +out vec3 eye; +out float totalBoneWeight; + +// 球形補間 +vec4 slerp(vec4 q1, vec4 q2, float t) { + float dot = dot(q1, q2); + + if(dot < 0.0) { + q1 = -q1; // q1の向きを反転させる + dot = -dot; + } + + if(dot > 0.9995) { + // クォータニオンが非常に近い場合は線形補間を使用し、正規化する + vec4 result = q1 + t * (q2 - q1); + return normalize(result); + } + + dot = clamp(dot, -1.0, 1.0); // 数値誤差による範囲外の値を修正 + float theta_0 = acos(dot); // q1とq2の間の角度 + float theta = theta_0 * t; // 現在のtにおける角度 + + vec4 q3 = q2 - q1 * dot; + q3 = normalize(q3); // 正規直交基底を作成 + + return q1 * cos(theta) + q3 * sin(theta); +} + +// mat4からvec4(クォータニオン)への変換 +vec4 mat4ToQuat(mat4 m) { + float tr = m[0][0] + m[1][1] + m[2][2]; + float qw, qx, qy, qz; + if(tr > 0) { + float S = sqrt(tr + 1.0) * 2; // S=4*qw + qw = 0.25 * S; + qx = (m[2][1] - m[1][2]) / S; + qy = (m[0][2] - m[2][0]) / S; + qz = (m[1][0] - m[0][1]) / S; + } else if((m[0][0] > m[1][1]) && (m[0][0] > m[2][2])) { + float S = sqrt(1.0 + m[0][0] - m[1][1] - m[2][2]) * 2; // S=4*qx + qw = (m[2][1] - m[1][2]) / S; + qx = 0.25 * S; + qy = (m[0][1] + m[1][0]) / S; + qz = (m[0][2] + m[2][0]) / S; + } else if(m[1][1] > m[2][2]) { + float S = sqrt(1.0 + m[1][1] - m[0][0] - m[2][2]) * 2; // S=4*qy + qw = (m[0][2] - m[2][0]) / S; + qx = (m[0][1] + m[1][0]) / S; + qy = 0.25 * S; + qz = (m[1][2] + m[2][1]) / S; + } else { + float S = sqrt(1.0 + m[2][2] - m[0][0] - m[1][1]) * 2; // S=4*qz + qw = (m[1][0] - m[0][1]) / S; + qx = (m[0][2] + m[2][0]) / S; + qy = (m[1][2] + m[2][1]) / S; + qz = 0.25 * S; + } + return vec4(qx, qy, qz, qw); +} + +// vec4(クォータニオン)からmat4への変換 +mat4 quatToMat4(vec4 q) { + float x = q.x; + float y = q.y; + float z = q.z; + float w = q.w; + return mat4(1.0 - 2.0 * y * y - 2.0 * z * z, 2.0 * x * y - 2.0 * z * w, 2.0 * x * z + 2.0 * y * w, 0.0, 2.0 * x * y + 2.0 * z * w, 1.0 - 2.0 * x * x - 2.0 * z * z, 2.0 * y * z - 2.0 * x * w, 0.0, 2.0 * x * z - 2.0 * y * w, 2.0 * y * z + 2.0 * x * w, 1.0 - 2.0 * x * x - 2.0 * y * y, 0.0, 0.0, 0.0, 0.0, 1.0); +} + +// テクスチャからボーン変形行列を取得する +mat4 getBoneMatrix(int boneIndex) { + int rowIndex = boneIndex * 4 / boneMatrixWidth; + int colIndex = (boneIndex * 4) - (boneMatrixWidth * rowIndex); + + vec4 row0 = texelFetch(boneMatrixTexture, ivec2(colIndex + 0, rowIndex), 0); + vec4 row1 = texelFetch(boneMatrixTexture, ivec2(colIndex + 1, rowIndex), 0); + vec4 row2 = texelFetch(boneMatrixTexture, ivec2(colIndex + 2, rowIndex), 0); + vec4 row3 = texelFetch(boneMatrixTexture, ivec2(colIndex + 3, rowIndex), 0); + mat4 boneMatrix = mat4(row0, row1, row2, row3); + + return boneMatrix; +} + +// クォータニオンによるボーンの回転を計算し、頂点Pを変形させる +mat4 calculateSdefMatrix(mat4 boneMatrix0, mat4 boneMatrix1, float boneWeight0, float boneWeight1) { + // ボーンのクォータニオン回転を取得 + vec4 boneQuat0 = mat4ToQuat(boneMatrix0); + vec4 boneQuat1 = mat4ToQuat(boneMatrix1); + + // ボーンのウェイトに基づいてクォータニオンをSLERPにより補間 + vec4 slerpedQuat1 = slerp(boneQuat0, boneQuat1, boneWeight1); + + // クォータニオンを回転行列に変換 + mat4 rotationMatrix = quatToMat4(slerpedQuat1); + + return rotationMatrix; +} + +// 補間点R0/R1をBDEF2移動させて交点Cを補正する +vec4 calculateCorrectedC(mat4 boneMatrix0, mat4 boneMatrix1, float boneWeight0, float boneWeight1) { + // R0/R1影響係数算出 + float lenR0C = length(sdefR0 - sdefC); + float lenR1C = length(sdefR1 - sdefC); + + float r1Bias = 0.0; + if(lenR1C == 0.0) { + r1Bias = 0.0; + } else if(lenR0C == 0.0) { + r1Bias = 1.0; + } else if(lenR0C + lenR1C != 0.0) { + float bias = lenR0C / (lenR0C + lenR1C); + if(!isinf(bias) && !isnan(bias)) { + r1Bias = clamp(bias, 0.0, 1.0); + } + } + float r0Bias = 1.0 - r1Bias; + + // ウェイトに基づいたC (BDEF2移動させたC) + vec4 weightedC0 = boneMatrix0 * boneWeight0 * vec4(sdefC, 1.0); + vec4 weightedC1 = boneMatrix1 * boneWeight1 * vec4(sdefC, 1.0); + vec4 weightedC = weightedC0 + weightedC1; + + // 影響係数に基づいたR + vec4 biasR0 = boneMatrix0 * r0Bias * vec4(sdefR0, 1.0); + vec4 biasR1 = boneMatrix1 * r1Bias * vec4(sdefR1, 1.0); + vec4 biasR = biasR0 + biasR1; + + // return biasR; + return (weightedC + biasR) * 0.5; +} + +void main() { + vec4 position4 = vec4(position + vertexDelta, 1.0); + + // 各頂点で使用されるボーン変形行列を計算する + totalBoneWeight = 0; + mat4 boneTransformMatrix = mat4(0.0); + mat3 normalTransformMatrix = mat3(1.0); + + // ボーン変形後頂点モーフ変形量 + mat4 afterVertexTransformMatrix = mat4(1.0); + afterVertexTransformMatrix[3] = vec4(afterVertexDelta, 1.0); // 4列目に移動量を設定 + + if(isSdef == 1.0) { + // SDEFの場合は、SDEF用の頂点位置を計算する + + // ボーンインデックスからボーン変形行列を取得 + mat4 boneMatrix0 = getBoneMatrix(int(boneIndexes[0])); + mat4 boneMatrix1 = getBoneMatrix(int(boneIndexes[1])); + + float boneWeight0 = boneWeights[0]; + float boneWeight1 = boneWeights[1]; + + // ボーンの回転を適用して頂点Pを変形させる + mat4 rotationMatrix = calculateSdefMatrix(boneMatrix0, boneMatrix1, boneWeight0, boneWeight1); + + // 補正Cを求める + vec4 correctedC = calculateCorrectedC(boneMatrix0, boneMatrix1, boneWeight0, boneWeight1); + + // 回転行列を使用して頂点を変形 + vec4 rotatedPosition = rotationMatrix * vec4(position, 1.0); + vec4 rotatedC = rotationMatrix * vec4(sdefC, 1.0); + + vec4 vecPosition = rotatedPosition - rotatedC + correctedC; + + gl_Position = modelViewProjectionMatrix * afterVertexTransformMatrix * modelViewMatrix * vec4(vecPosition.xyz, 1.0); + + // 各頂点で使用される法線変形行列をSDEF変形行列から回転情報のみ抽出して生成する + normalTransformMatrix = mat3(rotationMatrix); + } else { + for(int i = 0; i < 4; i++) { + float boneWeight = boneWeights[i]; + int boneIndex = int(boneIndexes[i]); + + // テクスチャからボーン変形行列を取得する + mat4 boneMatrix = getBoneMatrix(boneIndex); + + // ボーン変形行列を加算する + boneTransformMatrix += boneMatrix * boneWeight; + } + + gl_Position = modelViewProjectionMatrix * afterVertexTransformMatrix * modelViewMatrix * boneTransformMatrix * position4; + + // 各頂点で使用される法線変形行列をボーン変形行列から回転情報のみ抽出して生成する + normalTransformMatrix = mat3(boneTransformMatrix); + } + + // 頂点法線 + vertexNormal = normalize(normalTransformMatrix * normalize(normal)).xyz; + + // 頂点色設定 + vertexColor = diffuse; + + if(0 == useToon) { + // ディフューズ色＋アンビエント色 計算 + float lightNormal = clamp(dot(vertexNormal, -lightDirection), 0.0, 1.0); + vertexColor.rgb += ambient * lightNormal; + } + + vertexColor.a = diffuse.a; + vertexColor = clamp(vertexColor, 0.0, 1.0); + + // テクスチャ描画位置 + vertexUv = uv + uvDelta.xy; + + if(1 == useSphere) { + // Sphereマップ計算 + if(3 == sphereMode) { + // PMXサブテクスチャ座標 + sphereUv = extendUv; + } else { + // スフィアマップテクスチャ座標 + vec3 normalWv = mat3(modelViewMatrix) * vertexNormal; + sphereUv.x = normalWv.x * 0.5 + 0.5; + sphereUv.y = normalWv.y * -0.5 + 0.5; + } + sphereUv += uv1Delta.xy; + } + + // カメラとの相対位置 + vec3 eye = cameraPosition - (boneTransformMatrix * position4).xyz; + + // スペキュラ色計算 + vec3 HalfVector = normalize(normalize(eye) + -lightDirection); + vertexSpecular = pow(max(0, dot(HalfVector, vertexNormal)), max(0.000001, specular.w)) * specular.rgb; +} diff --git a/pkg/mview/glsl/physics.frag b/pkg/mview/glsl/physics.frag new file mode 100644 index 00000000..26683110 --- /dev/null +++ b/pkg/mview/glsl/physics.frag @@ -0,0 +1,8 @@ +#version 440 core + +in vec4 color4; +out vec4 outColor; + +void main() { + outColor = color4; +} \ No newline at end of file diff --git a/pkg/mview/glsl/physics.vert b/pkg/mview/glsl/physics.vert new file mode 100644 index 00000000..c486610b --- /dev/null +++ b/pkg/mview/glsl/physics.vert @@ -0,0 +1,15 @@ +#version 440 core + +uniform mat4 modelViewProjectionMatrix; +uniform mat4 modelViewMatrix; + +in layout(location = 0) vec3 position; +in layout(location = 1) vec4 color; + +out vec4 color4; + +void main() { + gl_Position = modelViewProjectionMatrix * modelViewMatrix * vec4(position, 1.0); + + color4 = color; +} diff --git a/pkg/mview/glsl/vertex.frag b/pkg/mview/glsl/vertex.frag new file mode 100644 index 00000000..901077e6 --- /dev/null +++ b/pkg/mview/glsl/vertex.frag @@ -0,0 +1,16 @@ +#version 440 core + +uniform vec4 color; + +in float vertexUvX; + +out vec4 outColor; + +void main() { + if (vertexUvX < 0) { + // UVのXが明示的にマイナスの場合、描画しない + discard; + } + + outColor = color; +} \ No newline at end of file diff --git a/pkg/mview/glsl/vertex.vert b/pkg/mview/glsl/vertex.vert new file mode 100644 index 00000000..6a405c2c --- /dev/null +++ b/pkg/mview/glsl/vertex.vert @@ -0,0 +1,221 @@ +#version 440 core + +uniform mat4 modelViewProjectionMatrix; +uniform mat4 modelViewMatrix; + +// ボーン変形行列を格納するテクスチャ +uniform sampler2D boneMatrixTexture; +uniform int boneMatrixWidth; +uniform int boneMatrixHeight; + +in layout(location = 0) vec3 position; +in layout(location = 1) vec3 normal; +in layout(location = 2) vec2 uv; +in layout(location = 3) vec2 extendUv; +in layout(location = 4) float vertexEdge; +in layout(location = 5) vec4 boneIndexes; +in layout(location = 6) vec4 boneWeights; +in layout(location = 7) float isSdef; +in layout(location = 8) vec3 sdefC; +in layout(location = 9) vec3 sdefR0; +in layout(location = 10) vec3 sdefR1; +in layout(location = 11) vec3 vertexDelta; // 頂点モーフ +in layout(location = 12) vec4 uvDelta; // UVモーフ +in layout(location = 13) vec4 uv1Delta; // 拡張UV1モーフ +in layout(location = 14) vec3 afterVertexDelta; // ボーン変形後頂点モーフ + +layout(std430, binding = 0) buffer VertexBuffer { + vec4 positions[]; +}; + +out float totalBoneWeight; +out float vertexUvX; + +// 球形補間 +vec4 slerp(vec4 q1, vec4 q2, float t) { + float dot = dot(q1, q2); + + if(dot < 0.0) { + q1 = -q1; // q1の向きを反転させる + dot = -dot; + } + + if(dot > 0.9995) { + // クォータニオンが非常に近い場合は線形補間を使用し、正規化する + vec4 result = q1 + t * (q2 - q1); + return normalize(result); + } + + dot = clamp(dot, -1.0, 1.0); // 数値誤差による範囲外の値を修正 + float theta_0 = acos(dot); // q1とq2の間の角度 + float theta = theta_0 * t; // 現在のtにおける角度 + + vec4 q3 = q2 - q1 * dot; + q3 = normalize(q3); // 正規直交基底を作成 + + return q1 * cos(theta) + q3 * sin(theta); +} + +// mat4からvec4(クォータニオン)への変換 +vec4 mat4ToQuat(mat4 m) { + float tr = m[0][0] + m[1][1] + m[2][2]; + float qw, qx, qy, qz; + if(tr > 0) { + float S = sqrt(tr + 1.0) * 2; // S=4*qw + qw = 0.25 * S; + qx = (m[2][1] - m[1][2]) / S; + qy = (m[0][2] - m[2][0]) / S; + qz = (m[1][0] - m[0][1]) / S; + } else if((m[0][0] > m[1][1]) && (m[0][0] > m[2][2])) { + float S = sqrt(1.0 + m[0][0] - m[1][1] - m[2][2]) * 2; // S=4*qx + qw = (m[2][1] - m[1][2]) / S; + qx = 0.25 * S; + qy = (m[0][1] + m[1][0]) / S; + qz = (m[0][2] + m[2][0]) / S; + } else if(m[1][1] > m[2][2]) { + float S = sqrt(1.0 + m[1][1] - m[0][0] - m[2][2]) * 2; // S=4*qy + qw = (m[0][2] - m[2][0]) / S; + qx = (m[0][1] + m[1][0]) / S; + qy = 0.25 * S; + qz = (m[1][2] + m[2][1]) / S; + } else { + float S = sqrt(1.0 + m[2][2] - m[0][0] - m[1][1]) * 2; // S=4*qz + qw = (m[1][0] - m[0][1]) / S; + qx = (m[0][2] + m[2][0]) / S; + qy = (m[1][2] + m[2][1]) / S; + qz = 0.25 * S; + } + return vec4(qx, qy, qz, qw); +} + +// vec4(クォータニオン)からmat4への変換 +mat4 quatToMat4(vec4 q) { + float x = q.x; + float y = q.y; + float z = q.z; + float w = q.w; + return mat4(1.0 - 2.0 * y * y - 2.0 * z * z, 2.0 * x * y - 2.0 * z * w, 2.0 * x * z + 2.0 * y * w, 0.0, 2.0 * x * y + 2.0 * z * w, 1.0 - 2.0 * x * x - 2.0 * z * z, 2.0 * y * z - 2.0 * x * w, 0.0, 2.0 * x * z - 2.0 * y * w, 2.0 * y * z + 2.0 * x * w, 1.0 - 2.0 * x * x - 2.0 * y * y, 0.0, 0.0, 0.0, 0.0, 1.0); +} + +// テクスチャからボーン変形行列を取得する +mat4 getBoneMatrix(int boneIndex) { + int rowIndex = boneIndex * 4 / boneMatrixWidth; + int colIndex = (boneIndex * 4) - (boneMatrixWidth * rowIndex); + + vec4 row0 = texelFetch(boneMatrixTexture, ivec2(colIndex + 0, rowIndex), 0); + vec4 row1 = texelFetch(boneMatrixTexture, ivec2(colIndex + 1, rowIndex), 0); + vec4 row2 = texelFetch(boneMatrixTexture, ivec2(colIndex + 2, rowIndex), 0); + vec4 row3 = texelFetch(boneMatrixTexture, ivec2(colIndex + 3, rowIndex), 0); + mat4 boneMatrix = mat4(row0, row1, row2, row3); + + return boneMatrix; +} + +// クォータニオンによるボーンの回転を計算し、頂点Pを変形させる +mat4 calculateSdefMatrix(mat4 boneMatrix0, mat4 boneMatrix1, float boneWeight0, float boneWeight1) { + // ボーンのクォータニオン回転を取得 + vec4 boneQuat0 = mat4ToQuat(boneMatrix0); + vec4 boneQuat1 = mat4ToQuat(boneMatrix1); + + // ボーンのウェイトに基づいてクォータニオンをSLERPにより補間 + vec4 slerpedQuat1 = slerp(boneQuat0, boneQuat1, boneWeight1); + + // クォータニオンを回転行列に変換 + mat4 rotationMatrix = quatToMat4(slerpedQuat1); + + return rotationMatrix; +} + +// 補間点R0/R1をBDEF2移動させて交点Cを補正する +vec4 calculateCorrectedC(mat4 boneMatrix0, mat4 boneMatrix1, float boneWeight0, float boneWeight1) { + // R0/R1影響係数算出 + float lenR0C = length(sdefR0 - sdefC); + float lenR1C = length(sdefR1 - sdefC); + + float r1Bias = 0.0; + if(lenR1C == 0.0) { + r1Bias = 0.0; + } else if(lenR0C == 0.0) { + r1Bias = 1.0; + } else if(lenR0C + lenR1C != 0.0) { + float bias = lenR0C / (lenR0C + lenR1C); + if(!isinf(bias) && !isnan(bias)) { + r1Bias = clamp(bias, 0.0, 1.0); + } + } + float r0Bias = 1.0 - r1Bias; + + // ウェイトに基づいたC (BDEF2移動させたC) + vec4 weightedC0 = boneMatrix0 * boneWeight0 * vec4(sdefC, 1.0); + vec4 weightedC1 = boneMatrix1 * boneWeight1 * vec4(sdefC, 1.0); + vec4 weightedC = weightedC0 + weightedC1; + + // 影響係数に基づいたR + vec4 biasR0 = boneMatrix0 * r0Bias * vec4(sdefR0, 1.0); + vec4 biasR1 = boneMatrix1 * r1Bias * vec4(sdefR1, 1.0); + vec4 biasR = biasR0 + biasR1; + + // return biasR; + return (weightedC + biasR) * 0.5; +} + +void main() { + vec4 position4 = vec4(position + vertexDelta, 1.0); + + // 各頂点で使用されるボーン変形行列を計算する + totalBoneWeight = 0; + mat4 boneTransformMatrix = mat4(0.0); + mat3 normalTransformMatrix = mat3(1.0); + + // ボーン変形後頂点モーフ変形量 + mat4 afterVertexTransformMatrix = mat4(1.0); + afterVertexTransformMatrix[3] = vec4(afterVertexDelta, 1.0); // 4列目に移動量を設定 + + if(isSdef == 1.0) { + // SDEFの場合は、SDEF用の頂点位置を計算する + + // ボーンインデックスからボーン変形行列を取得 + mat4 boneMatrix0 = getBoneMatrix(int(boneIndexes[0])); + mat4 boneMatrix1 = getBoneMatrix(int(boneIndexes[1])); + + float boneWeight0 = boneWeights[0]; + float boneWeight1 = boneWeights[1]; + + // ボーンの回転を適用して頂点Pを変形させる + mat4 rotationMatrix = calculateSdefMatrix(boneMatrix0, boneMatrix1, boneWeight0, boneWeight1); + + // 補正Cを求める + vec4 correctedC = calculateCorrectedC(boneMatrix0, boneMatrix1, boneWeight0, boneWeight1); + + // 回転行列を使用して頂点を変形 + vec4 rotatedPosition = rotationMatrix * vec4(position, 1.0); + vec4 rotatedC = rotationMatrix * vec4(sdefC, 1.0); + + vec4 vecPosition = rotatedPosition - rotatedC + correctedC; + + // 頂点位置 + gl_Position = modelViewProjectionMatrix * afterVertexTransformMatrix * modelViewMatrix * vec4(vecPosition.xyz, 1.0); + + // SDEF結果頂点位置を格納 + positions[gl_VertexID] = vec4(vecPosition.xyz, 1.0); + } else { + for(int i = 0; i < 4; i++) { + float boneWeight = boneWeights[i]; + int boneIndex = int(boneIndexes[i]); + + // テクスチャからボーン変形行列を取得する + mat4 boneMatrix = getBoneMatrix(boneIndex); + + // ボーン変形行列を加算する + boneTransformMatrix += boneMatrix * boneWeight; + } + + // 頂点位置 + gl_Position = modelViewProjectionMatrix * afterVertexTransformMatrix * modelViewMatrix * boneTransformMatrix * position4; + + // ボーン変形行列を加味した頂点位置を格納 + positions[gl_VertexID] = boneTransformMatrix * position4; + } + + vertexUvX = uv.x * uvDelta.x; +} diff --git a/pkg/mview/ibo.go b/pkg/mview/ibo.go new file mode 100644 index 00000000..50e6f771 --- /dev/null +++ b/pkg/mview/ibo.go @@ -0,0 +1,46 @@ +//go:build windows +// +build windows + +package mview + +import ( + "unsafe" + + "github.com/go-gl/gl/v4.4-core/gl" +) + +type IBO struct { + id uint32 // ID + target uint32 // gl.ELEMENT_ARRAY_BUFFER + size int // 一面のbyte数 + facePtr unsafe.Pointer // facePtr +} + +func NewIBO(facePtr unsafe.Pointer, count int) *IBO { + var iboId uint32 + + gl.GenBuffers(1, &iboId) + + ibo := &IBO{ + id: iboId, + target: gl.ELEMENT_ARRAY_BUFFER, + facePtr: facePtr, + size: count * 4, // ひとつの面につき、dtype(UNSIGNED_INT) + } + + return ibo +} + +func (ibo *IBO) Bind() { + gl.BindBuffer(ibo.target, ibo.id) + gl.BufferData(ibo.target, ibo.size, ibo.facePtr, gl.STATIC_DRAW) + CheckGLError() +} + +func (ibo *IBO) Unbind() { + gl.BindBuffer(ibo.target, 0) +} + +func (ibo *IBO) Delete() { + gl.DeleteBuffers(1, &ibo.id) +} diff --git a/pkg/mview/msaa.go b/pkg/mview/msaa.go new file mode 100644 index 00000000..90f28de5 --- /dev/null +++ b/pkg/mview/msaa.go @@ -0,0 +1,141 @@ +//go:build windows +// +build windows + +package mview + +import ( + "github.com/go-gl/gl/v4.4-core/gl" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" +) + +type Msaa struct { + width int32 + height int32 + msaa_samples int32 + msFBO uint32 + resolveFBO uint32 + colorBuffer uint32 + depthBuffer uint32 + colorBufferMS uint32 + depthBufferMS uint32 +} + +func NewMsaa(width int32, height int32) *Msaa { + msaa := &Msaa{ + width: width, + height: height, + msaa_samples: 4, + } + + // 深度テストの有効化 + gl.Enable(gl.DEPTH_TEST) + gl.DepthFunc(gl.LEQUAL) + + // マルチサンプルフレームバッファの作成 + gl.GenFramebuffers(1, &msaa.msFBO) + gl.BindFramebuffer(gl.FRAMEBUFFER, msaa.msFBO) + + // マルチサンプルカラーおよび深度バッファの作成 + gl.GenRenderbuffers(1, &msaa.colorBufferMS) + gl.BindRenderbuffer(gl.RENDERBUFFER, msaa.colorBufferMS) + gl.RenderbufferStorageMultisample(gl.RENDERBUFFER, msaa.msaa_samples, gl.RGBA8, int32(msaa.width), int32(msaa.height)) + gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, msaa.colorBufferMS) + + gl.GenRenderbuffers(1, &msaa.depthBufferMS) + gl.BindRenderbuffer(gl.RENDERBUFFER, msaa.depthBufferMS) + gl.RenderbufferStorageMultisample(gl.RENDERBUFFER, msaa.msaa_samples, gl.DEPTH_COMPONENT24, int32(msaa.width), int32(msaa.height)) + gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, msaa.depthBufferMS) + + if gl.CheckFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE { + mlog.F("Multisample Framebuffer is not complete") + } + + // アンバインド + gl.BindFramebuffer(gl.FRAMEBUFFER, 0) + + return msaa +} + +func (m *Msaa) ReadDepthAt(x, y, width, height int) float32 { + // シングルサンプルFBOから読み取る + gl.BindFramebuffer(gl.FRAMEBUFFER, m.resolveFBO) + if status := gl.CheckFramebufferStatus(gl.FRAMEBUFFER); status != gl.FRAMEBUFFER_COMPLETE { + mlog.E("Framebuffer is not complete: %v", status) + } + + var depth float32 + // yは下が0なので、上下反転 + gl.ReadPixels(int32(x), int32(height-y), 1, 1, gl.DEPTH_COMPONENT, gl.FLOAT, gl.Ptr(&depth)) + + // // エラーが発生していないかチェック + // if err := gl.GetError(); err != gl.NO_ERROR { + // mlog.E("OpenGL Error after ReadPixels: %v", err) + // } + + // mlog.D("Depth at (%d, %d): %f", x, y, depth) + + // // フレームバッファの内容を画像ファイルとして保存 + // pixels := readFramebuffer(int32(m.width), int32(m.height)) + // err := saveImage("framebuffer_output.png", int32(m.width), int32(m.height), pixels) + // if err != nil { + // mlog.E("Failed to save framebuffer image: %v", err) + // } + + // フレームバッファをアンバインド + m.Unbind() + + return depth +} + +// func readFramebuffer(w, h int32) []byte { +// pixels := make([]byte, w*h*4) // RGBA形式で4バイト/ピクセル +// gl.ReadPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(pixels)) +// return pixels +// } + +// func saveImage(filename string, w, h int32, pixels []byte) error { +// img := image.NewRGBA(image.Rect(0, 0, int(w), int(h))) +// for y := int32(0); y < h; y++ { +// for x := int32(0); x < w; x++ { +// i := (y*w + x) * 4 +// r := pixels[i] +// g := pixels[i+1] +// b := pixels[i+2] +// a := pixels[i+3] +// img.SetRGBA(int(x), int(h-y-1), color.RGBA{r, g, b, a}) // 画像の上下を反転 +// } +// } +// file, err := os.Create(filename) +// if err != nil { +// return err +// } +// defer file.Close() +// return png.Encode(file, img) +// } + +func (m *Msaa) Bind() { + gl.BindFramebuffer(gl.FRAMEBUFFER, m.msFBO) + gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) +} + +func (m *Msaa) Unbind() { + gl.BindFramebuffer(gl.FRAMEBUFFER, 0) + gl.BindFramebuffer(gl.READ_FRAMEBUFFER, 0) + gl.BindFramebuffer(gl.DRAW_FRAMEBUFFER, 0) +} + +func (m *Msaa) Resolve() { + gl.BindFramebuffer(gl.READ_FRAMEBUFFER, m.msFBO) + gl.BindFramebuffer(gl.DRAW_FRAMEBUFFER, m.resolveFBO) + gl.BlitFramebuffer(0, 0, int32(m.width), int32(m.height), 0, 0, int32(m.width), int32(m.height), + gl.COLOR_BUFFER_BIT|gl.DEPTH_BUFFER_BIT, gl.NEAREST) +} + +func (m *Msaa) Delete() { + gl.DeleteFramebuffers(1, &m.msFBO) + gl.DeleteFramebuffers(1, &m.resolveFBO) + gl.DeleteRenderbuffers(1, &m.colorBuffer) + gl.DeleteRenderbuffers(1, &m.depthBuffer) + gl.DeleteRenderbuffers(1, &m.colorBufferMS) + gl.DeleteRenderbuffers(1, &m.depthBufferMS) +} diff --git a/pkg/mview/shader.go b/pkg/mview/shader.go new file mode 100644 index 00000000..098fe528 --- /dev/null +++ b/pkg/mview/shader.go @@ -0,0 +1,410 @@ +//go:build windows +// +build windows + +package mview + +import ( + "embed" + "fmt" + "io/fs" + "strings" + + "github.com/go-gl/gl/v4.4-core/gl" + "github.com/go-gl/mathgl/mgl32" + + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +const ( + SHADER_BONE_MATRIX_TEXTURE = "boneMatrixTexture\x00" + SHADER_BONE_MATRIX_TEXTURE_WIDTH = "boneMatrixWidth\x00" + SHADER_BONE_MATRIX_TEXTURE_HEIGHT = "boneMatrixHeight\x00" + SHADER_MODEL_VIEW_MATRIX = "modelViewMatrix\x00" + SHADER_MODEL_VIEW_PROJECTION_MATRIX = "modelViewProjectionMatrix\x00" + SHADER_CAMERA_POSITION = "cameraPosition\x00" + SHADER_LIGHT_DIRECTION = "lightDirection\x00" + SHADER_DIFFUSE = "diffuse\x00" + SHADER_AMBIENT = "ambient\x00" + SHADER_SPECULAR = "specular\x00" + SHADER_TEXTURE_SAMPLER = "textureSampler\x00" + SHADER_TOON_SAMPLER = "toonSampler\x00" + SHADER_SPHERE_SAMPLER = "sphereSampler\x00" + SHADER_USE_TEXTURE = "useTexture\x00" + SHADER_USE_TOON = "useToon\x00" + SHADER_USE_SPHERE = "useSphere\x00" + SHADER_SPHERE_MODE = "sphereMode\x00" + SHADER_MORPH_TEXTURE_FACTOR = "textureFactor\x00" + SHADER_MORPH_TOON_FACTOR = "toonFactor\x00" + SHADER_MORPH_SPHERE_FACTOR = "sphereFactor\x00" + SHADER_COLOR = "color\x00" + SHADER_ALPHA = "alpha\x00" + SHADER_EDGE_COLOR = "edgeColor\x00" + SHADER_EDGE_SIZE = "edgeSize\x00" + SHADER_TEXTURE_MUL_FACTOR = "textureMulFactor\x00" + SHADER_TEXTURE_ADD_FACTOR = "textureAddFactor\x00" + SHADER_SPHERE_MUL_FACTOR = "sphereMulFactor\x00" + SHADER_SPHERE_ADD_FACTOR = "sphereAddFactor\x00" + SHADER_TOON_MUL_FACTOR = "toonMulFactor\x00" + SHADER_TOON_ADD_FACTOR = "toonAddFactor\x00" + SHADER_VERTEX_GL_POSITION = "gl_Position\x00" +) + +type ProgramType int + +const ( + PROGRAM_TYPE_MODEL ProgramType = iota + PROGRAM_TYPE_EDGE ProgramType = iota + PROGRAM_TYPE_BONE ProgramType = iota + PROGRAM_TYPE_PHYSICS ProgramType = iota + PROGRAM_TYPE_NORMAL ProgramType = iota + PROGRAM_TYPE_FLOOR ProgramType = iota + PROGRAM_TYPE_WIRE ProgramType = iota + PROGRAM_TYPE_SELECTED_VERTEX ProgramType = iota +) + +const ( + INITIAL_CAMERA_POSITION_Y float64 = 11.0 + INITIAL_CAMERA_POSITION_Z float64 = -40.0 + INITIAL_LOOK_AT_CENTER_Y float64 = 11.0 + LIGHT_AMBIENT float64 = 154.0 / 255.0 + FIELD_OF_VIEW_ANGLE float32 = 40.0 +) + +type MShader struct { + lightAmbient *mmath.MVec4 + CameraPosition *mmath.MVec3 + LookAtCenterPosition *mmath.MVec3 + FieldOfViewAngle float32 + Width int32 + Height int32 + NearPlane float32 + FarPlane float32 + lightPosition *mmath.MVec3 + lightDirection *mmath.MVec3 + Msaa *Msaa + ModelProgram uint32 + EdgeProgram uint32 + BoneProgram uint32 + PhysicsProgram uint32 + NormalProgram uint32 + FloorProgram uint32 + WireProgram uint32 + SelectedVertexProgram uint32 + BoneTextureId uint32 + IsDrawRigidBodyFront bool +} + +//go:embed glsl/* +var glslFiles embed.FS + +func NewMShader(width, height int) (*MShader, error) { + shader := &MShader{ + lightAmbient: &mmath.MVec4{LIGHT_AMBIENT, LIGHT_AMBIENT, LIGHT_AMBIENT, 1}, + CameraPosition: &mmath.MVec3{0.0, INITIAL_CAMERA_POSITION_Y, INITIAL_CAMERA_POSITION_Z}, + LookAtCenterPosition: &mmath.MVec3{0.0, INITIAL_LOOK_AT_CENTER_Y, 0.0}, + FieldOfViewAngle: FIELD_OF_VIEW_ANGLE, + Width: int32(width), + Height: int32(height), + NearPlane: 0.1, + FarPlane: 1000.0, + lightPosition: &mmath.MVec3{-0.5, -1.0, 0.5}, + Msaa: NewMsaa(int32(width), int32(height)), + IsDrawRigidBodyFront: true, + } + shader.lightDirection = shader.lightPosition.Normalized() + + { + modelProgram, err := shader.newProgram( + glslFiles, "glsl/model.vert", "glsl/model.frag") + if err != nil { + return nil, err + } + shader.ModelProgram = modelProgram + shader.Use(PROGRAM_TYPE_MODEL) + shader.initialize(shader.ModelProgram) + shader.Unuse() + } + + { + boneProgram, err := shader.newProgram( + glslFiles, "glsl/bone.vert", "glsl/bone.frag") + if err != nil { + return nil, err + } + shader.BoneProgram = boneProgram + shader.Use(PROGRAM_TYPE_BONE) + shader.initialize(shader.BoneProgram) + shader.Unuse() + } + + { + edgeProgram, err := shader.newProgram( + glslFiles, "glsl/edge.vert", "glsl/edge.frag") + if err != nil { + return nil, err + } + shader.EdgeProgram = edgeProgram + shader.Use(PROGRAM_TYPE_EDGE) + shader.initialize(shader.EdgeProgram) + shader.Unuse() + } + + { + physicsProgram, err := shader.newProgram( + glslFiles, "glsl/physics.vert", "glsl/physics.frag") + if err != nil { + return nil, err + } + shader.PhysicsProgram = physicsProgram + shader.Use(PROGRAM_TYPE_PHYSICS) + shader.initialize(shader.PhysicsProgram) + shader.Unuse() + } + + { + normalProgram, err := shader.newProgram( + glslFiles, "glsl/vertex.vert", "glsl/vertex.frag") + if err != nil { + return nil, err + } + shader.NormalProgram = normalProgram + shader.Use(PROGRAM_TYPE_NORMAL) + shader.initialize(shader.NormalProgram) + shader.Unuse() + } + + { + floorProgram, err := shader.newProgram( + glslFiles, "glsl/floor.vert", "glsl/floor.frag") + if err != nil { + return nil, err + } + shader.FloorProgram = floorProgram + shader.Use(PROGRAM_TYPE_FLOOR) + shader.initialize(shader.FloorProgram) + shader.Unuse() + } + + { + wireProgram, err := shader.newProgram( + glslFiles, "glsl/vertex.vert", "glsl/vertex.frag") + if err != nil { + return nil, err + } + shader.WireProgram = wireProgram + shader.Use(PROGRAM_TYPE_WIRE) + shader.initialize(shader.WireProgram) + shader.Unuse() + } + + { + selectedVertexProgram, err := shader.newProgram( + glslFiles, "glsl/vertex.vert", "glsl/vertex.frag") + if err != nil { + return nil, err + } + shader.SelectedVertexProgram = selectedVertexProgram + shader.Use(PROGRAM_TYPE_SELECTED_VERTEX) + shader.initialize(shader.SelectedVertexProgram) + shader.Unuse() + } + + return shader, nil +} + +func (s *MShader) Reset() { + s.CameraPosition = &mmath.MVec3{0.0, INITIAL_CAMERA_POSITION_Y, INITIAL_CAMERA_POSITION_Z} + s.LookAtCenterPosition = &mmath.MVec3{0.0, INITIAL_LOOK_AT_CENTER_Y, 0.0} + s.FieldOfViewAngle = FIELD_OF_VIEW_ANGLE + s.Resize(int(s.Width), int(s.Height)) +} + +func (s *MShader) Resize(width, height int) { + s.Width = int32(width) + s.Height = int32(height) + s.Msaa = NewMsaa(s.Width, s.Height) + s.updateCamera() +} + +func (s *MShader) DeleteProgram(program uint32) { + if program != 0 { + gl.DeleteProgram(program) + } +} + +func (s *MShader) compileShader(shaderName, source string, shaderType uint32) (uint32, error) { + shader := gl.CreateShader(shaderType) + + csources, free := gl.Strs(source + "\x00") + gl.ShaderSource(shader, 1, csources, nil) + free() + gl.CompileShader(shader) + + var status int32 + gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status) + if status != gl.TRUE { + var logLength int32 + gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength) + + log := strings.Repeat("\x00", int(logLength+1)) + gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log)) + + return 0, fmt.Errorf("failed to compile %v: %v", shaderName, log) + } + + return shader, nil +} + +func (s *MShader) newProgram( + glslFiles embed.FS, + vertexShaderName, fragmentShaderName string, +) (uint32, error) { + vertexShaderFile, err := fs.ReadFile(glslFiles, vertexShaderName) + if err != nil { + return 0, err + } + + vertexShaderSource := string(vertexShaderFile) + + fragmentShaderFile, err := fs.ReadFile(glslFiles, fragmentShaderName) + if err != nil { + return 0, err + } + + fragmentShaderSource := string(fragmentShaderFile) + + vertexShader, err := s.compileShader(vertexShaderName, vertexShaderSource, gl.VERTEX_SHADER) + if err != nil { + return 0, err + } + + fragmentShader, err := s.compileShader(fragmentShaderName, fragmentShaderSource, gl.FRAGMENT_SHADER) + if err != nil { + return 0, err + } + + program := gl.CreateProgram() + + gl.AttachShader(program, vertexShader) + gl.AttachShader(program, fragmentShader) + gl.LinkProgram(program) + + var status int32 + gl.GetProgramiv(program, gl.LINK_STATUS, &status) + if status == gl.FALSE { + var logLength int32 + gl.GetProgramiv(program, gl.INFO_LOG_LENGTH, &logLength) + + log := strings.Repeat("\x00", int(logLength+1)) + gl.GetProgramInfoLog(program, logLength, nil, gl.Str(log)) + + return 0, fmt.Errorf("failed to link program: %v", log) + } + + gl.DeleteShader(vertexShader) + gl.DeleteShader(fragmentShader) + + return program, nil +} + +func (s *MShader) initialize(program uint32) { + // light color + // MMD Light Diffuse は必ず0 + // MMDの照明色そのまま: light_diffuse == MMDのambient + s.lightAmbient = &mmath.MVec4{LIGHT_AMBIENT, LIGHT_AMBIENT, LIGHT_AMBIENT, 1} + + gl.UseProgram(program) + + projection := mgl32.Perspective( + mgl32.DegToRad(s.FieldOfViewAngle), float32(s.Width)/float32(s.Height), s.NearPlane, s.FarPlane) + projectionUniform := gl.GetUniformLocation(program, gl.Str(SHADER_MODEL_VIEW_PROJECTION_MATRIX)) + gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0]) + + // カメラの位置 + cameraPosition := s.CameraPosition.GL() + cameraPositionUniform := gl.GetUniformLocation(program, gl.Str(SHADER_CAMERA_POSITION)) + gl.Uniform3fv(cameraPositionUniform, 1, &cameraPosition[0]) + + // ライト + lightDirection := s.lightDirection.GL() + lightDirectionUniform := gl.GetUniformLocation(program, gl.Str(SHADER_LIGHT_DIRECTION)) + gl.Uniform3fv(lightDirectionUniform, 1, &lightDirection[0]) + + // カメラ中心 + lookAtCenter := s.LookAtCenterPosition.GL() + camera := mgl32.LookAtV(cameraPosition, lookAtCenter, mgl32.Vec3{0, 1, 0}) + cameraUniform := gl.GetUniformLocation(program, gl.Str(SHADER_MODEL_VIEW_MATRIX)) + gl.UniformMatrix4fv(cameraUniform, 1, false, &camera[0]) + + // ボーン行列用テクスチャ生成 + gl.GenTextures(1, &s.BoneTextureId) + + s.Fit(int(s.Width), int(s.Height)) + + gl.UseProgram(0) +} + +func (s *MShader) Fit( + width int, + height int, +) { + s.Width = int32(width) + s.Height = int32(height) + + // MSAAも作り直し + s.Msaa = NewMsaa(s.Width, s.Height) + + // ビューポートの設定 + gl.Viewport(0, 0, s.Width, s.Height) + + s.updateCamera() +} + +func (s *MShader) updateCamera() { + for _, p := range s.GetPrograms() { + s.Use(ProgramType(p)) + + s.Unuse() + } +} + +func (s *MShader) Use(programType ProgramType) { + switch programType { + case PROGRAM_TYPE_MODEL: + gl.UseProgram(s.ModelProgram) + case PROGRAM_TYPE_EDGE: + gl.UseProgram(s.EdgeProgram) + case PROGRAM_TYPE_BONE: + gl.UseProgram(s.BoneProgram) + case PROGRAM_TYPE_PHYSICS: + gl.UseProgram(s.PhysicsProgram) + case PROGRAM_TYPE_NORMAL: + gl.UseProgram(s.NormalProgram) + case PROGRAM_TYPE_FLOOR: + gl.UseProgram(s.FloorProgram) + case PROGRAM_TYPE_WIRE: + gl.UseProgram(s.WireProgram) + case PROGRAM_TYPE_SELECTED_VERTEX: + gl.UseProgram(s.SelectedVertexProgram) + } +} + +func (s *MShader) GetPrograms() []uint32 { + return []uint32{s.ModelProgram, s.EdgeProgram, s.BoneProgram, s.PhysicsProgram, s.NormalProgram, s.FloorProgram, s.WireProgram, s.SelectedVertexProgram} +} + +func (s *MShader) Unuse() { + gl.UseProgram(0) +} + +func (s *MShader) Delete() { + s.DeleteProgram(s.ModelProgram) + s.DeleteProgram(s.EdgeProgram) + s.DeleteProgram(s.BoneProgram) + s.DeleteProgram(s.PhysicsProgram) + s.DeleteProgram(s.NormalProgram) + s.DeleteProgram(s.FloorProgram) + s.DeleteProgram(s.WireProgram) + s.DeleteProgram(s.SelectedVertexProgram) + s.Msaa.Delete() +} diff --git a/pkg/mview/utils.go b/pkg/mview/utils.go new file mode 100644 index 00000000..3802411b --- /dev/null +++ b/pkg/mview/utils.go @@ -0,0 +1,40 @@ +//go:build windows +// +build windows + +package mview + +import ( + "fmt" + + "github.com/go-gl/gl/v4.4-core/gl" +) + +func GetOpenGLErrorString(errCode uint32) string { + switch errCode { + case gl.NO_ERROR: + return "No error" + case gl.INVALID_ENUM: + return "Invalid enum" + case gl.INVALID_VALUE: + return "Invalid value" + case gl.INVALID_OPERATION: + return "Invalid operation" + case gl.STACK_OVERFLOW: + return "Stack overflow" + case gl.STACK_UNDERFLOW: + return "Stack underflow" + case gl.OUT_OF_MEMORY: + return "Out of memory" + case gl.INVALID_FRAMEBUFFER_OPERATION: + return "Invalid framebuffer operation" + default: + return fmt.Sprintf("Unknown error code: %v", errCode) + } +} + +func CheckGLError() error { + if errCode := gl.GetError(); errCode != gl.NO_ERROR { + return fmt.Errorf("OpenGL error: %v - %s", errCode, GetOpenGLErrorString(errCode)) + } + return nil +} diff --git a/pkg/mview/vao.go b/pkg/mview/vao.go new file mode 100644 index 00000000..4bbfc315 --- /dev/null +++ b/pkg/mview/vao.go @@ -0,0 +1,44 @@ +//go:build windows +// +build windows + +package mview + +import ( + "github.com/go-gl/gl/v4.4-core/gl" +) + +// Vertex Array Object. +type VAO struct { + id uint32 // ID +} + +// Creates a new VAO. +// Bind and use VBOs for rendering later. +func NewVAO() *VAO { + var vaoId uint32 + gl.GenVertexArrays(1, &vaoId) + vao := &VAO{id: vaoId} + + return vao +} + +// Delete this VAO. +func (v *VAO) Delete() { + gl.DeleteVertexArrays(1, &v.id) +} + +// Binds VAO for rendering. +func (v *VAO) Bind() { + gl.BindVertexArray(v.id) + CheckGLError() +} + +// Unbinds. +func (v *VAO) Unbind() { + gl.BindVertexArray(0) +} + +// Returns the GL ID. +func (v *VAO) GetId() uint32 { + return v.id +} diff --git a/pkg/mview/vbo.go b/pkg/mview/vbo.go new file mode 100644 index 00000000..02270859 --- /dev/null +++ b/pkg/mview/vbo.go @@ -0,0 +1,503 @@ +//go:build windows +// +build windows + +package mview + +import ( + "unsafe" + + "github.com/go-gl/gl/v4.4-core/gl" +) + +// Vertex Buffer Object. +type VBO struct { + id uint32 // ID + target uint32 // gl.ARRAY_BUFFER + size int // size in bytes + ptr unsafe.Pointer // verticesPtr + stride int32 // stride + StrideSize int // strideSize +} + +// Delete this VBO. +func (v *VBO) Delete() { + gl.DeleteBuffers(1, &v.id) +} + +// Unbinds. +func (v *VBO) Unbind() { + gl.BindBuffer(v.target, 0) +} + +// Creates a new VBO with given faceDtype. +func NewVBOForVertex(ptr unsafe.Pointer, count int) *VBO { + var vboId uint32 + gl.GenBuffers(1, &vboId) + + vbo := &VBO{ + id: vboId, + target: gl.ARRAY_BUFFER, + ptr: ptr, + } + // 頂点構造体のサイズ(全部floatとする) + // position(3), normal(3), uv(2), extendedUV(2), edgeFactor(1), deformBoneIndex(4), deformBoneWeight(4), + // isSdef(1), sdefC(3), sdefR0(3), sdefR1(3), vertexDelta(3), uvDelta(4), uv1Delta(4), afterVertexDelta(3) + vbo.StrideSize = 3 + 3 + 2 + 2 + 1 + 4 + 4 + 1 + 3 + 3 + 3 + 3 + 4 + 4 + 3 + vbo.stride = int32(4 * vbo.StrideSize) + vbo.size = count * 4 + + return vbo +} + +// Binds VBO for rendering. +func (v *VBO) BindVertex(vertexMorphIndexes []int, vertexMorphDeltas [][]float32) { + gl.BindBuffer(v.target, v.id) + + if vertexMorphIndexes != nil { + vboVertexSize := (3 + 3 + 2 + 2 + 1 + 4 + 4 + 1 + 3 + 3 + 3) + + // モーフ分の変動量を設定 + for i, vidx := range vertexMorphIndexes { + vd := vertexMorphDeltas[i] + offsetStride := (vidx*v.StrideSize + vboVertexSize) * 4 + // 必要な場合にのみ部分更新 + gl.BufferSubData(v.target, offsetStride, len(vd)*4, gl.Ptr(vd)) + } + } else { + gl.BufferData(v.target, v.size, v.ptr, gl.STATIC_DRAW) + } + + CheckGLError() + + // 0: position + gl.EnableVertexAttribArray(0) + gl.VertexAttribPointerWithOffset( + 0, // 属性のインデックス + 3, // 属性のサイズ + gl.FLOAT, // データの型 + false, // 正規化するかどうか + v.stride, // ストライド + 0, // オフセット（構造体内の位置） + ) + + // 1: normal + gl.EnableVertexAttribArray(1) + gl.VertexAttribPointerWithOffset( + 1, + 3, + gl.FLOAT, + false, + v.stride, + 3*4, + ) + + // 2: uv + gl.EnableVertexAttribArray(2) + gl.VertexAttribPointerWithOffset( + 2, + 2, + gl.FLOAT, + false, + v.stride, + 6*4, + ) + + // 3: extendedUV + gl.EnableVertexAttribArray(3) + gl.VertexAttribPointerWithOffset( + 3, + 2, + gl.FLOAT, + false, + v.stride, + 8*4, + ) + + // 4: edgeFactor + gl.EnableVertexAttribArray(4) + gl.VertexAttribPointerWithOffset( + 4, + 1, + gl.FLOAT, + false, + v.stride, + 10*4, + ) + + // 5: deformBoneIndex + gl.EnableVertexAttribArray(5) + gl.VertexAttribPointerWithOffset( + 5, + 4, + gl.FLOAT, + false, + v.stride, + 11*4, + ) + + // 6: deformBoneWeight + gl.EnableVertexAttribArray(6) + gl.VertexAttribPointerWithOffset( + 6, + 4, + gl.FLOAT, + false, + v.stride, + 15*4, + ) + + // 7: isSdef + gl.EnableVertexAttribArray(7) + gl.VertexAttribPointerWithOffset( + 7, + 1, + gl.FLOAT, + false, + v.stride, + 19*4, + ) + + // 8: SDEF-C + gl.EnableVertexAttribArray(8) + gl.VertexAttribPointerWithOffset( + 8, + 3, + gl.FLOAT, + false, + v.stride, + 20*4, + ) + + // 9: SDEF-R0 + gl.EnableVertexAttribArray(9) + gl.VertexAttribPointerWithOffset( + 9, + 3, + gl.FLOAT, + false, + v.stride, + 23*4, + ) + + // 10: SDEF-R1 + gl.EnableVertexAttribArray(10) + gl.VertexAttribPointerWithOffset( + 10, + 3, + gl.FLOAT, + false, + v.stride, + 26*4, + ) + + // 11: vertexDelta + gl.EnableVertexAttribArray(11) + gl.VertexAttribPointerWithOffset( + 11, + 3, + gl.FLOAT, + false, + v.stride, + 29*4, + ) + + // 12: uvDelta + gl.EnableVertexAttribArray(12) + gl.VertexAttribPointerWithOffset( + 12, + 4, + gl.FLOAT, + false, + v.stride, + 32*4, + ) + + // 13: uv1Delta + gl.EnableVertexAttribArray(13) + gl.VertexAttribPointerWithOffset( + 13, + 4, + gl.FLOAT, + false, + v.stride, + 36*4, + ) + + // 14: vertexDelta + gl.EnableVertexAttribArray(14) + gl.VertexAttribPointerWithOffset( + 14, + 3, + gl.FLOAT, + false, + v.stride, + 40*4, + ) + +} + +// Creates a new VBO with given faceDtype. +func NewVBOForDebug() *VBO { + var vboId uint32 + gl.GenBuffers(1, &vboId) + + vbo := &VBO{ + id: vboId, + target: gl.ARRAY_BUFFER, + ptr: nil, + } + // 剛体構造体のサイズ(全部floatとする) + // position(3) + vbo.stride = int32(4 * (3 + 4)) + + return vbo +} + +// Binds VBO for rendering. +func (v *VBO) BindDebug(vertices []float32) { + // verticesの要素数 * float32のサイズ + v.size = len(vertices) * 4 + + gl.BindBuffer(v.target, v.id) + gl.BufferData(v.target, v.size, gl.Ptr(&vertices[0]), gl.STATIC_DRAW) + CheckGLError() + + // 0: position + gl.EnableVertexAttribArray(0) + gl.VertexAttribPointerWithOffset( + 0, + 3, + gl.FLOAT, + false, + v.stride, + 0*4, + ) + + // 1: color + gl.EnableVertexAttribArray(1) + gl.VertexAttribPointerWithOffset( + 1, + 4, + gl.FLOAT, + false, + v.stride, + 3*4, + ) +} + +// 床のVBOを作成 +func NewVBOForFloor() (*VBO, int32) { + + // 床のラインの頂点データ + floorVertices := make([]float32, 0) + for x := -50; x < 0; x += 5 { + floorVertices = append(floorVertices, float32(x)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(-50)) + + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + + floorVertices = append(floorVertices, float32(x)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(50)) + + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + } + for x := 0; x <= 50; x += 5 { + floorVertices = append(floorVertices, float32(x)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(-50)) + + if x == 0 { + // 原点Z軸ライン + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 1.0) + floorVertices = append(floorVertices, 1.0) + } else { + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + } + + floorVertices = append(floorVertices, float32(x)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(0)) + + if x == 0 { + // 原点Z軸ライン + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 1.0) + floorVertices = append(floorVertices, 1.0) + } else { + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + } + + floorVertices = append(floorVertices, float32(x)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(0)) + + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + + floorVertices = append(floorVertices, float32(x)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(50)) + + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + } + for z := -50; z < 0; z += 5 { + floorVertices = append(floorVertices, float32(-50)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(z)) + + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + + floorVertices = append(floorVertices, float32(50)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(z)) + + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + } + for z := 0; z <= 50; z += 5 { + floorVertices = append(floorVertices, float32(-50)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(z)) + + if z == 0 { + // 原点X軸ライン + floorVertices = append(floorVertices, 1.0) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 1.0) + } else { + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + } + + floorVertices = append(floorVertices, float32(0)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(z)) + + if z == 0 { + // 原点X軸ライン + floorVertices = append(floorVertices, 1.0) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 1.0) + } else { + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + } + + floorVertices = append(floorVertices, float32(0)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(z)) + + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + + floorVertices = append(floorVertices, float32(50)) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, float32(z)) + + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.9) + floorVertices = append(floorVertices, 0.7) + } + + // 原点Y軸ライン + { + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 0.0) + + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 1.0) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 1.0) + + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 50.0) + floorVertices = append(floorVertices, 0.0) + + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 1.0) + floorVertices = append(floorVertices, 0.0) + floorVertices = append(floorVertices, 1.0) + } + + var vboId uint32 + gl.GenBuffers(1, &vboId) + + vbo := &VBO{ + id: vboId, + target: gl.ARRAY_BUFFER, + ptr: gl.Ptr(&floorVertices[0]), + } + // 剛体構造体のサイズ(全部floatとする) + // position(3) + vbo.stride = int32(4 * (3 + 4)) + // floorVerticesの要素数 * float32のサイズ + vbo.size = int(len(floorVertices) * 4) + + return vbo, int32(len(floorVertices)) +} + +// 床描画 +func (v *VBO) BindFloor() { + gl.BindBuffer(v.target, v.id) + gl.BufferData(v.target, v.size, v.ptr, gl.STATIC_DRAW) + CheckGLError() + + // 0: position + gl.EnableVertexAttribArray(0) + gl.VertexAttribPointerWithOffset( + 0, + 3, + gl.FLOAT, + false, + v.stride, + 0*4, + ) + + // 1: color + gl.EnableVertexAttribArray(1) + gl.VertexAttribPointerWithOffset( + 1, + 4, + gl.FLOAT, + false, + v.stride, + 3*4, + ) +} diff --git a/pkg/mwidget/console_view.go b/pkg/mwidget/console_view.go new file mode 100644 index 00000000..08d7358a --- /dev/null +++ b/pkg/mwidget/console_view.go @@ -0,0 +1,113 @@ +//go:build windows +// +build windows + +package mwidget + +import ( + "bytes" + "sync" + "syscall" + "unsafe" + + "github.com/miu200521358/walk/pkg/walk" + "github.com/miu200521358/win" +) + +// ConsoleView は、walk.WidgetBaseを埋め込んでカスタムウィジェットを作成します。 +type ConsoleView struct { + walk.WidgetBase + Console *walk.TextEdit + logChan chan string + mutex sync.Mutex +} + +const ( + ConsoleViewClass = "ConsoleView Class" + TEM_APPENDTEXT = win.WM_USER + 6 +) + +func NewConsoleView(parent walk.Container, minWidth int, minHeight int) (*ConsoleView, error) { + lc := make(chan string, 512) + cv := &ConsoleView{logChan: lc} + + if err := walk.InitWidget( + cv, + parent, + ConsoleViewClass, + win.WS_DISABLED, + 0); err != nil { + return nil, err + } + + // テキストエディットを作成 + te, err := walk.NewTextEditWithStyle(parent, win.WS_VISIBLE|win.WS_VSCROLL|win.ES_MULTILINE) + if err != nil { + return nil, err + } + te.SetMinMaxSize( + walk.Size{Width: minWidth, Height: minHeight}, + walk.Size{Width: minWidth * 100, Height: minHeight * 100}) + cv.Console = te + cv.Console.SetReadOnly(true) + cv.Console.SendMessage(win.EM_SETLIMITTEXT, 4294967295, 0) + + return cv, nil +} + +func (cv *ConsoleView) CreateLayoutItem(ctx *walk.LayoutContext) walk.LayoutItem { + return walk.NewGreedyLayoutItem() +} + +func (cv *ConsoleView) setTextSelection(start, end int) { + cv.Console.SendMessage(win.EM_SETSEL, uintptr(start), uintptr(end)) +} + +func (cv *ConsoleView) textLength() int { + return int(cv.Console.SendMessage(0x000E, uintptr(0), uintptr(0))) +} + +func (cv *ConsoleView) AppendText(value string) { + textLength := cv.textLength() + cv.setTextSelection(textLength, textLength) + uv, err := syscall.UTF16PtrFromString(value) + if err == nil { + cv.Console.SendMessage(win.EM_REPLACESEL, 0, uintptr(unsafe.Pointer(uv))) + } +} +func (cv *ConsoleView) PostAppendText(value string) { + cv.mutex.Lock() + defer cv.mutex.Unlock() + + cv.logChan <- value + win.PostMessage(cv.Handle(), TEM_APPENDTEXT, 0, 0) +} + +func (cv *ConsoleView) WndProc(hwnd win.HWND, msg uint32, wParam, lParam uintptr) uintptr { + switch msg { + case win.WM_GETDLGCODE: + if wParam == win.VK_RETURN { + return win.DLGC_WANTALLKEYS + } + + return win.DLGC_HASSETSEL | win.DLGC_WANTARROWS | win.DLGC_WANTCHARS + case TEM_APPENDTEXT: + select { + case value := <-cv.logChan: + cv.AppendText(value) + default: + return 0 + } + } + + return cv.WidgetBase.WndProc(hwnd, msg, wParam, lParam) +} + +// Write はio.Writerインターフェースを実装し、logの出力をConsoleViewにリダイレクトします。 +func (cv *ConsoleView) Write(p []byte) (n int, err error) { + + // 改行が文字列内にある場合、コンソール内で改行が行われるよう置換する + p = bytes.ReplaceAll(p, []byte("\n"), []byte("\r\n")) + cv.PostAppendText(string(p)) + + return n, nil +} diff --git a/pkg/mwidget/file_picker.go b/pkg/mwidget/file_picker.go new file mode 100644 index 00000000..22f8866a --- /dev/null +++ b/pkg/mwidget/file_picker.go @@ -0,0 +1,611 @@ +//go:build windows +// +build windows + +package mwidget + +import ( + "fmt" + "path/filepath" + "runtime" + + "github.com/miu200521358/walk/pkg/walk" + "github.com/miu200521358/win" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mutils" + "github.com/miu200521358/mlib_go/pkg/mutils/mconfig" + "github.com/miu200521358/mlib_go/pkg/mutils/mi18n" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" + "github.com/miu200521358/mlib_go/pkg/pmx" + "github.com/miu200521358/mlib_go/pkg/vmd" +) + +const FilePickerClass = "FilePicker Class" + +type FilePicker struct { + walk.WidgetBase + title string // ファイルタイトル + historyKey string // 履歴用キー(空欄の場合、保存用ファイルと見なす) + filterExtension map[int]map[string]string // フィルタ拡張子 + PathLineEdit *walk.LineEdit // ファイルパス入力欄 + nameLineEdit *walk.LineEdit // ファイル名入力欄 + openPushButton *walk.PushButton // 開くボタン + historyPushButton *walk.PushButton // 履歴ボタン + OnPathChanged func(string) // パス変更時のコールバック + limitHistory int // 履歴リスト + modelReader mcore.ReaderInterface // mcore + initialDirPath string // 初期ディレクトリ + cacheData mcore.IHashModel // キャッシュデータ + window *MWindow // MWindow + historyDialog *walk.Dialog // 履歴ダイアログ +} + +func NewPmxReadFilePicker( + window *MWindow, + parent walk.Container, + historyKey string, + title string, + tooltip string, + description string, + OnPathChanged func(string), +) (*FilePicker, error) { + return NewFilePicker( + window, + parent, + historyKey, + title, + tooltip, + description, + map[int]map[string]string{ + 0: {"*.pmx": "Pmx Files (*.pmx)"}, 2: {"*.*": "All Files (*.*)"}}, + 50, + &pmx.PmxReader{}, + OnPathChanged) +} + +func NewVpdReadFilePicker( + window *MWindow, + parent walk.Container, + historyKey string, + title string, + tooltip string, + description string, + OnPathChanged func(string), +) (*FilePicker, error) { + return NewFilePicker( + window, + parent, + historyKey, + title, + tooltip, + description, + map[int]map[string]string{ + 0: {"*.vpd": "Vpd Files (*.vpd)"}, 1: {"*.*": "All Files (*.*)"}}, + 50, + &vmd.VpdMotionReader{}, + OnPathChanged) +} + +func NewVmdVpdReadFilePicker( + window *MWindow, + parent walk.Container, + historyKey string, + title string, + tooltip string, + description string, + OnPathChanged func(string), +) (*FilePicker, error) { + return NewFilePicker( + window, + parent, + historyKey, + title, + tooltip, + description, + map[int]map[string]string{ + 0: {"*.vmd": "Vmd Files (*.vmd)"}, + 1: {"*.vpd": "Vpd Files (*.vpd)"}, + 2: {"*.*": "All Files (*.*)"}}, + 50, + vmd.NewVmdVpdMotionReader(), + OnPathChanged) +} + +func NewVmdReadFilePicker( + window *MWindow, + parent walk.Container, + historyKey string, + title string, + tooltip string, + description string, + OnPathChanged func(string), +) (*FilePicker, error) { + return NewFilePicker( + window, + parent, + historyKey, + title, + tooltip, + description, + map[int]map[string]string{ + 0: {"*.vmd": "Vmd Files (*.vmd)"}, + 1: {"*.*": "All Files (*.*)"}}, + 50, + &vmd.VmdMotionReader{}, + OnPathChanged) +} + +func NewVmdSaveFilePicker( + window *MWindow, + parent walk.Container, + title string, + tooltip string, + description string, + OnPathChanged func(string), +) (*FilePicker, error) { + return NewFilePicker( + window, + parent, + "", + title, + tooltip, + description, + map[int]map[string]string{ + 0: {"*.vmd": "Vmd Files (*.vmd)"}, + 1: {"*.*": "All Files (*.*)"}}, + 0, + nil, + OnPathChanged) +} + +func NewPmxSaveFilePicker( + window *MWindow, + parent walk.Container, + title string, + tooltip string, + description string, + onPathChanged func(string), +) (*FilePicker, error) { + return NewFilePicker( + window, + parent, + "", + title, + tooltip, + description, + map[int]map[string]string{ + 0: {"*.pmx": "Pmx Files (*.pmx)"}, + 1: {"*.*": "All Files (*.*)"}}, + 0, + nil, + onPathChanged) +} + +func NewFilePicker( + window *MWindow, + parent walk.Container, + historyKey string, + title string, + tooltip string, + description string, + filterExtension map[int]map[string]string, + limitHistory int, + modelReader mcore.ReaderInterface, + onPathChanged func(string), +) (*FilePicker, error) { + picker := new(FilePicker) + picker.title = title + picker.historyKey = historyKey + picker.filterExtension = filterExtension + picker.OnPathChanged = onPathChanged + picker.limitHistory = limitHistory + picker.modelReader = modelReader + picker.window = window + + if err := walk.InitWidget( + picker, + parent, + FilePickerClass, + win.WS_DISABLED, + 0); err != nil { + + return nil, err + } + + // タイトル + titleComposite, err := walk.NewComposite(parent) + if err != nil { + return nil, err + } + titleComposite.SetLayout(walk.NewHBoxLayout()) + + titleLabel, err := walk.NewTextLabel(titleComposite) + if err != nil { + return nil, err + } + titleLabel.SetText(title) + titleLabel.SetToolTipText(tooltip) + titleLabel.MouseDown().Attach(func(x, y int, button walk.MouseButton) { + mlog.IL(description) + }) + + if historyKey != "" { + startBracketLabel, err := walk.NewTextLabel(titleComposite) + if err != nil { + return nil, err + } + startBracketLabel.SetText(" (") + startBracketLabel.SetToolTipText(tooltip) + + nameLineEdit, err := walk.NewLineEditStaticEdge(titleComposite) + if err != nil { + return nil, err + } + nameLineEdit.SetText(mi18n.T("未設定")) + nameLineEdit.SetToolTipText(tooltip) + nameLineEdit.SetReadOnly(true) + picker.nameLineEdit = nameLineEdit + + endBracketLabel, err := walk.NewTextLabel(titleComposite) + if err != nil { + return nil, err + } + endBracketLabel.SetText(")") + } + + // パス入力欄 + inputComposite, err := walk.NewComposite(parent) + if err != nil { + return nil, err + } + inputComposite.SetLayout(walk.NewHBoxLayout()) + + picker.PathLineEdit, err = walk.NewLineEdit(inputComposite) + if err != nil { + return nil, err + } + picker.PathLineEdit.SetToolTipText(tooltip) + picker.PathLineEdit.DropFiles().Attach(func(files []string) { + if len(files) > 0 { + path := files[0] + // パスを入力欄に設定 + picker.PathLineEdit.SetText(path) + // コールバックを呼び出し + picker.OnChanged(path) + } + }) + + picker.openPushButton, err = walk.NewPushButton(inputComposite) + if err != nil { + return nil, err + } + picker.openPushButton.SetToolTipText(tooltip) + picker.openPushButton.SetText(mi18n.T("開く")) + picker.openPushButton.Clicked().Attach(picker.onClickOpenButton()) + + if historyKey != "" { + picker.historyPushButton, err = walk.NewPushButton(inputComposite) + if err != nil { + return nil, err + } + picker.historyPushButton.SetToolTipText(tooltip) + picker.historyPushButton.SetText(mi18n.T("履歴")) + picker.historyDialog, err = picker.createHistoryDialog() + if err != nil { + return nil, err + } + + picker.historyPushButton.Clicked().Attach(picker.onClickHistoryButton()) + } + + return picker, nil +} + +func (picker *FilePicker) GetData() (mcore.IHashModel, error) { + if picker.PathLineEdit.Text() == "" || picker.modelReader == nil { + return nil, nil + } + + if isExist, err := mutils.ExistsFile(picker.PathLineEdit.Text()); err != nil || !isExist { + return nil, fmt.Errorf(mi18n.T("ファイルが存在しません")) + } + + // キャッシュの有無は見ずに、必ず取得し直す + data, err := picker.modelReader.ReadByFilepath(picker.PathLineEdit.Text()) + defer runtime.GC() // 読み込み時のメモリ解放 + + if err != nil { + return nil, err + } + picker.cacheData = data + + return data, nil +} + +// パスが正しいことが分かっている上でデータだけ取り直したい場合 +func (picker *FilePicker) GetDataForce() mcore.IHashModel { + data, err := picker.modelReader.ReadByFilepath(picker.PathLineEdit.Text()) + defer runtime.GC() // 読み込み時のメモリ解放 + + if err != nil { + return nil + } + + return data +} + +func (picker *FilePicker) SetCache(data mcore.IHashModel) { + if data == nil { + picker.PathLineEdit.SetText("") + return + } + + picker.cacheData = data + picker.PathLineEdit.SetText(data.GetPath()) +} + +func (picker *FilePicker) IsCached() bool { + if isExist, err := mutils.ExistsFile(picker.PathLineEdit.Text()); err != nil || !isExist { + return false + } + + hash, err := picker.modelReader.ReadHashByFilePath(picker.PathLineEdit.Text()) + if err != nil { + return false + } + + return picker.cacheData != nil && picker.cacheData.GetHash() == hash +} + +func (picker *FilePicker) ClearCache() { + picker.cacheData = nil +} + +func (picker *FilePicker) GetCache() mcore.IHashModel { + return picker.cacheData +} + +func (picker *FilePicker) SetPath(path string) { + picker.PathLineEdit.SetText(path) +} + +func (picker *FilePicker) GetPath() string { + return picker.PathLineEdit.Text() +} + +func (picker *FilePicker) OnChanged(path string) { + picker.PathLineEdit.SetText(path) + + if picker.modelReader != nil && picker.historyKey != "" { + if path == "" { + picker.nameLineEdit.SetText(mi18n.T("未設定")) + } else { + modelName, err := picker.modelReader.ReadNameByFilepath(path) + if err != nil { + picker.nameLineEdit.SetText(mi18n.T("読み込み失敗")) + } else { + picker.nameLineEdit.SetText(modelName) + } + } + } + + if picker.historyKey != "" { + // 履歴用キーを指定して履歴リストを保存 + mconfig.SaveUserConfig(picker.historyKey, path, picker.limitHistory) + } + + if picker.OnPathChanged != nil { + picker.OnPathChanged(path) + } +} + +func (picker *FilePicker) onClickHistoryButton() walk.EventHandler { + return func() { + if dlg, err := picker.createHistoryDialog(); dlg != nil && err == nil { + if ok := dlg.Run(); ok == walk.DlgCmdOK { + // コールバックを呼び出し + picker.OnChanged(picker.PathLineEdit.Text()) + } + dlg.Dispose() + } + } +} + +func (picker *FilePicker) createHistoryDialog() (*walk.Dialog, error) { + // 履歴リストを取得 + choices := mconfig.LoadUserConfig(picker.historyKey) + + // 履歴ダイアログを開く + dlg, err := walk.NewDialog(picker.Form()) + if err != nil { + walk.MsgBox(nil, mi18n.T("履歴ダイアログ生成エラー"), err.Error(), walk.MsgBoxIconError) + return nil, err + } + dlg.SetTitle(mi18n.T("履歴ダイアログタイトル", map[string]interface{}{"Title": picker.title})) + dlg.SetLayout(walk.NewVBoxLayout()) + dlg.SetSize(walk.Size{Width: 800, Height: 400}) + + // 履歴リストを表示 + historyListBox, err := walk.NewListBox(dlg) + if err != nil { + walk.MsgBox(nil, mi18n.T("履歴リスト生成エラー"), err.Error(), walk.MsgBoxIconError) + return nil, err + } + + // OKボタンの動作を定義する関数 + itemActivated := func() { + // 選択されたアイテムを取得 + index := historyListBox.CurrentIndex() + if index < 0 { + return + } + item := choices[index] + // パスを入力欄に設定 + picker.PathLineEdit.SetText(item) + } + + historyListBox.SetModel(choices) + historyListBox.SetMinMaxSize(walk.Size{Width: 800, Height: 400}, walk.Size{Width: 800, Height: 400}) + // 先頭を表示する（選択はできない） + historyListBox.SetCurrentIndex(-1) + + // ダブルクリック時の動作を定義 + historyListBox.ItemActivated().Attach(func() { + itemActivated() + dlg.Accept() + }) + + // ボタンBox + buttonComposite, err := walk.NewComposite(dlg) + if err != nil { + walk.MsgBox(nil, mi18n.T("ボタンBox生成エラー"), err.Error(), walk.MsgBoxIconError) + return nil, err + } + buttonComposite.SetLayout(walk.NewHBoxLayout()) + + // OKボタン + okButton, err := walk.NewPushButton(buttonComposite) + if err != nil { + walk.MsgBox(nil, mi18n.T("OKボタン生成エラー"), err.Error(), walk.MsgBoxIconError) + return nil, err + } + okButton.SetText("OK") + okButton.Clicked().Attach(func() { + itemActivated() + dlg.Accept() + }) + + // Cancel ボタン + cancelButton, err := walk.NewPushButton(buttonComposite) + if err != nil { + walk.MsgBox(nil, mi18n.T("Cancelボタン生成エラー"), err.Error(), walk.MsgBoxIconError) + return nil, err + } + cancelButton.SetText("Cancel") + cancelButton.Clicked().Attach(func() { + // ダイアログを閉じる + dlg.Cancel() + }) + + return dlg, nil +} + +func (picker *FilePicker) onClickOpenButton() walk.EventHandler { + return func() { + if picker.PathLineEdit.Text() != "" { + // ファイルパスからディレクトリパスを取得 + dirPath := filepath.Dir(picker.PathLineEdit.Text()) + // ファイルパスのディレクトリを初期パスとして設定 + picker.initialDirPath = dirPath + } else if picker.historyKey != "" { + // 履歴用キーを指定して履歴リストを取得 + choices := mconfig.LoadUserConfig(picker.historyKey) + if len(choices) > 0 { + // ファイルパスからディレクトリパスを取得 + dirPath := filepath.Dir(choices[0]) + // 履歴リストの先頭を初期パスとして設定 + picker.initialDirPath = dirPath + } + } + + // ファイル選択ダイアログを開く + dlg := walk.FileDialog{ + Title: mi18n.T( + "ファイル選択ダイアログタイトル", + map[string]interface{}{"Title": picker.title}), + Filter: picker.convertFilterExtension(picker.filterExtension), + FilterIndex: 1, + InitialDirPath: picker.initialDirPath, + } + if ok, err := dlg.ShowOpen(nil); err != nil { + walk.MsgBox(nil, mi18n.T("ファイル選択ダイアログ選択エラー"), err.Error(), walk.MsgBoxIconError) + } else if ok { + // パスを入力欄に設定 + picker.PathLineEdit.SetText(dlg.FilePath) + // コールバックを呼び出し + picker.OnChanged(dlg.FilePath) + } + } +} + +func (f *FilePicker) convertFilterExtension(filterExtension map[int]map[string]string) string { + var filterString string + for i := 0; i < len(filterExtension); i++ { + extData := filterExtension[i] + for ext, desc := range extData { + if filterString != "" { + filterString = filterString + "|" + } + filterString = filterString + desc + "|" + ext + } + } + return filterString +} + +func (*FilePicker) CreateLayoutItem(ctx *walk.LayoutContext) walk.LayoutItem { + return &filePickerLayoutItem{idealSize: walk.SizeFrom96DPI(walk.Size{Width: 50, Height: 50}, ctx.DPI())} +} + +func (f *FilePicker) Exists() bool { + if f.PathLineEdit.Text() == "" { + return false + } + isExist, err := mutils.ExistsFile(f.PathLineEdit.Text()) + if err != nil { + return false + } + return isExist +} + +func (f *FilePicker) ExistsOrEmpty() bool { + if f.PathLineEdit.Text() == "" { + return true + } + isExist, err := mutils.ExistsFile(f.PathLineEdit.Text()) + if err != nil { + return false + } + return isExist +} + +func (f *FilePicker) SetEnabled(enable bool) { + f.PathLineEdit.SetEnabled(enable) + f.openPushButton.SetEnabled(enable) + if f.historyPushButton != nil { + f.historyPushButton.SetEnabled(enable) + } +} + +func (f *FilePicker) Enabled() bool { + return f.PathLineEdit.Enabled() +} + +func (f *FilePicker) SetVisible(visible bool) { + f.PathLineEdit.SetVisible(visible) + f.openPushButton.SetVisible(visible) + if f.historyPushButton != nil { + f.historyPushButton.SetVisible(visible) + } +} + +func (f *FilePicker) Dispose() { + f.PathLineEdit.Dispose() + f.openPushButton.Dispose() + if f.historyPushButton != nil { + f.historyPushButton.Dispose() + } + f.WidgetBase.Dispose() +} + +type filePickerLayoutItem struct { + walk.LayoutItemBase + idealSize walk.Size // in native pixels +} + +func (li *filePickerLayoutItem) LayoutFlags() walk.LayoutFlags { + return 0 +} + +func (li *filePickerLayoutItem) IdealSize() walk.Size { + return li.idealSize +} diff --git a/pkg/mwidget/fix_view_widget.go b/pkg/mwidget/fix_view_widget.go new file mode 100644 index 00000000..71f43396 --- /dev/null +++ b/pkg/mwidget/fix_view_widget.go @@ -0,0 +1,119 @@ +//go:build windows +// +build windows + +package mwidget + +import ( + "github.com/miu200521358/mlib_go/pkg/mutils/mi18n" + "github.com/miu200521358/walk/pkg/walk" + "github.com/miu200521358/win" +) + +const FixViewWidgetClass = "FixViewWidget Class" + +type FixViewWidget struct { + walk.WidgetBase + mWindow *MWindow // メインウィンドウ + ModelChoice *walk.ComboBox // モデル選択 + BoneChoice *walk.ComboBox // ボーン選択 + DirectionChoice *walk.ComboBox // 方向選択 + ShowButton *walk.PushButton // 表示ボタン + IsShow bool // 表示中かどうか +} + +func NewFixViewWidget(parent walk.Container, mWindow *MWindow) (*FixViewWidget, error) { + fw := new(FixViewWidget) + fw.mWindow = mWindow + + if err := walk.InitWidget( + fw, + parent, + FixViewWidgetClass, + win.WS_DISABLED, + 0); err != nil { + + return nil, err + } + + composite, err := walk.NewComposite(parent) + if err != nil { + return nil, err + } + layout := walk.NewHBoxLayout() + composite.SetLayout(layout) + + // モデル選択 + fw.ModelChoice, err = walk.NewDropDownBox(composite) + if err != nil { + return nil, err + } + fw.ModelChoice.SetModel([]string{"No.1", "No.2", "No.3"}) + fw.ModelChoice.SetCurrentIndex(0) + + // ボーン選択 + fw.BoneChoice, err = walk.NewDropDownBox(composite) + if err != nil { + return nil, err + } + fw.BoneChoice.SetModel([]string{"頭", "上半身", "右足首"}) + fw.BoneChoice.SetCurrentIndex(0) + + // 方向選択 + fw.DirectionChoice, err = walk.NewDropDownBox(composite) + if err != nil { + return nil, err + } + fw.DirectionChoice.SetModel([]string{"正面", "左面", "右面", "背面"}) + fw.DirectionChoice.SetCurrentIndex(0) + + fw.ShowButton, err = walk.NewPushButton(composite) + if err != nil { + return nil, err + } + fw.ShowButton.SetText(mi18n.T("固定ビュー表示")) + fw.ShowButton.Clicked().Attach(func() { + if fw.IsShow { + fw.ShowButton.SetChecked(false) + fw.ShowButton.SetText(mi18n.T("固定ビュー表示")) + } else { + fw.ShowButton.SetChecked(true) + fw.ShowButton.SetText(mi18n.T("固定ビュー非表示")) + } + fw.IsShow = !fw.IsShow + }) + + return fw, nil +} + +func (fw *FixViewWidget) Dispose() { + fw.WidgetBase.Dispose() + fw.ModelChoice.Dispose() + fw.BoneChoice.Dispose() + fw.DirectionChoice.Dispose() + fw.ShowButton.Dispose() +} + +func (fw *FixViewWidget) SetEnabled(enabled bool) { + fw.WidgetBase.SetEnabled(enabled) + fw.ModelChoice.SetEnabled(enabled) + fw.BoneChoice.SetEnabled(enabled) + fw.DirectionChoice.SetEnabled(enabled) + fw.ShowButton.SetEnabled(enabled) +} + +func (f *FixViewWidget) CreateLayoutItem(ctx *walk.LayoutContext) walk.LayoutItem { + return &subViewWidgetLayoutItem{idealSize: walk.SizeFrom96DPI(walk.Size{Width: 50, Height: 50}, ctx.DPI())} +} + +type subViewWidgetLayoutItem struct { + walk.LayoutItemBase + idealSize walk.Size // in native pixels +} + +func (li *subViewWidgetLayoutItem) LayoutFlags() walk.LayoutFlags { + return 0 +} + +func (li *subViewWidgetLayoutItem) IdealSize() walk.Size { + return li.idealSize +} diff --git a/pkg/mwidget/gl_window.go b/pkg/mwidget/gl_window.go new file mode 100644 index 00000000..4a4d2fa1 --- /dev/null +++ b/pkg/mwidget/gl_window.go @@ -0,0 +1,980 @@ +//go:build windows +// +build windows + +package mwidget + +import ( + "fmt" + "image" + "math" + "unsafe" + + "github.com/go-gl/gl/v4.4-core/gl" + "github.com/go-gl/glfw/v3.3/glfw" + "github.com/go-gl/mathgl/mgl32" + "github.com/go-gl/mathgl/mgl64" + "github.com/miu200521358/walk/pkg/walk" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mphysics" + "github.com/miu200521358/mlib_go/pkg/mutils/mconfig" + "github.com/miu200521358/mlib_go/pkg/mutils/mi18n" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" + "github.com/miu200521358/mlib_go/pkg/mview" + "github.com/miu200521358/mlib_go/pkg/pmx" + "github.com/miu200521358/mlib_go/pkg/vmd" +) + +// 直角の定数値 +const RIGHT_ANGLE = 89.9 + +type GlWindow struct { + *glfw.Window + mWindow *MWindow // walkウィンドウ + modelSets []*ModelSet // モデルセット + Shader *mview.MShader // シェーダー + appConfig *mconfig.AppConfig // アプリケーション設定 + title string // ウィンドウタイトル(fpsとか入ってないオリジナル) + WindowIndex int // ウィンドウインデックス + prevCursorPos *mmath.MVec2 // 前回のカーソル位置 + nowCursorPos *mmath.MVec2 // 現在のカーソル位置 + yaw float64 // ウィンドウ操作yaw + pitch float64 // ウィンドウ操作pitch + Physics *mphysics.MPhysics // 物理 + leftButtonPressed bool // 左ボタン押下フラグ + middleButtonPressed bool // 中ボタン押下フラグ + rightButtonPressed bool // 右ボタン押下フラグ + updatedPrev bool // 前回のカーソル位置更新フラグ + shiftPressed bool // Shiftキー押下フラグ + ctrlPressed bool // Ctrlキー押下フラグ + running bool // 描画ループ中フラグ + playing bool // 再生中フラグ + doResetPhysicsStart bool // 物理リセット開始フラグ + doResetPhysicsProgress bool // 物理リセット中フラグ + doResetPhysicsCount int // 物理リセット処理回数 + VisibleBones map[pmx.BoneFlag]bool // ボーン表示フラグ + VisibleNormal bool // 法線表示フラグ + VisibleWire bool // ワイヤーフレーム表示フラグ + VisibleSelectedVertex bool // 選択頂点表示フラグ + enablePhysics bool // 物理有効フラグ + EnableFrameDrop bool // フレームドロップ有効フラグ + isClosed bool // walkウィンドウが閉じられたかどうか + isShowInfo bool // 情報表示フラグ + spfLimit float64 //fps制限 + frame float64 // 現在のフレーム + prevFrame int // 前回のフレーム + isSaveDelta bool // 前回デフォーム保存フラグ(walkウィンドウからの変更情報検知用) + motionPlayer *MotionPlayer // 再生ウィジェット + width int // ウィンドウ幅 + height int // ウィンドウ高さ + floor *MFloor // 床 + funcWorldPos func(prevXprevYFrontPos, prevXprevYBackPos, prevXnowYFrontPos, prevXnowYBackPos, + nowXprevYFrontPos, nowXprevYBackPos, nowXnowYFrontPos, nowXnowYBackPos *mmath.MVec3, + vmdDeltas []*vmd.VmdDeltas) // 選択ポイントからのグローバル位置取得コールバック関数 + AppendModelSetChannel chan *ModelSet // モデルセット追加チャネル + RemoveModelSetIndexChannel chan int // モデルセット削除チャネル + ReplaceModelSetChannel chan map[int]*ModelSet // モデルセット入替チャネル + IsPlayingChannel chan bool // 再生チャネル + FrameChannel chan int // フレームチャネル + IsClosedChannel chan bool // ウィンドウクローズチャネル +} + +func NewGlWindow( + width int, + height int, + windowIndex int, + iconImg *image.Image, + appConfig *mconfig.AppConfig, + mainWindow *GlWindow, + fixViewWidget *FixViewWidget, +) (*GlWindow, error) { + if mainWindow == nil { + // GLFW の初期化(最初の一回だけ) + if err := glfw.Init(); err != nil { + return nil, err + } + } + + glfw.WindowHint(glfw.Resizable, glfw.True) + glfw.WindowHint(glfw.ContextVersionMajor, 4) + glfw.WindowHint(glfw.ContextVersionMinor, 4) + glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile) + glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True) + + var mw *glfw.Window = nil + if mainWindow != nil { + mw = mainWindow.Window + } + + // ウィンドウの作成 + title := mi18n.T("ビューワー") + w, err := glfw.CreateWindow(width, height, title, nil, mw) + if err != nil { + return nil, err + } + w.MakeContextCurrent() + w.SetInputMode(glfw.StickyKeysMode, glfw.True) + w.SetIcon([]image.Image{*iconImg}) + + // OpenGL の初期化 + if err := gl.Init(); err != nil { + return nil, err + } + + // デバッグコールバックを設定します。 + gl.DebugMessageCallback(func( + source uint32, + glType uint32, + id uint32, + severity uint32, + length int32, + message string, + userParam unsafe.Pointer, + ) { + switch severity { + case gl.DEBUG_SEVERITY_HIGH: + mlog.E("[HIGH] GL CALLBACK: %v type = 0x%x, severity = 0x%x, message = %s\n", + source, glType, severity, message) + panic("critical OpenGL error") + case gl.DEBUG_SEVERITY_MEDIUM: + mlog.V("[MEDIUM] GL CALLBACK: %v type = 0x%x, severity = 0x%x, message = %s\n", + source, glType, severity, message) + case gl.DEBUG_SEVERITY_LOW: + mlog.V("[LOW] GL CALLBACK: %v type = 0x%x, severity = 0x%x, message = %s\n", + source, glType, severity, message) + // case gl.DEBUG_SEVERITY_NOTIFICATION: + // mlog.D("[NOTIFICATION] GL CALLBACK: %v type = 0x%x, severity = 0x%x, message = %s\n", + // source, glType, severity, message) + } + }, gl.Ptr(nil)) + gl.Enable(gl.DEBUG_OUTPUT) + gl.Enable(gl.DEBUG_OUTPUT_SYNCHRONOUS) // 同期的なデバッグ出力を有効にします。 + + shader, err := mview.NewMShader(width, height) + if err != nil { + return nil, err + } + + glWindow := GlWindow{ + Window: w, + modelSets: make([]*ModelSet, 0), + Shader: shader, + appConfig: appConfig, + title: title, + WindowIndex: windowIndex, + prevCursorPos: &mmath.MVec2{0, 0}, + nowCursorPos: &mmath.MVec2{0, 0}, + yaw: RIGHT_ANGLE, + pitch: 0.0, + Physics: mphysics.NewMPhysics(shader), + middleButtonPressed: false, + rightButtonPressed: false, + updatedPrev: false, + shiftPressed: false, + ctrlPressed: false, + VisibleBones: make(map[pmx.BoneFlag]bool, 0), + VisibleNormal: false, + VisibleWire: false, + VisibleSelectedVertex: false, + isClosed: false, + isShowInfo: false, + spfLimit: 1.0 / 30.0, + running: false, + playing: false, // 最初は再生OFF + enablePhysics: true, // 最初は物理ON + EnableFrameDrop: true, // 最初はドロップON + frame: 0, + prevFrame: 0, + isSaveDelta: true, + width: width, + height: height, + floor: newMFloor(), + AppendModelSetChannel: make(chan *ModelSet, 1), + RemoveModelSetIndexChannel: make(chan int, 1), + ReplaceModelSetChannel: make(chan map[int]*ModelSet), + IsPlayingChannel: make(chan bool, 1), + FrameChannel: make(chan int, 1), + } + + w.SetScrollCallback(glWindow.handleScrollEvent) + w.SetMouseButtonCallback(glWindow.handleMouseButtonEvent) + w.SetCursorPosCallback(glWindow.handleCursorPosEvent) + w.SetKeyCallback(glWindow.handleKeyEvent) + w.SetCloseCallback(glWindow.TriggerClose) + w.SetSizeCallback(glWindow.resize) + w.SetFramebufferSizeCallback(glWindow.resizeBuffer) + + return &glWindow, nil +} + +func (w *GlWindow) SetTitle(title string) { + w.title = title + w.Window.SetTitle(title) +} + +func (w *GlWindow) SetMWindow(mw *MWindow) { + w.mWindow = mw +} + +func (w *GlWindow) SetMotionPlayer(mp *MotionPlayer) { + w.motionPlayer = mp +} + +func (w *GlWindow) SetFuncWorldPos(f func(prevXprevYFrontPos, prevXprevYBackPos, prevXnowYFrontPos, prevXnowYBackPos, + nowXprevYFrontPos, nowXprevYBackPos, nowXnowYFrontPos, nowXnowYBackPos *mmath.MVec3, vmdDeltas []*vmd.VmdDeltas)) { + w.funcWorldPos = f +} + +func (w *GlWindow) resizeBuffer(window *glfw.Window, width int, height int) { + w.width = width + w.height = height + if width > 0 && height > 0 { + gl.Viewport(0, 0, int32(width), int32(height)) + } +} + +func (w *GlWindow) resize(window *glfw.Window, width int, height int) { + gl.Viewport(0, 0, int32(width), int32(height)) + w.Shader.Resize(width, height) +} + +func (w *GlWindow) TriggerPlay(p bool) { + w.playing = p + w.isSaveDelta = false +} + +func (w *GlWindow) GetFrame() int { + return int(w.frame) +} + +func (w *GlWindow) SetFrame(f int) { + w.frame = float64(f) + w.prevFrame = f + w.isSaveDelta = false +} + +func (w *GlWindow) TriggerClose(window *glfw.Window) { + w.running = false +} + +func (w *GlWindow) handleKeyEvent( + window *glfw.Window, + key glfw.Key, + scancode int, + action glfw.Action, + mods glfw.ModifierKey, +) { + if !(action == glfw.Press || action == glfw.Repeat) || + !(key == glfw.KeyKP0 || + key == glfw.KeyKP2 || + key == glfw.KeyKP4 || + key == glfw.KeyKP5 || + key == glfw.KeyKP6 || + key == glfw.KeyKP8 || + key == glfw.KeyLeftShift || + key == glfw.KeyRightShift || + key == glfw.KeyLeftControl || + key == glfw.KeyRightControl || + key == glfw.KeyLeft || + key == glfw.KeyRight || + key == glfw.KeyUp || + key == glfw.KeyDown) { + return + } + + if w.motionPlayer != nil { + if key == glfw.KeyRight || key == glfw.KeyUp { + w.motionPlayer.SetValue(w.GetFrame() + 1) + return + } else if key == glfw.KeyLeft || key == glfw.KeyDown { + w.motionPlayer.SetValue(w.GetFrame() - 1) + return + } + } + + if key == glfw.KeyLeftShift || key == glfw.KeyRightShift { + if action == glfw.Press { + w.shiftPressed = true + } else if action == glfw.Release { + w.shiftPressed = false + } + return + } else if key == glfw.KeyLeftControl || key == glfw.KeyRightControl { + if action == glfw.Press { + w.ctrlPressed = true + } else if action == glfw.Release { + w.ctrlPressed = false + } + return + } + + w.TriggerViewReset() + + switch key { + case glfw.KeyKP0: // 下面から + w.yaw = RIGHT_ANGLE + w.pitch = RIGHT_ANGLE + case glfw.KeyKP2: // 正面から + w.yaw = RIGHT_ANGLE + w.pitch = 0 + case glfw.KeyKP4: // 左面から + w.yaw = 180 + w.pitch = 0 + case glfw.KeyKP5: // 上面から + w.yaw = RIGHT_ANGLE + w.pitch = -RIGHT_ANGLE + case glfw.KeyKP6: // 右面から + w.yaw = 0 + w.pitch = 0 + case glfw.KeyKP8: // 背面から + w.yaw = -RIGHT_ANGLE + w.pitch = 0 + default: + return + } + + // カメラの新しい位置を計算 + radius := mview.INITIAL_CAMERA_POSITION_Z + + // 球面座標系をデカルト座標系に変換 + cameraX := radius * math.Cos(mgl64.DegToRad(w.pitch)) * math.Cos(mgl64.DegToRad(w.yaw)) + cameraY := radius * math.Sin(mgl64.DegToRad(w.pitch)) + cameraZ := radius * math.Cos(mgl64.DegToRad(w.pitch)) * math.Sin(mgl64.DegToRad(w.yaw)) + + // カメラ位置を更新 + w.Shader.CameraPosition.SetX(cameraX) + w.Shader.CameraPosition.SetY(mview.INITIAL_CAMERA_POSITION_Y + cameraY) + w.Shader.CameraPosition.SetZ(cameraZ) +} + +func (w *GlWindow) handleScrollEvent(window *glfw.Window, xoff float64, yoff float64) { + ratio := float32(1.0) + if w.shiftPressed { + ratio *= 10 + } else if w.ctrlPressed { + ratio *= 0.1 + } + + if yoff > 0 { + w.Shader.FieldOfViewAngle -= ratio + if w.Shader.FieldOfViewAngle < 3.0 { + w.Shader.FieldOfViewAngle = 3.0 + } + } else if yoff < 0 { + w.Shader.FieldOfViewAngle += ratio + } +} + +func (w *GlWindow) handleMouseButtonEvent( + window *glfw.Window, + button glfw.MouseButton, + action glfw.Action, + mod glfw.ModifierKey, +) { + if button == glfw.MouseButtonMiddle { + if action == glfw.Press { + w.middleButtonPressed = true + w.updatedPrev = false + } else if action == glfw.Release { + w.middleButtonPressed = false + } + } else if button == glfw.MouseButtonRight { + if action == glfw.Press { + w.rightButtonPressed = true + w.updatedPrev = false + } else if action == glfw.Release { + w.rightButtonPressed = false + } + } else if button == glfw.MouseButtonLeft && w.funcWorldPos != nil && w.VisibleSelectedVertex { + if action == glfw.Press { + w.leftButtonPressed = true + w.updatedPrev = false + } else if action == glfw.Release { + w.leftButtonPressed = false + w.execWorldPos() + w.nowCursorPos = &mmath.MVec2{0, 0} + } + } +} + +func (gw *GlWindow) getWorldPosition( + x, y, z float32, +) *mmath.MVec3 { + // ウィンドウサイズを取得 + w, h := float32(gw.width), float32(gw.height) + + // プロジェクション行列の設定 + projection := mgl32.Perspective(mgl32.DegToRad(gw.Shader.FieldOfViewAngle), w/h, gw.Shader.NearPlane, gw.Shader.FarPlane) + mlog.V("Projection: %s", projection.String()) + + // カメラの位置と中心からビュー行列を計算 + cameraPosition := gw.Shader.CameraPosition.GL() + lookAtCenter := gw.Shader.LookAtCenterPosition.GL() + view := mgl32.LookAtV(cameraPosition, lookAtCenter, mgl32.Vec3{0, 1, 0}) + mlog.V("CameraPosition: %s, LookAtCenterPosition: %s", gw.Shader.CameraPosition.String(), gw.Shader.LookAtCenterPosition.String()) + mlog.V("View: %s", view.String()) + + worldCoords, err := mgl32.UnProject( + mgl32.Vec3{x, float32(gw.height) - y, z}, + view, projection, 0, 0, gw.width, gw.height) + if err != nil { + mlog.E("UnProject error: %v", err) + return nil + } + + worldPos := &mmath.MVec3{float64(-worldCoords.X()), float64(worldCoords.Y()), float64(worldCoords.Z())} + mlog.D("WindowPos [x=%.3f, y=%.3f, z=%.7f] -> WorldPos [x=%.3f, y=%.3f, z=%.3f]", + x, y, z, worldPos.GetX(), worldPos.GetY(), worldPos.GetZ()) + + return worldPos +} + +func (w GlWindow) execWorldPos() { + prevX := w.prevCursorPos.GetX() + prevY := w.prevCursorPos.GetY() + nowX := w.nowCursorPos.GetX() + nowY := w.nowCursorPos.GetY() + + vmdDeltas := make([]*vmd.VmdDeltas, len(w.modelSets)) + for i, modelSet := range w.modelSets { + vmdDeltas[i] = modelSet.prevDeltas + } + + if w.nowCursorPos.Length() == 0 || w.prevCursorPos.Distance(w.nowCursorPos) < 0.1 { + // カーソルが動いていない場合は直近のだけ取得 + // x: prev, y: prevのワールド座標位置 + depth := w.Shader.Msaa.ReadDepthAt(int(prevX), int(prevY), w.width, w.height) + worldPos := w.getWorldPosition(float32(prevX), float32(prevY), depth) + + w.funcWorldPos(worldPos, nil, nil, nil, nil, nil, nil, nil, vmdDeltas) + } else { + // x: prev, y: prevのワールド座標位置 + prevXprevYDepth := w.Shader.Msaa.ReadDepthAt(int(prevX), int(prevY), w.width, w.height) + prevXnowYDepth := w.Shader.Msaa.ReadDepthAt(int(prevX), int(nowY), w.width, w.height) + nowXprevYDepth := w.Shader.Msaa.ReadDepthAt(int(nowX), int(prevY), w.width, w.height) + nowXnowYDepth := w.Shader.Msaa.ReadDepthAt(int(nowX), int(nowY), w.width, w.height) + + mlog.D("prevXprevYDepth=%.3f, prevXnowYDepth=%.3f, nowXprevYDepth=%.3f, nowXnowYDepth=%.3f", + prevXprevYDepth, prevXnowYDepth, nowXprevYDepth, nowXnowYDepth) + + // 最も手前を基準とする + depth := min(prevXprevYDepth, prevXnowYDepth, nowXprevYDepth, nowXnowYDepth) + + prevXprevYFrontPos := w.getWorldPosition(float32(prevX), float32(prevY), max(depth-1e-5, 0.0)) + prevXprevYBackPos := w.getWorldPosition(float32(prevX), float32(prevY), min(depth+1e-5, 1.0)) + + // x: prev, y: nowのワールド座標位置 + prevXnowYFrontPos := w.getWorldPosition(float32(prevX), float32(nowY), max(depth-1e-5, 0.0)) + prevXnowYBackPos := w.getWorldPosition(float32(prevX), float32(nowY), min(depth+1e-5, 1.0)) + + // x: now, y: prevのワールド座標位置 + nowXprevYFrontPos := w.getWorldPosition(float32(nowX), float32(prevY), max(depth-1e-5, 0.0)) + nowXprevYBackPos := w.getWorldPosition(float32(nowX), float32(prevY), min(depth+1e-5, 1.0)) + + // x: now, y: nowのワールド座標位置 + nowXnowYFrontPos := w.getWorldPosition(float32(nowX), float32(nowY), max(depth-1e-5, 0.0)) + nowXnowYBackPos := w.getWorldPosition(float32(nowX), float32(nowY), min(depth+1e-5, 1.0)) + + w.funcWorldPos(prevXprevYFrontPos, prevXprevYBackPos, prevXnowYFrontPos, prevXnowYBackPos, nowXprevYFrontPos, nowXprevYBackPos, nowXnowYFrontPos, nowXnowYBackPos, vmdDeltas) + } +} + +func (w *GlWindow) updateCameraAngle(xpos, ypos float64) { + + ratio := 0.1 + if w.shiftPressed { + ratio *= 10 + } else if w.ctrlPressed { + ratio *= 0.1 + } + + // 右クリックはカメラ中心をそのままにカメラ位置を変える + xOffset := (w.prevCursorPos.GetX() - xpos) * ratio + yOffset := (w.prevCursorPos.GetY() - ypos) * ratio + + // 方位角と仰角を更新 + w.yaw += xOffset + w.pitch += yOffset + + // 仰角の制限（水平面より上下に行き過ぎないようにする） + if w.pitch > RIGHT_ANGLE { + w.pitch = RIGHT_ANGLE + } else if w.pitch < -RIGHT_ANGLE { + w.pitch = -RIGHT_ANGLE + } + + // 方位角の制限（360度を超えないようにする） + if w.yaw > 360.0 { + w.yaw -= 360.0 + } else if w.yaw < -360.0 { + w.yaw += 360.0 + } + + // 球面座標系をデカルト座標系に変換 + // radius := float64(-w.Shader.CameraPosition.Sub(w.Shader.LookAtCenterPosition).Length()) + radius := float64(mview.INITIAL_CAMERA_POSITION_Z) + cameraX := radius * math.Cos(mgl64.DegToRad(w.pitch)) * math.Cos(mgl64.DegToRad(w.yaw)) + cameraY := radius * math.Sin(mgl64.DegToRad(w.pitch)) + cameraZ := radius * math.Cos(mgl64.DegToRad(w.pitch)) * math.Sin(mgl64.DegToRad(w.yaw)) + + // カメラ位置を更新 + w.Shader.CameraPosition.SetX(cameraX) + w.Shader.CameraPosition.SetY(mview.INITIAL_CAMERA_POSITION_Y + cameraY) + w.Shader.CameraPosition.SetZ(cameraZ) + // mlog.D("xOffset %.7f, yOffset %.7f, CameraPosition: %s, LookAtCenterPosition: %s\n", + // xOffset, yOffset, w.Shader.CameraPosition.String(), w.Shader.LookAtCenterPosition.String()) +} + +func (w *GlWindow) updateCameraPosition(xpos, ypos float64) { + + ratio := 0.07 + if w.shiftPressed { + ratio *= 10 + } else if w.ctrlPressed { + ratio *= 0.1 + } + // 中ボタンが押された場合の処理 + if w.middleButtonPressed { + ratio := 0.07 + if w.shiftPressed { + ratio *= 10 + } else if w.ctrlPressed { + ratio *= 0.1 + } + + xOffset := (w.prevCursorPos.GetX() - xpos) * ratio + yOffset := (w.prevCursorPos.GetY() - ypos) * ratio + + // カメラの向きに基づいて移動方向を計算 + forward := w.Shader.LookAtCenterPosition.Subed(w.Shader.CameraPosition) + right := forward.Cross(mmath.MVec3UnitY).Normalize() + up := right.Cross(forward.Normalize()).Normalize() + + // 上下移動のベクトルを計算 + upMovement := up.MulScalar(-yOffset) + // 左右移動のベクトルを計算 + rightMovement := right.MulScalar(-xOffset) + + // 移動ベクトルを合成してカメラ位置と中心を更新 + movement := upMovement.Add(rightMovement) + w.Shader.CameraPosition.Add(movement) + w.Shader.LookAtCenterPosition.Add(movement) + } +} + +func (w *GlWindow) handleCursorPosEvent(window *glfw.Window, xpos float64, ypos float64) { + // mlog.D("[start] yaw %.7f, pitch %.7f, CameraPosition: %s, LookAtCenterPosition: %s\n", + // w.yaw, w.pitch, w.Shader.CameraPosition.String(), w.Shader.LookAtCenterPosition.String()) + + if !w.updatedPrev { + w.prevCursorPos.SetX(xpos) + w.prevCursorPos.SetY(ypos) + w.updatedPrev = true + return + } + + if w.leftButtonPressed { + w.nowCursorPos.SetX(xpos) + w.nowCursorPos.SetY(ypos) + return + } else if w.rightButtonPressed { + // 右クリックはカメラの角度を更新 + w.updateCameraAngle(xpos, ypos) + } else if w.middleButtonPressed { + // 中クリックはカメラ位置と中心を移動 + w.updateCameraPosition(xpos, ypos) + } + + w.prevCursorPos.SetX(xpos) + w.prevCursorPos.SetY(ypos) +} + +func (w *GlWindow) TriggerPhysicsEnabled(enabled bool) { + w.enablePhysics = enabled + for i := range w.modelSets { + w.modelSets[i].prevDeltas = nil + } +} + +func (w *GlWindow) TriggerPhysicsReset() { + if !w.doResetPhysicsProgress { + w.doResetPhysicsStart = true + } +} + +func (w *GlWindow) resetPhysicsStart() { + // 物理ON・まだリセット中ではないの時だけリセット処理を行う + if w.enablePhysics && !w.doResetPhysicsProgress { + // 一旦物理OFFにする + w.TriggerPhysicsEnabled(false) + w.Physics.ResetWorld() + w.doResetPhysicsStart = false + w.doResetPhysicsProgress = true + w.doResetPhysicsCount = 0 + } +} + +func (w *GlWindow) resetPhysicsFinish() { + // 物理ONに戻してリセットフラグを落とす + w.TriggerPhysicsEnabled(true) + w.doResetPhysicsStart = false + w.doResetPhysicsProgress = false + w.doResetPhysicsCount = 0 +} + +func (w *GlWindow) TriggerViewReset() { + // カメラとかリセット + w.Shader.Reset() + w.prevCursorPos = &mmath.MVec2{0, 0} + w.yaw = RIGHT_ANGLE + w.pitch = 0.0 + w.middleButtonPressed = false + w.rightButtonPressed = false + +} + +func (w *GlWindow) Size() walk.Size { + x, y := w.Window.GetSize() + return walk.Size{Width: x, Height: y} +} + +func (w *GlWindow) Run() { + prevTime := glfw.GetTime() + prevShowTime := glfw.GetTime() + w.prevFrame = 0 + w.running = true + + go func() { + channelLoop: + for { + select { + case pair := <-w.AppendModelSetChannel: + // 追加処理 + w.modelSets[len(w.modelSets)-1] = pair + w.isSaveDelta = false + case pairMap := <-w.ReplaceModelSetChannel: + // 入替処理 + for i := range pairMap { + // 変更が加えられている可能性があるので、セットアップ実施（変更がなければスルーされる） + if pairMap[i].NextModel != nil { + pairMap[i].NextModel.Setup() + } + + for j := len(w.modelSets); j <= i; j++ { + // 既存のモデルセットがない場合は追加 + w.modelSets = append(w.modelSets, NewModelSet()) + } + + w.modelSets[i].NextModel = pairMap[i].NextModel + w.modelSets[i].NextMotion = pairMap[i].NextMotion + w.modelSets[i].NextSelectedVertexIndexes = pairMap[i].NextSelectedVertexIndexes + w.modelSets[i].NextInvisibleMaterialIndexes = pairMap[i].NextInvisibleMaterialIndexes + } + w.isSaveDelta = false + case index := <-w.RemoveModelSetIndexChannel: + // 削除処理 + if index < len(w.modelSets) { + if w.modelSets[index].Model != nil { + w.modelSets[index].Model.Delete() + } + w.modelSets[index] = NewModelSet() + } + w.isSaveDelta = false + case isPlaying := <-w.IsPlayingChannel: + // 再生設定 + w.TriggerPlay(isPlaying) + case frame := <-w.FrameChannel: + // フレーム設定 + w.SetFrame(frame) + case isClosed := <-w.IsClosedChannel: + // ウィンドウが閉じられた場合 + w.isClosed = isClosed + break channelLoop + } + } + }() + + for { + glfw.PollEvents() + + if !w.IsRunning() { + goto closeApp + } + + if w.width == 0 || w.height == 0 { + // ウィンドウが最小化されている場合は描画をスキップ(フレームも進めない) + prevTime = glfw.GetTime() + continue + } + + if w.playing && w.motionPlayer != nil && w.frame >= w.motionPlayer.FrameEdit.MaxValue() { + // 再生中に最後までいったら最初にループして戻る + w.TriggerPhysicsReset() + w.SetFrame(0) + + go func() { + w.motionPlayer.SetValue(int(w.frame)) + }() + } + + frameTime := glfw.GetTime() + originalElapsed := frameTime - prevTime + + var elapsed float64 + var timeStep float32 + if !w.EnableFrameDrop { + // フレームドロップOFF + // 物理fpsは60fps固定 + timeStep = w.Physics.PhysicsSpf + // デフォームfpsは30fps上限の経過時間 + elapsed = mmath.ClampedFloat(originalElapsed, 0.0, float64(w.Physics.DeformSpf)) + } else { + // 物理fpsは経過時間 + timeStep = float32(originalElapsed) + elapsed = originalElapsed + } + + if elapsed < w.spfLimit { + // 1フレームの時間が経過していない場合はスキップ + // fps制限は描画fpsにのみ依存 + continue + } + + w.MakeContextCurrent() + + // MSAAフレームバッファをバインド + w.Shader.Msaa.Bind() + + // 深度バッファのクリア + gl.ClearColor(0.7, 0.7, 0.7, 1.0) + gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) + + // 隠面消去 + // https://learnopengl.com/Advanced-OpenGL/Depth-testing + gl.Enable(gl.DEPTH_TEST) + gl.DepthFunc(gl.LEQUAL) + + // ブレンディングを有効にする + gl.Enable(gl.BLEND) + gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) + + // カメラの再計算 + projection := mgl32.Perspective( + mgl32.DegToRad(w.Shader.FieldOfViewAngle), + float32(w.Shader.Width)/float32(w.Shader.Height), + w.Shader.NearPlane, + w.Shader.FarPlane, + ) + + // カメラの位置 + cameraPosition := w.Shader.CameraPosition.GL() + + // カメラの中心 + lookAtCenter := w.Shader.LookAtCenterPosition.GL() + camera := mgl32.LookAtV(cameraPosition, lookAtCenter, mgl32.Vec3{0, 1, 0}) + + for _, program := range w.Shader.GetPrograms() { + // プログラムの切り替え + gl.UseProgram(program) + + // カメラの再計算 + projectionUniform := gl.GetUniformLocation(program, gl.Str(mview.SHADER_MODEL_VIEW_PROJECTION_MATRIX)) + gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0]) + + // カメラの位置 + cameraPositionUniform := gl.GetUniformLocation(program, gl.Str(mview.SHADER_CAMERA_POSITION)) + gl.Uniform3fv(cameraPositionUniform, 1, &cameraPosition[0]) + + // カメラの中心 + cameraUniform := gl.GetUniformLocation(program, gl.Str(mview.SHADER_MODEL_VIEW_MATRIX)) + gl.UniformMatrix4fv(cameraUniform, 1, false, &camera[0]) + + gl.UseProgram(0) + } + + // 床平面を描画 + w.drawFloor() + + if w.playing { + // 経過秒数をキーフレームの進捗具合に合わせて調整 + if w.spfLimit < -1 { + // デフォームFPS制限なしの場合、フレーム番号を常に進める + w.frame += 1.0 + } else { + w.frame += elapsed * float64(w.Physics.DeformFps) + } + } + + if w.doResetPhysicsStart { + // 物理リセット開始 + w.resetPhysicsStart() + } + + // デフォーム + w.modelSets = deformsAll( + w.Physics, w.modelSets, int(w.frame), w.prevFrame, + timeStep, w.enablePhysics, w.doResetPhysicsProgress) + + // 描画 + for k := range w.modelSets { + if w.modelSets[k].Model != nil && w.modelSets[k].prevDeltas != nil { + w.modelSets[k].prevDeltas = draw( + w.Physics, w.modelSets[k].Model, w.Shader, w.modelSets[k].prevDeltas, + w.modelSets[k].InvisibleMaterialIndexes, w.modelSets[k].NextInvisibleMaterialIndexes, + w.WindowIndex, w.VisibleNormal, w.VisibleWire, w.VisibleSelectedVertex, w.VisibleBones) + } + + if w.modelSets[k].NextMotion != nil { + w.TriggerPhysicsReset() + + w.modelSets[k].Motion = w.modelSets[k].NextMotion + w.modelSets[k].NextMotion = nil + w.isSaveDelta = false + } + + // モデルが変わっている場合は最新の情報を取得する + if w.modelSets[k].NextModel != nil { + w.TriggerPhysicsReset() + + // 次のモデルが指定されている場合、初期化して入替 + if w.modelSets[k].Model != nil && w.modelSets[k].Model.DrawInitialized { + // 既存モデルが描画初期化されてたら削除 + w.modelSets[k].Model.Delete() + w.modelSets[k].Model = nil + } + if !w.modelSets[k].NextModel.DrawInitialized { + w.modelSets[k].NextModel.Index = k + w.modelSets[k].NextModel.DrawInitialize(w.WindowIndex, w.Physics) + } + w.modelSets[k].Model = w.modelSets[k].NextModel + w.modelSets[k].NextModel = nil + w.isSaveDelta = false + } + + if w.modelSets[k].NextInvisibleMaterialIndexes != nil { + w.modelSets[k].InvisibleMaterialIndexes = w.modelSets[k].NextInvisibleMaterialIndexes + w.modelSets[k].NextInvisibleMaterialIndexes = nil + } + + if w.modelSets[k].NextSelectedVertexIndexes != nil { + w.modelSets[k].SelectedVertexIndexes = w.modelSets[k].NextSelectedVertexIndexes + w.modelSets[k].NextSelectedVertexIndexes = nil + } + + // キーフレの手動変更がなかった場合のみ前回デフォームとして保持 + if !w.isSaveDelta { + w.modelSets[k].prevDeltas = nil + } + w.isSaveDelta = true + } + + if w.doResetPhysicsProgress { + if w.doResetPhysicsCount > 1 { + // 0: 物理リセット開始 + // 1: 物理リセット中(リセット状態で物理更新) + // 2: 物理リセット完了 + // 物理リセット完了 + w.resetPhysicsFinish() + } else { + w.doResetPhysicsCount++ + } + } + + prevTime = frameTime + + if w.playing && int(w.frame) > w.prevFrame { + // フレーム番号上書き + w.prevFrame = int(w.frame) + if w.playing && w.motionPlayer != nil { + go func() { + w.motionPlayer.SetValue(int(w.frame)) + }() + } + } + + w.Shader.Msaa.Resolve() + w.Shader.Msaa.Unbind() + + // 物理デバッグ表示（要不要は中で見ている）MSAAには含めない + w.Physics.DrawDebugLines() + + w.SwapBuffers() + + if w.isShowInfo { + nowShowTime := glfw.GetTime() + // 1秒ごとにオリジナルの経過時間からFPSを表示 + if nowShowTime-prevShowTime >= 1.0 { + var suffixFps string + if w.appConfig.IsEnvProd() { + // リリース版の場合、FPSの表示を簡略化 + suffixFps = fmt.Sprintf("%.2f fps", 1.0/elapsed) + } else { + // 開発版の場合、FPSの表示を詳細化 + suffixFps = fmt.Sprintf("d) %.2f (%.2f) / p) %.2f fps", 1.0/elapsed, 1/originalElapsed, 1.0/timeStep) + } + + w.Window.SetTitle(fmt.Sprintf("%s - %s", w.title, suffixFps)) + prevShowTime = nowShowTime + } + } else { + w.Window.SetTitle(w.title) + } + + // if w.frame > 100 { + // goto closeApp + // } + } + +closeApp: + w.Shader.Delete() + for i := range w.modelSets { + w.modelSets[i].Model.Delete() + } + if w.WindowIndex == 0 { + glfw.Terminate() + walk.App().Exit(0) + } +} + +func (w *GlWindow) IsRunning() bool { + return !w.isClosed && // walkウィンドウ側が閉じられたか + w.running && // GLウィンドウ側が閉じられたか + !CheckOpenGLError() && !w.ShouldClose() && + ((w.mWindow != nil && !w.mWindow.IsDisposed()) || w.mWindow == nil) +} + +// 床描画 ------------------ + +type MFloor struct { + vao *mview.VAO + vbo *mview.VBO + count int32 +} + +func newMFloor() *MFloor { + mf := &MFloor{} + + mf.vao = mview.NewVAO() + mf.vao.Bind() + mf.vbo, mf.count = mview.NewVBOForFloor() + mf.vbo.Unbind() + mf.vao.Unbind() + + return mf +} + +func (w *GlWindow) drawFloor() { + // mlog.D("MFloor.DrawLine") + w.Shader.Use(mview.PROGRAM_TYPE_FLOOR) + + // 平面を引く + w.floor.vao.Bind() + w.floor.vbo.BindFloor() + + gl.DrawArrays(gl.LINES, 0, w.floor.count) + + w.floor.vbo.Unbind() + w.floor.vao.Unbind() + + w.Shader.Unuse() +} diff --git a/pkg/mwidget/icon/pause.png b/pkg/mwidget/icon/pause.png new file mode 100644 index 00000000..3e0f8863 Binary files /dev/null and b/pkg/mwidget/icon/pause.png differ diff --git a/pkg/mwidget/icon/play.png b/pkg/mwidget/icon/play.png new file mode 100644 index 00000000..78fa76e1 Binary files /dev/null and b/pkg/mwidget/icon/play.png differ diff --git a/pkg/mwidget/icon/repeat.png b/pkg/mwidget/icon/repeat.png new file mode 100644 index 00000000..86943074 Binary files /dev/null and b/pkg/mwidget/icon/repeat.png differ diff --git a/pkg/mwidget/m_tab.go b/pkg/mwidget/m_tab.go new file mode 100644 index 00000000..fcae974d --- /dev/null +++ b/pkg/mwidget/m_tab.go @@ -0,0 +1,48 @@ +//go:build windows +// +build windows + +package mwidget + +import ( + "github.com/miu200521358/walk/pkg/walk" + + "github.com/miu200521358/mlib_go/pkg/mutils/mi18n" +) + +type MTabWidget struct { + *walk.TabWidget +} + +func NewMTabWidget(mWindow *MWindow) *MTabWidget { + tabWidget, err := walk.NewTabWidget(mWindow) + CheckError(err, mWindow, mi18n.T("タブウィジェット生成エラー")) + + bg, err := walk.NewSystemColorBrush(walk.SysColorBackground) + CheckError(err, mWindow, mi18n.T("背景色生成エラー")) + tabWidget.SetBackground(bg) + + return &MTabWidget{TabWidget: tabWidget} +} + +type MTabPage struct { + *walk.TabPage + mWindow *MWindow +} + +func NewMTabPage(mWindow *MWindow, tabWidget *MTabWidget, title string) (*MTabPage, error) { + tabPage, err := walk.NewTabPage() + if err != nil { + return nil, err + } + + tabWidget.Pages().Add(tabPage) + tabPage.SetTitle(title) + + bg, err := walk.NewSystemColorBrush(walk.SysColor3DFace) + if err != nil { + return nil, err + } + tabPage.SetBackground(bg) + + return &MTabPage{TabPage: tabPage, mWindow: mWindow}, nil +} diff --git a/pkg/mwidget/m_window.go b/pkg/mwidget/m_window.go new file mode 100644 index 00000000..10897be8 --- /dev/null +++ b/pkg/mwidget/m_window.go @@ -0,0 +1,609 @@ +//go:build windows +// +build windows + +package mwidget + +import ( + "fmt" + "image" + + "github.com/miu200521358/walk/pkg/declarative" + "github.com/miu200521358/walk/pkg/walk" + "golang.org/x/sys/windows" + + "github.com/miu200521358/mlib_go/pkg/mutils/mconfig" + "github.com/miu200521358/mlib_go/pkg/mutils/mi18n" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +type MWindow struct { + *walk.MainWindow + TabWidget *MTabWidget // タブウィジェット + isHorizontal bool // 横並びであるか否か + GlWindows []*GlWindow // 描画ウィンドウ + ConsoleView *ConsoleView // コンソールビュー + frameDropAction *walk.Action // フレームドロップON/OFF + physicsAction *walk.Action // 物理ON/OFF + physicsResetAction *walk.Action // 物理リセット + normalDebugAction *walk.Action // ボーンデバッグ表示 + wireDebugAction *walk.Action // ワイヤーフレームデバッグ表示 + selectedVertexDebugAction *walk.Action // 選択頂点デバッグ表示 + boneDebugAllAction *walk.Action // 全ボーンデバッグ表示 + boneDebugIkAction *walk.Action // IKボーンデバッグ表示 + boneDebugEffectorAction *walk.Action // 付与親ボーンデバッグ表示 + boneDebugFixedAction *walk.Action // 軸制限ボーンデバッグ表示 + boneDebugRotateAction *walk.Action // 回転ボーンデバッグ表示 + boneDebugTranslateAction *walk.Action // 移動ボーンデバッグ表示 + boneDebugVisibleAction *walk.Action // 表示ボーンデバッグ表示 + rigidBodyFrontDebugAction *walk.Action // 剛体デバッグ表示(前面) + rigidBodyBackDebugAction *walk.Action // 剛体デバッグ表示(埋め込み) + jointDebugAction *walk.Action // ジョイントデバッグ表示 + infoDebugAction *walk.Action // 情報デバッグ表示 + fps30LimitAction *walk.Action // 30FPS制限 + fps60LimitAction *walk.Action // 60FPS制限 + fpsUnLimitAction *walk.Action // FPS無制限 + logLevelDebugAction *walk.Action // デバッグメッセージ表示 + logLevelVerboseAction *walk.Action // 冗長メッセージ表示 + logLevelIkVerboseAction *walk.Action // IK冗長メッセージ表示 + fpsDeformUnLimitAction *walk.Action // デフォームFPS無制限 +} + +func NewMWindow( + width int, + height int, + funcHelpMenuItems func() []declarative.MenuItem, + iconImg *image.Image, + appConfig *mconfig.AppConfig, + isHorizontal bool, +) (*MWindow, error) { + mainWindow := &MWindow{ + isHorizontal: isHorizontal, + GlWindows: []*GlWindow{}, + } + + logMenuItems := []declarative.MenuItem{ + declarative.Action{ + Text: mi18n.T("&使い方"), + OnTriggered: func() { + mlog.ILT(mi18n.T("メイン画面の使い方"), mi18n.T("メイン画面の使い方メッセージ")) + }, + }, + declarative.Separator{}, + declarative.Action{ + Text: mi18n.T("&デバッグログ表示"), + Checkable: true, + OnTriggered: mainWindow.logLevelTriggered, + AssignTo: &mainWindow.logLevelDebugAction, + }, + } + + if !appConfig.IsEnvProd() { + // 開発時のみ冗長ログ表示を追加 + logMenuItems = append(logMenuItems, + declarative.Separator{}) + logMenuItems = append(logMenuItems, + declarative.Action{ + Text: mi18n.T("&冗長ログ表示"), + Checkable: true, + OnTriggered: mainWindow.logLevelTriggered, + AssignTo: &mainWindow.logLevelVerboseAction, + }) + logMenuItems = append(logMenuItems, + declarative.Action{ + Text: mi18n.T("&IK冗長ログ表示"), + Checkable: true, + OnTriggered: mainWindow.logLevelTriggered, + AssignTo: &mainWindow.logLevelIkVerboseAction, + }) + } + + fpsLImitMenuItems := []declarative.MenuItem{ + declarative.Action{ + Text: mi18n.T("&30fps制限"), + Checkable: true, + OnTriggered: mainWindow.fps30LimitTriggered, + AssignTo: &mainWindow.fps30LimitAction, + }, + declarative.Action{ + Text: mi18n.T("&60fps制限"), + Checkable: true, + OnTriggered: mainWindow.fps60LimitTriggered, + AssignTo: &mainWindow.fps60LimitAction, + }, + declarative.Action{ + Text: mi18n.T("&fps無制限"), + Checkable: true, + OnTriggered: mainWindow.fpsUnLimitTriggered, + AssignTo: &mainWindow.fpsUnLimitAction, + }, + } + + if !appConfig.IsEnvProd() { + // 開発時にだけ描画無制限モードを追加 + fpsLImitMenuItems = append(fpsLImitMenuItems, + declarative.Action{ + Text: "&デフォームfps無制限", + Checkable: true, + OnTriggered: mainWindow.fpsDeformUnLimitTriggered, + AssignTo: &mainWindow.fpsDeformUnLimitAction, + }) + } + + if err := (declarative.MainWindow{ + AssignTo: &mainWindow.MainWindow, + Title: fmt.Sprintf("%s %s", appConfig.Name, appConfig.Version), + Size: getWindowSize(width, height), + Layout: declarative.VBox{Alignment: declarative.AlignHNearVNear, MarginsZero: true, SpacingZero: true}, + MenuItems: []declarative.MenuItem{ + declarative.Menu{ + Text: mi18n.T("&ビューワー"), + Items: []declarative.MenuItem{ + declarative.Action{ + Text: mi18n.T("&フレームドロップON"), + Checkable: true, + OnTriggered: mainWindow.frameDropTriggered, + AssignTo: &mainWindow.frameDropAction, + }, + declarative.Separator{}, + declarative.Action{ + Text: mi18n.T("&物理ON/OFF"), + Checkable: true, + OnTriggered: mainWindow.physicsTriggered, + AssignTo: &mainWindow.physicsAction, + }, + declarative.Action{ + Text: mi18n.T("&物理リセット"), + OnTriggered: mainWindow.physicsResetTriggered, + AssignTo: &mainWindow.physicsResetAction, + }, + declarative.Separator{}, + declarative.Action{ + Text: mi18n.T("&法線表示"), + Checkable: true, + OnTriggered: mainWindow.normalDebugViewTriggered, + AssignTo: &mainWindow.normalDebugAction, + }, + declarative.Action{ + Text: mi18n.T("&ワイヤーフレーム表示"), + Checkable: true, + OnTriggered: mainWindow.wireDebugViewTriggered, + AssignTo: &mainWindow.wireDebugAction, + }, + declarative.Action{ + Text: mi18n.T("&選択頂点表示"), + Checkable: true, + OnTriggered: mainWindow.selectedVertexDebugViewTriggered, + AssignTo: &mainWindow.selectedVertexDebugAction, + }, + declarative.Separator{}, + declarative.Menu{ + Text: mi18n.T("&ボーン表示"), + Items: []declarative.MenuItem{ + declarative.Action{ + Text: mi18n.T("&全ボーン"), + Checkable: true, + OnTriggered: mainWindow.boneDebugViewAllTriggered, + AssignTo: &mainWindow.boneDebugAllAction, + }, + declarative.Separator{}, + declarative.Action{ + Text: mi18n.T("&IKボーン"), + Checkable: true, + OnTriggered: mainWindow.boneDebugViewIndividualTriggered, + AssignTo: &mainWindow.boneDebugIkAction, + }, + declarative.Action{ + Text: mi18n.T("&付与親ボーン"), + Checkable: true, + OnTriggered: mainWindow.boneDebugViewIndividualTriggered, + AssignTo: &mainWindow.boneDebugEffectorAction, + }, + declarative.Action{ + Text: mi18n.T("&軸制限ボーン"), + Checkable: true, + OnTriggered: mainWindow.boneDebugViewIndividualTriggered, + AssignTo: &mainWindow.boneDebugFixedAction, + }, + declarative.Action{ + Text: mi18n.T("&回転ボーン"), + Checkable: true, + OnTriggered: mainWindow.boneDebugViewIndividualTriggered, + AssignTo: &mainWindow.boneDebugRotateAction, + }, + declarative.Action{ + Text: mi18n.T("&移動ボーン"), + Checkable: true, + OnTriggered: mainWindow.boneDebugViewIndividualTriggered, + AssignTo: &mainWindow.boneDebugTranslateAction, + }, + declarative.Action{ + Text: mi18n.T("&表示ボーン"), + Checkable: true, + OnTriggered: mainWindow.boneDebugViewIndividualTriggered, + AssignTo: &mainWindow.boneDebugVisibleAction, + }, + }, + }, + declarative.Separator{}, + declarative.Menu{ + Text: mi18n.T("&剛体表示"), + Items: []declarative.MenuItem{ + declarative.Action{ + Text: mi18n.T("&前面表示"), + Checkable: true, + OnTriggered: mainWindow.rigidBodyDebugFrontViewTriggered, + AssignTo: &mainWindow.rigidBodyFrontDebugAction, + }, + declarative.Action{ + Text: mi18n.T("&埋め込み表示"), + Checkable: true, + OnTriggered: mainWindow.rigidBodyDebugBackViewTriggered, + AssignTo: &mainWindow.rigidBodyBackDebugAction, + }, + }, + }, + declarative.Action{ + Text: mi18n.T("&ジョイント表示"), + Checkable: true, + OnTriggered: mainWindow.jointDebugViewTriggered, + AssignTo: &mainWindow.jointDebugAction, + }, + declarative.Separator{}, + declarative.Action{ + Text: mi18n.T("&情報表示"), + Checkable: true, + OnTriggered: mainWindow.infoDebugViewTriggered, + AssignTo: &mainWindow.infoDebugAction, + }, + declarative.Menu{ + Text: mi18n.T("&fps制限"), + Items: fpsLImitMenuItems, + }, + declarative.Separator{}, + declarative.Action{ + Text: mi18n.T("&使い方"), + OnTriggered: func() { + mlog.ILT(mi18n.T("ビューワーの使い方"), mi18n.T("ビューワーの使い方メッセージ")) + }, + }, + }, + }, + declarative.Menu{ + Text: mi18n.T("&メイン画面"), + Items: logMenuItems, + }, + declarative.Menu{ + Text: mi18n.T("&使い方"), + Items: funcHelpMenuItems(), + }, + declarative.Menu{ + Text: mi18n.T("&言語"), + Items: []declarative.MenuItem{ + declarative.Action{ + Text: "日本語", + OnTriggered: func() { mainWindow.langTriggered("ja") }, + }, + declarative.Action{ + Text: "English", + OnTriggered: func() { mainWindow.langTriggered("en") }, + }, + declarative.Action{ + Text: "中文", + OnTriggered: func() { mainWindow.langTriggered("zh") }, + }, + declarative.Action{ + Text: "한국어", + OnTriggered: func() { mainWindow.langTriggered("ko") }, + }, + }, + }, + }, + }).Create(); err != nil { + return nil, err + } + + // 最初は物理ON + mainWindow.physicsAction.SetChecked(true) + // 最初はフレームドロップON + mainWindow.frameDropAction.SetChecked(true) + // 最初は30fps制限 + mainWindow.fps30LimitAction.SetChecked(true) + + mainWindow.Closing().Attach(func(canceled *bool, reason walk.CloseReason) { + if len(mainWindow.GlWindows) > 0 && !CheckOpenGLError() { + for _, glWindow := range mainWindow.GlWindows { + glWindow.SetShouldClose(true) + } + } + walk.App().Exit(0) + }) + + icon, err := walk.NewIconFromImageForDPI(*iconImg, 96) + if err != nil { + return nil, err + } + mainWindow.SetIcon(icon) + + // タブウィジェット追加 + mainWindow.TabWidget = NewMTabWidget(mainWindow) + mainWindow.Children().Add(mainWindow.TabWidget) + + bg, err := walk.NewSystemColorBrush(walk.SysColor3DShadow) + CheckError(err, mainWindow, mi18n.T("背景色生成エラー")) + mainWindow.SetBackground(bg) + + return mainWindow, nil +} + +func (w *MWindow) logLevelTriggered() { + mlog.SetLevel(mlog.INFO) + if w.logLevelDebugAction.Checked() { + mlog.SetLevel(mlog.DEBUG) + } + if w.logLevelIkVerboseAction.Checked() { + mlog.SetLevel(mlog.IK_VERBOSE) + } + if w.logLevelVerboseAction.Checked() { + mlog.SetLevel(mlog.VERBOSE) + } +} + +func (w *MWindow) langTriggered(lang string) { + mi18n.SetLang(lang) + walk.MsgBox( + w.MainWindow, + mi18n.TWithLocale(lang, "LanguageChanged.Title"), + mi18n.TWithLocale(lang, "LanguageChanged.Message"), + walk.MsgBoxOK|walk.MsgBoxIconInformation, + ) + w.Close() +} + +func (w *MWindow) SetCheckWireDebugView(checked bool) { + w.wireDebugAction.SetChecked(checked) + w.wireDebugViewTriggered() +} + +func (w *MWindow) SetCheckSelectedVertexDebugView(checked bool) { + w.selectedVertexDebugAction.SetChecked(checked) + w.selectedVertexDebugViewTriggered() +} + +func (w *MWindow) normalDebugViewTriggered() { + for _, glWindow := range w.GlWindows { + glWindow.VisibleNormal = w.normalDebugAction.Checked() + } +} + +func (w *MWindow) wireDebugViewTriggered() { + for _, glWindow := range w.GlWindows { + glWindow.VisibleWire = w.wireDebugAction.Checked() + } +} + +func (w *MWindow) selectedVertexDebugViewTriggered() { + for _, glWindow := range w.GlWindows { + glWindow.VisibleSelectedVertex = w.selectedVertexDebugAction.Checked() + } +} + +func (w *MWindow) boneDebugViewAllTriggered() { + w.boneDebugIkAction.SetChecked(false) + w.boneDebugEffectorAction.SetChecked(false) + w.boneDebugFixedAction.SetChecked(false) + w.boneDebugRotateAction.SetChecked(false) + w.boneDebugTranslateAction.SetChecked(false) + w.boneDebugVisibleAction.SetChecked(false) + + w.boneDebugViewTriggered() +} + +func (w *MWindow) boneDebugViewIndividualTriggered() { + w.boneDebugAllAction.SetChecked(false) + + w.boneDebugViewTriggered() +} + +func (w *MWindow) boneDebugViewTriggered() { + for _, glWindow := range w.GlWindows { + // 全ボーン表示 + glWindow.VisibleBones[pmx.BONE_FLAG_NONE] = w.boneDebugAllAction.Checked() + // IKボーン表示 + glWindow.VisibleBones[pmx.BONE_FLAG_IS_IK] = w.boneDebugIkAction.Checked() + // 付与親ボーン表示 + glWindow.VisibleBones[pmx.BONE_FLAG_IS_EXTERNAL_ROTATION] = w.boneDebugEffectorAction.Checked() + glWindow.VisibleBones[pmx.BONE_FLAG_IS_EXTERNAL_TRANSLATION] = w.boneDebugEffectorAction.Checked() + // 軸制限ボーン表示 + glWindow.VisibleBones[pmx.BONE_FLAG_HAS_FIXED_AXIS] = w.boneDebugFixedAction.Checked() + // 回転ボーン表示 + glWindow.VisibleBones[pmx.BONE_FLAG_CAN_ROTATE] = w.boneDebugRotateAction.Checked() + // 移動ボーン表示 + glWindow.VisibleBones[pmx.BONE_FLAG_CAN_TRANSLATE] = w.boneDebugTranslateAction.Checked() + // 表示ボーン表示 + glWindow.VisibleBones[pmx.BONE_FLAG_IS_VISIBLE] = w.boneDebugVisibleAction.Checked() + } +} + +func (w *MWindow) rigidBodyDebugFrontViewTriggered() { + w.rigidBodyBackDebugAction.SetChecked(false) + for _, glWindow := range w.GlWindows { + glWindow.Physics.VisibleRigidBody(w.rigidBodyFrontDebugAction.Checked()) + glWindow.Shader.IsDrawRigidBodyFront = true + } +} + +func (w *MWindow) rigidBodyDebugBackViewTriggered() { + w.rigidBodyFrontDebugAction.SetChecked(false) + for _, glWindow := range w.GlWindows { + glWindow.Physics.VisibleRigidBody(w.rigidBodyBackDebugAction.Checked()) + glWindow.Shader.IsDrawRigidBodyFront = false + } +} + +func (w *MWindow) jointDebugViewTriggered() { + for _, glWindow := range w.GlWindows { + glWindow.Physics.VisibleJoint(w.jointDebugAction.Checked()) + } +} + +func (w *MWindow) infoDebugViewTriggered() { + for _, glWindow := range w.GlWindows { + glWindow.isShowInfo = w.infoDebugAction.Checked() + } +} + +func (w *MWindow) fps30LimitTriggered() { + w.fps30LimitAction.SetChecked(true) + w.fps60LimitAction.SetChecked(false) + w.fpsUnLimitAction.SetChecked(false) + w.fpsDeformUnLimitAction.SetChecked(false) + for _, glWindow := range w.GlWindows { + glWindow.spfLimit = 1 / 30.0 + } +} + +func (w *MWindow) fps60LimitTriggered() { + w.fps30LimitAction.SetChecked(false) + w.fps60LimitAction.SetChecked(true) + w.fpsUnLimitAction.SetChecked(false) + w.fpsDeformUnLimitAction.SetChecked(false) + for _, glWindow := range w.GlWindows { + glWindow.spfLimit = 1 / 60.0 + } +} + +func (w *MWindow) fpsUnLimitTriggered() { + w.fps30LimitAction.SetChecked(false) + w.fps60LimitAction.SetChecked(false) + w.fpsUnLimitAction.SetChecked(true) + w.fpsDeformUnLimitAction.SetChecked(false) + for _, glWindow := range w.GlWindows { + glWindow.spfLimit = -1.0 + } +} + +func (w *MWindow) fpsDeformUnLimitTriggered() { + w.fps30LimitAction.SetChecked(false) + w.fps60LimitAction.SetChecked(false) + w.fpsUnLimitAction.SetChecked(false) + w.fpsDeformUnLimitAction.SetChecked(true) + for _, glWindow := range w.GlWindows { + glWindow.spfLimit = -2.0 + } +} + +func (w *MWindow) physicsTriggered() { + for _, glWindow := range w.GlWindows { + glWindow.TriggerPhysicsEnabled(w.physicsAction.Checked()) + } +} + +func (w *MWindow) physicsResetTriggered() { + for _, glWindow := range w.GlWindows { + glWindow.TriggerPhysicsReset() + } +} + +func (w *MWindow) frameDropTriggered() { + for _, glWindow := range w.GlWindows { + glWindow.EnableFrameDrop = w.frameDropAction.Checked() + } +} + +func getWindowSize(width int, height int) declarative.Size { + screenWidth := GetSystemMetrics(SM_CXSCREEN) + screenHeight := GetSystemMetrics(SM_CYSCREEN) + + if width > screenWidth-50 { + width = screenWidth - 50 + } + if height > screenHeight-50 { + height = screenHeight - 50 + } + + return declarative.Size{Width: width, Height: height} +} + +func (w *MWindow) AddGlWindow(glWindow *GlWindow) { + w.GlWindows = append(w.GlWindows, glWindow) +} + +func (w *MWindow) GetMainGlWindow() *GlWindow { + if len(w.GlWindows) > 0 { + return w.GlWindows[0] + } + return nil +} + +func (w *MWindow) Center() { + // スクリーンの解像度を取得 + screenWidth := GetSystemMetrics(SM_CXSCREEN) + screenHeight := GetSystemMetrics(SM_CYSCREEN) + + // ウィンドウのサイズを取得 + windowSize := w.Size() + + glWindowWidth := 0 + glWindowHeight := 0 + for _, glWindow := range w.GlWindows { + glWindowWidth += glWindow.Size().Width + glWindowHeight += glWindow.Size().Height + } + + // ウィンドウを中央に配置 + if w.isHorizontal { + centerX := (screenWidth - (windowSize.Width + glWindowWidth)) / 2 + centerY := (screenHeight - windowSize.Height) / 2 + + centerX += glWindowWidth + w.SetX(centerX) + w.SetY(centerY) + + for _, glWindow := range w.GlWindows { + centerX -= glWindow.Size().Width + glWindow.SetPos(centerX, centerY) + } + } else { + centerX := (screenWidth - windowSize.Width) / 2 + centerY := (screenHeight - (windowSize.Height + glWindowHeight)) / 2 + + centerY += windowSize.Height + w.SetX(centerX) + w.SetY(centerY) + + for _, glWindow := range w.GlWindows { + centerY -= glWindow.Size().Height + glWindow.SetPos(centerX, centerY) + } + } +} + +func (w *MWindow) Dispose() { + for _, glWindow := range w.GlWindows { + glWindow.TriggerClose(glWindow.Window) + } + w.MainWindow.Dispose() + defer walk.App().Exit(0) +} + +var ( + user32 = windows.NewLazySystemDLL("user32.dll") + procGetSystemMetrics = user32.NewProc("GetSystemMetrics") + procMessageBeep = user32.NewProc("MessageBeep") + MB_ICONASTERISK = 0x00000040 +) + +func (w *MWindow) Beep() { + procMessageBeep.Call(uintptr(MB_ICONASTERISK)) +} + +const ( + SM_CXSCREEN = 0 + SM_CYSCREEN = 1 +) + +func GetSystemMetrics(nIndex int) int { + ret, _, _ := procGetSystemMetrics.Call(uintptr(nIndex)) + return int(ret) +} diff --git a/pkg/mwidget/model_draw.go b/pkg/mwidget/model_draw.go new file mode 100644 index 00000000..8b12173d --- /dev/null +++ b/pkg/mwidget/model_draw.go @@ -0,0 +1,251 @@ +//go:build windows +// +build windows + +package mwidget + +import ( + "sync" + + "github.com/go-gl/mathgl/mgl32" + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mphysics" + "github.com/miu200521358/mlib_go/pkg/mphysics/mbt" + "github.com/miu200521358/mlib_go/pkg/mview" + "github.com/miu200521358/mlib_go/pkg/pmx" + "github.com/miu200521358/mlib_go/pkg/vmd" +) + +type ModelSet struct { + Model *pmx.PmxModel // 現在描画中のモデル + Motion *vmd.VmdMotion // 現在描画中のモーション + InvisibleMaterialIndexes []int // 非表示材質インデックス + SelectedVertexIndexes []int // 選択頂点インデックス + NextModel *pmx.PmxModel // UIから渡された次のモデル + NextMotion *vmd.VmdMotion // UIから渡された次のモーション + NextInvisibleMaterialIndexes []int // UIから渡された次の非表示材質インデックス + NextSelectedVertexIndexes []int // UIから渡された次の選択頂点インデックス + prevDeltas *vmd.VmdDeltas // 前回のデフォーム情報 +} + +func NewModelSet() *ModelSet { + return &ModelSet{ + InvisibleMaterialIndexes: make([]int, 0), + SelectedVertexIndexes: make([]int, 0), + NextInvisibleMaterialIndexes: make([]int, 0), + NextSelectedVertexIndexes: make([]int, 0), + } +} + +func deformsAll( + modelPhysics *mphysics.MPhysics, + modelSets []*ModelSet, + frame, prevFrame int, + timeStep float32, + enablePhysics, resetPhysics bool, +) []*ModelSet { + + // 物理前デフォーム + { + var wg sync.WaitGroup + + for i := range modelSets { + if modelSets[i].Model == nil { + continue + } + + wg.Add(1) + go func(ii int) { + defer wg.Done() + + if int(frame) != prevFrame { + // フレーム番号が変わっている場合は前回デフォームを破棄 + modelSets[ii].prevDeltas = nil + } + + modelSets[ii].prevDeltas = deformBeforePhysics( + modelPhysics, modelSets[ii].Model, modelSets[ii].Motion, modelSets[ii].prevDeltas, + int(frame), timeStep, enablePhysics, resetPhysics, + ) + }(i) + } + + wg.Wait() + } + + if enablePhysics || resetPhysics { + // 物理更新 + modelPhysics.Update(timeStep) + } + + // 物理後デフォーム + { + var wg sync.WaitGroup + + for i := range modelSets { + if modelSets[i].Model == nil { + continue + } + + wg.Add(1) + go func(ii int) { + defer wg.Done() + + modelSets[ii].prevDeltas = deformAfterPhysics( + modelPhysics, modelSets[ii].Model, modelSets[ii].Motion, modelSets[ii].prevDeltas, + modelSets[ii].SelectedVertexIndexes, modelSets[ii].NextSelectedVertexIndexes, int(frame), + enablePhysics, resetPhysics, + ) + }(i) + } + + wg.Wait() + } + + return modelSets +} + +func deformBeforePhysics( + modelPhysics *mphysics.MPhysics, + model *pmx.PmxModel, + motion *vmd.VmdMotion, + prevDeltas *vmd.VmdDeltas, + frame int, + timeStep float32, + enablePhysics, resetPhysics bool, +) *vmd.VmdDeltas { + if motion == nil { + motion = vmd.NewVmdMotion("") + } + + vds := vmd.NewVmdDeltas(model.Vertices) + + // IKのON/OFF + ikFrame := motion.IkFrames.Get(frame) + + if prevDeltas == nil { + vds.Morphs = motion.DeformMorph(frame, model, nil) + vds.Bones = motion.BoneFrames.DeformByPhysicsFlag(frame, model, nil, true, + nil, vds.Morphs, ikFrame, false) + + vds.MeshGlDeltas = make([]*pmx.MeshDelta, len(model.Materials.Data)) + for i, md := range vds.Morphs.Materials.Data { + vds.MeshGlDeltas[i] = md.Result() + } + + vds.VertexMorphIndexes, vds.VertexMorphGlDeltas = vds.Morphs.Vertices.GL() + } else { + vds.Morphs = prevDeltas.Morphs + vds.Bones = prevDeltas.Bones + + vds.MeshGlDeltas = prevDeltas.MeshGlDeltas + + vds.VertexMorphIndexes = prevDeltas.VertexMorphIndexes + vds.VertexMorphGlDeltas = prevDeltas.VertexMorphGlDeltas + } + + for _, rigidBody := range model.RigidBodies.Data { + // 現在のボーン変形情報を保持 + rigidBodyBone := rigidBody.Bone + if rigidBodyBone == nil { + rigidBodyBone = rigidBody.JointedBone + } + if rigidBodyBone == nil || vds.Bones.Get(rigidBodyBone.Index) == nil { + continue + } + + // 物理フラグが落ちている場合があるので、強制的に起こす + forceUpdate := rigidBody.UpdateFlags(model.Index, modelPhysics, enablePhysics, resetPhysics) + forceUpdate = timeStep == 0.0 || !enablePhysics || forceUpdate + + if rigidBody.PhysicsType != pmx.PHYSICS_TYPE_DYNAMIC || forceUpdate { + // ボーン追従剛体・物理＋ボーン位置もしくは強制更新の場合のみ剛体位置更新 + boneTransform := mbt.NewBtTransform() + defer mbt.DeleteBtTransform(boneTransform) + mat := vds.Bones.Get(rigidBodyBone.Index).GlobalMatrix().GL() + boneTransform.SetFromOpenGLMatrix(&mat[0]) + + rigidBody.UpdateTransform(model.Index, modelPhysics, rigidBodyBone, boneTransform) + } + } + + return vds +} + +func deformAfterPhysics( + modelPhysics *mphysics.MPhysics, + model *pmx.PmxModel, + motion *vmd.VmdMotion, + deltas *vmd.VmdDeltas, + selectedVertexIndexes, nextSelectedVertexIndexes []int, + frame int, + enablePhysics, resetPhysics bool, +) *vmd.VmdDeltas { + if motion == nil { + motion = vmd.NewVmdMotion("") + } + + // 物理剛体位置を更新 + if enablePhysics || resetPhysics { + // IKのON/OFF + ikFrame := motion.IkFrames.Get(frame) + + for _, isAfterPhysics := range []bool{false, true} { + for _, bone := range model.Bones.LayerSortedBones[isAfterPhysics] { + if bone.RigidBody == nil || bone.RigidBody.PhysicsType == pmx.PHYSICS_TYPE_STATIC { + continue + } + bonePhysicsGlobalMatrix := bone.RigidBody.GetRigidBodyBoneMatrix(model.Index, modelPhysics) + if deltas.Bones != nil && bonePhysicsGlobalMatrix != nil { + bd := vmd.NewBoneDeltaByGlobalMatrix(bone, frame, + bonePhysicsGlobalMatrix, deltas.Bones.Get(bone.ParentIndex)) + deltas.Bones.Update(bd) + } + } + } + + // 物理後のデフォーム情報 + deltas.Bones = motion.BoneFrames.DeformByPhysicsFlag(frame, model, nil, true, + deltas.Bones, deltas.Morphs, ikFrame, true) + } + + // GL描画用データの作成 + deltas.BoneGlDeltas = make([]mgl32.Mat4, len(model.Bones.Data)) + for i, bone := range model.Bones.Data { + delta := deltas.Bones.Get(bone.Index) + if delta != nil { + deltas.BoneGlDeltas[i] = delta.LocalMatrix().GL() + } + } + + // 選択頂点モーフの設定は常に更新する + deltas.SelectedVertexIndexes, deltas.SelectedVertexGlDeltas = deltas.SelectedVertexDeltas.GL( + model, selectedVertexIndexes, nextSelectedVertexIndexes) + + return deltas +} + +func draw( + modelPhysics *mphysics.MPhysics, + model *pmx.PmxModel, + shader *mview.MShader, + deltas *vmd.VmdDeltas, + invisibleMaterialIndexes, nextInvisibleMaterialIndexes []int, + windowIndex int, + isDrawNormal, isDrawWire, isDrawSelectedVertex bool, + isDrawBones map[pmx.BoneFlag]bool, +) *vmd.VmdDeltas { + vertexPositions := model.Meshes.Draw( + shader, deltas.BoneGlDeltas, deltas.VertexMorphIndexes, deltas.VertexMorphGlDeltas, + deltas.SelectedVertexIndexes, deltas.SelectedVertexGlDeltas, deltas.MeshGlDeltas, + invisibleMaterialIndexes, nextInvisibleMaterialIndexes, windowIndex, + isDrawNormal, isDrawWire, isDrawSelectedVertex, isDrawBones, model.Bones) + + for i, pos := range vertexPositions { + deltas.Vertices.Data[i] = vmd.NewVertexDelta(&mmath.MVec3{float64(-pos[0]), float64(pos[1]), float64(pos[2])}) + } + + // 物理デバッグ表示 + modelPhysics.DebugDrawWorld() + + return deltas +} diff --git a/pkg/mwidget/motion_player.go b/pkg/mwidget/motion_player.go new file mode 100644 index 00000000..7d94988e --- /dev/null +++ b/pkg/mwidget/motion_player.go @@ -0,0 +1,186 @@ +//go:build windows +// +build windows + +package mwidget + +import ( + "github.com/miu200521358/walk/pkg/walk" + "github.com/miu200521358/win" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils/mi18n" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" +) + +type MotionPlayer struct { + walk.WidgetBase + mWindow *MWindow // メインウィンドウ + FrameEdit *walk.NumberEdit // フレーム番号入力欄 + FrameSlider *walk.Slider // フレームスライダー + PlayButton *walk.PushButton // 一時停止ボタン + playing bool // 再生中かどうか + OnPlay func(bool) error // 再生/一時停止時のコールバック +} + +const MotionPlayerClass = "MotionPlayer Class" + +func NewMotionPlayer(parent walk.Container, mWindow *MWindow) (*MotionPlayer, error) { + mp := new(MotionPlayer) + mp.mWindow = mWindow + + if err := walk.InitWidget( + mp, + parent, + MotionPlayerClass, + win.WS_DISABLED, + 0); err != nil { + + return nil, err + } + + playerComposite, err := walk.NewComposite(parent) + if err != nil { + return nil, err + } + layout := walk.NewHBoxLayout() + playerComposite.SetLayout(layout) + + // 再生エリア + titleLabel, err := walk.NewTextLabel(playerComposite) + if err != nil { + return nil, err + } + titleLabel.SetText(mi18n.T("再生")) + titleLabel.MouseDown().Attach(func(x, y int, button walk.MouseButton) { + mlog.IL(mi18n.T("再生ウィジェットの使い方メッセージ")) + }) + + // キーフレ番号 + mp.FrameEdit, err = walk.NewNumberEdit(playerComposite) + if err != nil { + return nil, err + } + mp.FrameEdit.SetDecimals(0) + mp.FrameEdit.SetRange(0, 1) + mp.FrameEdit.SetValue(0) + mp.FrameEdit.SetIncrement(1) + mp.FrameEdit.SetSpinButtonsVisible(true) + + // フレームスライダー + mp.FrameSlider, err = walk.NewSlider(playerComposite) + if err != nil { + return nil, err + } + mp.FrameSlider.SetRange(0, 1) + mp.FrameSlider.SetValue(0) + + mp.PlayButton, err = walk.NewPushButton(playerComposite) + if err != nil { + return nil, err + } + mp.PlayButton.SetText(mi18n.T("再生")) + mp.PlayButton.Clicked().Attach(func() { + mp.playing = !mp.playing + mp.Play(mp.playing) + }) + + mp.FrameEdit.ValueChanged().Attach(func() { + if !mp.playing { + go func() { + mWindow.GetMainGlWindow().SetFrame(int(mp.FrameEdit.Value())) + mp.FrameSlider.SetValue(int(mp.FrameEdit.Value())) + }() + } + }) + mp.FrameSlider.ValueChanged().Attach(func() { + if !mp.playing { + go func() { + mWindow.GetMainGlWindow().SetFrame(int(mp.FrameSlider.Value())) + mp.FrameEdit.SetValue(float64(mp.FrameSlider.Value())) + }() + } + }) + + // レイアウト + layout.SetStretchFactor(mp.FrameEdit, 3) + layout.SetStretchFactor(mp.FrameSlider, 20) + layout.SetStretchFactor(mp.PlayButton, 2) + + return mp, nil +} + +func (mp *MotionPlayer) Playing() bool { + return mp.playing +} + +func (mp *MotionPlayer) Dispose() { + mp.WidgetBase.Dispose() + mp.FrameEdit.Dispose() + mp.FrameSlider.Dispose() + mp.PlayButton.Dispose() +} + +func (mp *MotionPlayer) Play(playing bool) { + if playing { + mp.PlayButton.SetText(mi18n.T("一時停止")) + mp.SetEnabled(false) + } else { + mp.PlayButton.SetText(mi18n.T("再生")) + mp.SetEnabled(true) + } + + if mp.OnPlay != nil { + err := mp.OnPlay(playing) + if err != nil { + mlog.ET("再生失敗", err.Error()) + mp.Play(false) + } + } +} + +func (mp *MotionPlayer) SetRange(min, max int) { + mp.FrameEdit.SetRange(float64(min), float64(max)) + mp.FrameSlider.SetRange(min, max) +} + +func (mp *MotionPlayer) SetValue(v int) { + value := mmath.ClampedFloat(float64(v), mp.FrameEdit.MinValue(), mp.FrameEdit.MaxValue()) + mp.FrameEdit.SetValue(value) + mp.FrameSlider.SetValue(int(value)) +} + +func (mp *MotionPlayer) SetEnabled(enabled bool) { + mp.FrameEdit.SetEnabled(enabled) + if !enabled { + bg, err := walk.NewSystemColorBrush(walk.SysColor3DFace) + if err != nil { + return + } + mp.FrameEdit.SetBackground(bg) + } else { + bg, err := walk.NewSolidColorBrush(walk.RGB(255, 255, 255)) + if err != nil { + return + } + mp.FrameEdit.SetBackground(bg) + } + mp.FrameSlider.SetEnabled(enabled) + mp.PlayButton.SetEnabled(enabled) +} + +func (*MotionPlayer) CreateLayoutItem(ctx *walk.LayoutContext) walk.LayoutItem { + return &motionPlayerLayoutItem{idealSize: walk.SizeFrom96DPI(walk.Size{Width: 50, Height: 50}, ctx.DPI())} +} + +type motionPlayerLayoutItem struct { + walk.LayoutItemBase + idealSize walk.Size // in native pixels +} + +func (li *motionPlayerLayoutItem) LayoutFlags() walk.LayoutFlags { + return 0 +} + +func (li *motionPlayerLayoutItem) IdealSize() walk.Size { + return li.idealSize +} diff --git a/pkg/mwidget/utils.go b/pkg/mwidget/utils.go new file mode 100644 index 00000000..76262ee8 --- /dev/null +++ b/pkg/mwidget/utils.go @@ -0,0 +1,111 @@ +//go:build windows +// +build windows + +package mwidget + +import ( + "bytes" + "embed" + "fmt" + "os" + "os/exec" + "runtime/debug" + + "github.com/go-gl/gl/v4.4-core/gl" + "github.com/go-gl/glfw/v3.3/glfw" + "github.com/miu200521358/walk/pkg/declarative" + "github.com/miu200521358/walk/pkg/walk" + + "github.com/miu200521358/mlib_go/pkg/mutils/mi18n" +) + +//go:embed icon/* +var iconFiles embed.FS + +func CheckError(err error, w *MWindow, message string) { + if err != nil { + if w != nil { + walk.MsgBox(w.MainWindow, message, err.Error(), walk.MsgBoxIconError) + w.Close() + } else { + walk.MsgBox(nil, message, err.Error(), walk.MsgBoxIconError) + } + } +} + +var MARGIN_ZERO = walk.Margins{HNear: 0, VNear: 0, HFar: 0, VFar: 0} +var MARGIN_SMALL = walk.Margins{HNear: 3, VNear: 3, HFar: 3, VFar: 3} +var MARGIN_MEDIUM = walk.Margins{HNear: 6, VNear: 6, HFar: 6, VFar: 6} + +// エラー監視 +func RecoverFromPanic(mWindow *MWindow) { + if r := recover(); r != nil { + stackTrace := debug.Stack() + + var errMsg string + // パニックの値がerror型である場合、エラーメッセージを取得 + if err, ok := r.(error); ok { + errMsg = err.Error() + } else { + // それ以外の型の場合は、文字列に変換 + errMsg = fmt.Sprintf("%v", r) + } + + var errT *walk.TextEdit + if _, err := (declarative.MainWindow{ + Title: mi18n.T("予期せぬエラーが発生しました"), + Size: declarative.Size{Width: 500, Height: 400}, + MinSize: declarative.Size{Width: 500, Height: 400}, + MaxSize: declarative.Size{Width: 500, Height: 400}, + Layout: declarative.VBox{}, + Children: []declarative.Widget{ + declarative.TextLabel{ + Text: mi18n.T("予期せぬエラーヘッダー"), + }, + declarative.TextEdit{ + Text: fmt.Sprintf("GLError: %d", gl.GetError()) + + string("\r\n------------\r\n") + + fmt.Sprintf("Error: %s", errMsg) + + string("\r\n------------\r\n") + + string(bytes.ReplaceAll(stackTrace, []byte("\n"), []byte("\r\n"))), + ReadOnly: true, + AssignTo: &errT, + VScroll: true, + HScroll: true, + }, + declarative.PushButton{ + Text: mi18n.T("コミュニティ報告"), + Alignment: declarative.AlignHFarVNear, + OnClicked: func() { + if err := walk.Clipboard().SetText(errT.Text()); err != nil { + walk.MsgBox(nil, mi18n.T("クリップボードコピー失敗"), + string(stackTrace), walk.MsgBoxIconError) + } + exec.Command("cmd", "/c", "start", "https://com.nicovideo.jp/community/co5387214").Start() + }, + }, + declarative.PushButton{ + Text: mi18n.T("アプリを終了"), + OnClicked: func() { + os.Exit(1) + if mWindow != nil { + mWindow.Close() + } + }, + }, + }, + }).Run(); err != nil { + walk.MsgBox(nil, mi18n.T("エラーダイアログ起動失敗"), string(stackTrace), walk.MsgBoxIconError) + } + + if mWindow != nil { + mWindow.Close() + } + } +} + +func CheckOpenGLError() bool { + err := gl.GetError() + glfwErrorMessage := glfw.ErrorCode(err).String() + return err != gl.NO_ERROR || glfwErrorMessage != "ErrorCode(0)" +} diff --git a/pkg/pmx/bone.go b/pkg/pmx/bone.go new file mode 100644 index 00000000..871a90bb --- /dev/null +++ b/pkg/pmx/bone.go @@ -0,0 +1,701 @@ +package pmx + +import ( + "slices" + "sort" + "strings" + + "github.com/jinzhu/copier" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +type IkLink struct { + BoneIndex int // リンクボーンのボーンIndex + AngleLimit bool // 角度制限有無 + MinAngleLimit *mmath.MRotation // 下限 + MaxAngleLimit *mmath.MRotation // 上限 + LocalAngleLimit bool // ローカル軸の角度制限有無 + LocalMinAngleLimit *mmath.MRotation // ローカル軸制限の下限 + LocalMaxAngleLimit *mmath.MRotation // ローカル軸制限の上限 +} + +func NewIkLink() *IkLink { + return &IkLink{ + BoneIndex: -1, + AngleLimit: false, + MinAngleLimit: mmath.NewRotation(), + MaxAngleLimit: mmath.NewRotation(), + LocalAngleLimit: false, + LocalMinAngleLimit: mmath.NewRotation(), + LocalMaxAngleLimit: mmath.NewRotation(), + } +} + +func (v *IkLink) Copy() *IkLink { + copied := NewIkLink() + copier.CopyWithOption(copied, v, copier.Option{DeepCopy: true}) + return copied +} + +type Ik struct { + BoneIndex int // IKターゲットボーンのボーンIndex + LoopCount int // IKループ回数 (最大255) + UnitRotation *mmath.MRotation // IKループ計算時の1回あたりの制限角度 + Links []*IkLink // IKリンクリスト +} + +func NewIk() *Ik { + return &Ik{ + BoneIndex: -1, + LoopCount: 0, + UnitRotation: mmath.NewRotation(), + Links: []*IkLink{}, + } +} + +func (t *Ik) Copy() *Ik { + copied := &Ik{} + copied.BoneIndex = t.BoneIndex + copied.LoopCount = t.LoopCount + copied.UnitRotation = t.UnitRotation.Copy() + copied.Links = make([]*IkLink, len(t.Links)) + for i, link := range t.Links { + copied.Links[i] = link.Copy() + } + return copied +} + +type Bone struct { + *mcore.IndexNameModel + Position *mmath.MVec3 // ボーン位置 + ParentIndex int // 親ボーンのボーンIndex + Layer int // 変形階層 + BoneFlag BoneFlag // ボーンフラグ(16bit) 各bit 0:OFF 1:ON + TailPosition *mmath.MVec3 // 接続先:0 の場合 座標オフセット, ボーン位置からの相対分 + TailIndex int // 接続先:1 の場合 接続先ボーンのボーンIndex + EffectIndex int // 回転付与:1 または 移動付与:1 の場合 付与親ボーンのボーンIndex + EffectFactor float64 // 付与率 + FixedAxis *mmath.MVec3 // 軸固定:1 の場合 軸の方向ベクトル + LocalAxisX *mmath.MVec3 // ローカル軸:1 の場合 X軸の方向ベクトル + LocalAxisZ *mmath.MVec3 // ローカル軸:1 の場合 Z軸の方向ベクトル + EffectorKey int // 外部親変形:1 の場合 Key値 + Ik *Ik // IK:1 の場合 IKデータを格納 + DisplaySlot int // 該当表示枠 + IsSystem bool // システム計算用追加ボーン の場合 true + NormalizedLocalAxisX *mmath.MVec3 // 計算済みのX軸の方向ベクトル + NormalizedLocalAxisY *mmath.MVec3 // 計算済みのY軸の方向ベクトル + NormalizedLocalAxisZ *mmath.MVec3 // 計算済みのZ軸の方向ベクトル + NormalizedFixedAxis *mmath.MVec3 // 計算済みの軸制限ベクトル + LocalAxis *mmath.MVec3 // ローカル軸の方向ベクトル(CorrectedLocalXVectorの正規化ベクトル) + ParentRelativePosition *mmath.MVec3 // 親ボーンからの相対位置 + ChildRelativePosition *mmath.MVec3 // Tailボーンへの相対位置 + LocalMatrix *mmath.MMat4 // ローカル軸行列 + RevertOffsetMatrix *mmath.MMat4 // 逆オフセット行列(親ボーンからの相対位置分を戻す) + OffsetMatrix *mmath.MMat4 // オフセット行列 (自身の位置を原点に戻す行列) + TreeBoneIndexes []int // 自分のボーンまでのボーンIndexのリスト + ParentBoneIndexes []int // 自分の親ボーンからルートまでのボーンIndexのリスト + ParentBoneNames []string // 自分の親ボーンからルートまでのボーン名のリスト + RelativeBoneIndexes []int // 関連ボーンINDEX一覧（付与親とかIKとか） + ChildBoneIndexes []int // 自分を親として登録しているボーンINDEX一覧 + EffectiveBoneIndexes []int // 自分を付与親として登録しているボーンINDEX一覧 + IkLinkBoneIndexes []int // IKリンクとして登録されているIKボーンのボーンIndex + IkTargetBoneIndexes []int // IKターゲットとして登録されているIKボーンのボーンIndex + AngleLimit bool // 自分がIKリンクボーンの角度制限がある場合、true + MinAngleLimit *mmath.MRotation // 自分がIKリンクボーンの角度制限の下限 + MaxAngleLimit *mmath.MRotation // 自分がIKリンクボーンの角度制限の上限 + LocalAngleLimit bool // 自分がIKリンクボーンのローカル軸角度制限がある場合、true + LocalMinAngleLimit *mmath.MRotation // 自分がIKリンクボーンのローカル軸角度制限の下限 + LocalMaxAngleLimit *mmath.MRotation // 自分がIKリンクボーンのローカル軸角度制限の上限 + AxisSign int // ボーンの軸ベクトル(左は-1, 右は1) + RigidBody *RigidBody // 物理演算用剛体 +} + +func NewBone() *Bone { + bone := &Bone{ + IndexNameModel: &mcore.IndexNameModel{Index: -1, Name: "", EnglishName: ""}, + Position: mmath.NewMVec3(), + ParentIndex: -1, + Layer: -1, + BoneFlag: BONE_FLAG_NONE, + TailPosition: mmath.NewMVec3(), + TailIndex: -1, + EffectIndex: -1, + EffectFactor: 0.0, + FixedAxis: mmath.NewMVec3(), + LocalAxisX: mmath.NewMVec3(), + LocalAxisZ: mmath.NewMVec3(), + EffectorKey: -1, + Ik: NewIk(), + DisplaySlot: -1, + IsSystem: true, + NormalizedLocalAxisX: mmath.NewMVec3(), + NormalizedLocalAxisY: mmath.NewMVec3(), + NormalizedLocalAxisZ: mmath.NewMVec3(), + LocalAxis: &mmath.MVec3{1, 0, 0}, + IkLinkBoneIndexes: make([]int, 0), + IkTargetBoneIndexes: make([]int, 0), + ParentRelativePosition: mmath.NewMVec3(), + ChildRelativePosition: mmath.NewMVec3(), + NormalizedFixedAxis: mmath.NewMVec3(), + TreeBoneIndexes: make([]int, 0), + RevertOffsetMatrix: mmath.NewMMat4(), + OffsetMatrix: mmath.NewMMat4(), + ParentBoneIndexes: make([]int, 0), + ParentBoneNames: make([]string, 0), + RelativeBoneIndexes: make([]int, 0), + ChildBoneIndexes: make([]int, 0), + EffectiveBoneIndexes: make([]int, 0), + AngleLimit: false, + MinAngleLimit: mmath.NewRotation(), + MaxAngleLimit: mmath.NewRotation(), + LocalAngleLimit: false, + LocalMinAngleLimit: mmath.NewRotation(), + LocalMaxAngleLimit: mmath.NewRotation(), + AxisSign: 1, + RigidBody: nil, + } + bone.NormalizedLocalAxisX = bone.LocalAxisX.Copy() + bone.NormalizedLocalAxisZ = bone.LocalAxisZ.Copy() + bone.NormalizedLocalAxisY = bone.NormalizedLocalAxisZ.Cross(bone.NormalizedLocalAxisX) + bone.NormalizedFixedAxis = bone.FixedAxis.Copy() + return bone +} + +func NewBoneByName(name string) *Bone { + bone := NewBone() + bone.Name = name + return bone +} + +func (v *Bone) Copy() mcore.IIndexNameModel { + copied := NewBone() + copier.CopyWithOption(copied, v, copier.Option{DeepCopy: true}) + return copied +} + +func (bone *Bone) NormalizeFixedAxis(fixedAxis *mmath.MVec3) { + bone.NormalizedFixedAxis = fixedAxis.Normalized() +} + +func (bone *Bone) NormalizeLocalAxis(localAxisX *mmath.MVec3) { + bone.NormalizedLocalAxisX = localAxisX.Normalized() + bone.NormalizedLocalAxisY = bone.NormalizedLocalAxisX.Cross(mmath.MVec3UnitZInv) + bone.NormalizedLocalAxisZ = bone.NormalizedLocalAxisX.Cross(bone.NormalizedLocalAxisY) +} + +// 表示先がボーンであるか +func (bone *Bone) IsTailBone() bool { + return bone.BoneFlag&BONE_FLAG_TAIL_IS_BONE == BONE_FLAG_TAIL_IS_BONE +} + +// 回転可能であるか +func (bone *Bone) CanRotate() bool { + return bone.BoneFlag&BONE_FLAG_CAN_ROTATE == BONE_FLAG_CAN_ROTATE +} + +// 移動可能であるか +func (bone *Bone) CanTranslate() bool { + return bone.BoneFlag&BONE_FLAG_CAN_TRANSLATE == BONE_FLAG_CAN_TRANSLATE +} + +// 表示であるか +func (bone *Bone) IsVisible() bool { + return bone.BoneFlag&BONE_FLAG_IS_VISIBLE == BONE_FLAG_IS_VISIBLE +} + +// 操作可であるか +func (bone *Bone) CanManipulate() bool { + return bone.BoneFlag&BONE_FLAG_CAN_MANIPULATE == BONE_FLAG_CAN_MANIPULATE +} + +// IKであるか +func (bone *Bone) IsIK() bool { + return bone.BoneFlag&BONE_FLAG_IS_IK == BONE_FLAG_IS_IK +} + +// ローカル付与であるか +func (bone *Bone) IsEffectorLocal() bool { + return bone.BoneFlag&BONE_FLAG_IS_EXTERNAL_LOCAL == BONE_FLAG_IS_EXTERNAL_LOCAL +} + +// 回転付与であるか +func (bone *Bone) IsEffectorRotation() bool { + return bone.BoneFlag&BONE_FLAG_IS_EXTERNAL_ROTATION == BONE_FLAG_IS_EXTERNAL_ROTATION +} + +// 移動付与であるか +func (bone *Bone) IsEffectorTranslation() bool { + return bone.BoneFlag&BONE_FLAG_IS_EXTERNAL_TRANSLATION == BONE_FLAG_IS_EXTERNAL_TRANSLATION +} + +// 軸固定であるか +func (bone *Bone) HasFixedAxis() bool { + return bone.BoneFlag&BONE_FLAG_HAS_FIXED_AXIS == BONE_FLAG_HAS_FIXED_AXIS +} + +// ローカル軸を持つか +func (bone *Bone) HasLocalAxis() bool { + return bone.BoneFlag&BONE_FLAG_HAS_LOCAL_AXIS == BONE_FLAG_HAS_LOCAL_AXIS +} + +// 物理後変形であるか +func (bone *Bone) IsAfterPhysicsDeform() bool { + return bone.BoneFlag&BONE_FLAG_IS_AFTER_PHYSICS_DEFORM == BONE_FLAG_IS_AFTER_PHYSICS_DEFORM +} + +// 外部親変形であるか +func (bone *Bone) IsEffectorParentDeform() bool { + return bone.BoneFlag&BONE_FLAG_IS_EXTERNAL_PARENT_DEFORM == BONE_FLAG_IS_EXTERNAL_PARENT_DEFORM +} + +// 足D系列であるか +func (bone *Bone) IsLegD() bool { + return bone.containsCategory(CATEGORY_LEG_D) +} + +// 肩P系列であるか +func (bone *Bone) IsShoulderP() bool { + return bone.containsCategory(CATEGORY_SHOULDER_P) +} + +// 足FK系列であるか +func (bone *Bone) IsLegFK() bool { + return bone.containsCategory(CATEGORY_LEG_FK) +} + +// 足首から先であるか +func (bone *Bone) IsAnkle() bool { + return bone.containsCategory(CATEGORY_ANKLE) +} + +// 捩りボーンであるか +func (bone *Bone) IsTwist() bool { + return bone.containsCategory(CATEGORY_TWIST) +} + +// 腕系ボーンであるか(指は含まない) +func (bone *Bone) IsArm() bool { + return bone.containsCategory(CATEGORY_ARM) +} + +// 指系ボーンであるか +func (bone *Bone) IsFinger() bool { + return bone.containsCategory(CATEGORY_FINGER) +} + +// 頭系であるか +func (bone *Bone) IsHead() bool { + return bone.containsCategory(CATEGORY_HEAD) +} + +// 下半身系であるか +func (bone *Bone) IsLower() bool { + return bone.containsCategory(CATEGORY_LOWER) +} + +// 上半身系であるか +func (bone *Bone) IsUpper() bool { + return bone.containsCategory(CATEGORY_UPPER) +} + +// ローカル軸行列計算で親のキャンセルをさせないボーンであるか +func (bone *Bone) IsNoLocalCancel() bool { + // 捩り分散ボーンも含む + if strings.Contains(bone.Name, "捩") { + return true + } + + return bone.containsCategory(CATEGORY_NO_LOCAL_CANCEL) +} + +// 指定したカテゴリーに属するか +func (bone *Bone) containsCategory(category BoneCategory) bool { + for _, boneConfig := range GetStandardBoneConfigs() { + for _, c := range boneConfig.Categories { + if c == category && (boneConfig.Name.String() == bone.Name || + boneConfig.Name.Right() == bone.Name || + boneConfig.Name.Left() == bone.Name) { + return true + } + } + } + return false +} + +func (bone *Bone) normalizeFixedAxis(fixedAxis *mmath.MVec3) { + bone.NormalizedFixedAxis = fixedAxis.Normalized() +} + +func (bone *Bone) normalizeLocalAxis(localXVector *mmath.MVec3) { + v := localXVector.Normalized() + bone.NormalizedLocalAxisX = v + bone.NormalizedLocalAxisY = v.Cross(&mmath.MVec3{0, 0, -1}) + bone.NormalizedLocalAxisZ = v.Cross(bone.NormalizedLocalAxisY) +} + +func (bone *Bone) setup() { + // 各ボーンのローカル軸 + bone.LocalAxis = bone.ChildRelativePosition.Normalized() + // ローカル軸行列 + bone.LocalMatrix = bone.LocalAxis.ToLocalMatrix4x4() + + if bone.HasFixedAxis() { + bone.normalizeFixedAxis(bone.FixedAxis) + bone.normalizeLocalAxis(bone.FixedAxis) + } else { + bone.normalizeLocalAxis(bone.LocalAxis) + } + + // オフセット行列は自身の位置を原点に戻す行列 + bone.OffsetMatrix = bone.Position.Inverted().ToMat4() + + // 逆オフセット行列は親ボーンからの相対位置分 + bone.RevertOffsetMatrix = bone.ParentRelativePosition.ToMat4() +} + +func (b *Bones) getParentRelativePosition(boneIndex int) *mmath.MVec3 { + bone := b.Get(boneIndex) + if bone.ParentIndex >= 0 && b.Contains(bone.ParentIndex) { + return bone.Position.Subed(b.Get(bone.ParentIndex).Position) + } + // 親が見つからない場合、自分の位置を原点からの相対位置として返す + return bone.Position.Copy() +} + +func (b *Bones) getChildRelativePosition(boneIndex int) *mmath.MVec3 { + bone := b.Get(boneIndex) + + fromPosition := bone.Position + var toPosition *mmath.MVec3 + + if bone.IsTailBone() && bone.TailIndex >= 0 && slices.Contains(b.GetIndexes(), bone.TailIndex) { + toPosition = b.Get(bone.TailIndex).Position + } else if !bone.IsTailBone() && bone.TailPosition.Length() > 0 { + toPosition = bone.TailPosition.Added(bone.Position) + } else if bone.ParentIndex < 0 || !b.Contains(bone.ParentIndex) { + return mmath.NewMVec3() + } else { + fromPosition = b.Get(bone.ParentIndex).Position + toPosition = bone.Position + } + + v := toPosition.Subed(fromPosition) + return v +} + +func (b *Bones) GetLayerIndexes(isAfterPhysics bool) []int { + layerIndexes := make(LayerIndexes, 0, len(b.NameIndexes)) + for _, bone := range b.Data { + if (isAfterPhysics && bone.IsAfterPhysicsDeform()) || (!isAfterPhysics && !bone.IsAfterPhysicsDeform()) { + // 物理前後でフィルタリング + layerIndexes = append(layerIndexes, LayerIndex{Layer: bone.Layer, Index: bone.Index}) + } + } + sort.Sort(layerIndexes) + + indexes := make([]int, len(layerIndexes)) + for i, layerIndex := range layerIndexes { + indexes[i] = layerIndex.Index + } + + return indexes +} + +// 関連ボーンリストの取得 +func (b *Bones) getRelativeBoneIndexes(boneIndex int, parentBoneIndexes, relativeBoneIndexes []int) ([]int, []int) { + + if boneIndex <= 0 || !b.Contains(boneIndex) { + return parentBoneIndexes, relativeBoneIndexes + } + + bone := b.Get(boneIndex) + if b.Contains(bone.ParentIndex) && !slices.Contains(relativeBoneIndexes, bone.ParentIndex) { + // 親ボーンを辿る(親から子の順番) + parentBoneIndexes = append([]int{bone.ParentIndex}, parentBoneIndexes...) + relativeBoneIndexes = append(relativeBoneIndexes, bone.ParentIndex) + parentBoneIndexes, relativeBoneIndexes = + b.getRelativeBoneIndexes(bone.ParentIndex, parentBoneIndexes, relativeBoneIndexes) + } + if (bone.IsEffectorRotation() || bone.IsEffectorTranslation()) && + b.Contains(bone.EffectIndex) && !slices.Contains(relativeBoneIndexes, bone.EffectIndex) { + // 付与親ボーンを辿る + relativeBoneIndexes = append(relativeBoneIndexes, bone.EffectIndex) + _, relativeBoneIndexes = + b.getRelativeBoneIndexes(bone.EffectIndex, parentBoneIndexes, relativeBoneIndexes) + } + if bone.IsIK() { + if b.Contains(bone.Ik.BoneIndex) && !slices.Contains(relativeBoneIndexes, bone.Ik.BoneIndex) { + // IKターゲットボーンを辿る + relativeBoneIndexes = append(relativeBoneIndexes, bone.Ik.BoneIndex) + _, relativeBoneIndexes = + b.getRelativeBoneIndexes(bone.Ik.BoneIndex, parentBoneIndexes, relativeBoneIndexes) + } + for _, link := range bone.Ik.Links { + if b.Contains(link.BoneIndex) && !slices.Contains(relativeBoneIndexes, link.BoneIndex) { + // IKリンクボーンを辿る + relativeBoneIndexes = append(relativeBoneIndexes, link.BoneIndex) + _, relativeBoneIndexes = + b.getRelativeBoneIndexes(link.BoneIndex, parentBoneIndexes, relativeBoneIndexes) + } + } + } + for _, boneIndex := range bone.EffectiveBoneIndexes { + if b.Contains(boneIndex) && !slices.Contains(relativeBoneIndexes, boneIndex) { + // 外部子ボーンを辿る + relativeBoneIndexes = append(relativeBoneIndexes, boneIndex) + _, relativeBoneIndexes = + b.getRelativeBoneIndexes(boneIndex, parentBoneIndexes, relativeBoneIndexes) + } + } + for _, boneIndex := range bone.IkTargetBoneIndexes { + if b.Contains(boneIndex) && !slices.Contains(relativeBoneIndexes, boneIndex) { + // IKターゲットボーンを辿る + relativeBoneIndexes = append(relativeBoneIndexes, boneIndex) + _, relativeBoneIndexes = + b.getRelativeBoneIndexes(boneIndex, parentBoneIndexes, relativeBoneIndexes) + } + } + for _, boneIndex := range bone.IkLinkBoneIndexes { + if b.Contains(boneIndex) && !slices.Contains(relativeBoneIndexes, boneIndex) { + // IKリンクボーンを辿る + relativeBoneIndexes = append(relativeBoneIndexes, boneIndex) + _, relativeBoneIndexes = + b.getRelativeBoneIndexes(boneIndex, parentBoneIndexes, relativeBoneIndexes) + } + } + + return parentBoneIndexes, relativeBoneIndexes +} + +// IKツリーの親INDEXを取得 +func (b *Bones) getIkTreeIndex(bone *Bone, isAfterPhysics bool, loop int) *Bone { + if bone == nil || bone.ParentIndex < 0 || !b.Contains(bone.ParentIndex) || loop > 100 { + return nil + } + + parentBone := b.Get(bone.ParentIndex) + if parentBone.Index < 0 { + return nil + } + + if _, ok := b.IkTreeIndexes[parentBone.Index]; ok { + return parentBone + } else { + parentLayerBone := b.getIkTreeIndex(parentBone, isAfterPhysics, loop+1) + if parentLayerBone != nil { + return parentLayerBone + } + } + + if bone.IsEffectorRotation() || bone.IsEffectorTranslation() { + effectBone := b.Get(bone.EffectIndex) + if _, ok := b.IkTreeIndexes[effectBone.Index]; ok { + return effectBone + } else { + effectorLayerBone := b.getIkTreeIndex(effectBone, isAfterPhysics, loop+1) + if effectorLayerBone != nil { + return effectorLayerBone + } + } + } + + return nil +} + +func (b *Bones) setup() { + b.IkTreeIndexes = make(map[int][]int) + b.LayerSortedBones = make(map[bool][]*Bone) + b.LayerSortedNames = make(map[bool]map[string]int) + b.DeformBoneIndexes = make(map[int][]int) + + for _, bone := range b.Data { + // 関係ボーンリストを一旦クリア + bone.IkLinkBoneIndexes = make([]int, 0) + bone.IkTargetBoneIndexes = make([]int, 0) + bone.EffectiveBoneIndexes = make([]int, 0) + bone.ChildBoneIndexes = make([]int, 0) + bone.RelativeBoneIndexes = make([]int, 0) + bone.ParentBoneIndexes = make([]int, 0) + bone.ParentBoneNames = make([]string, 0) + bone.TreeBoneIndexes = make([]int, 0) + } + + // 関連ボーンINDEX情報を設定 + for i := range len(b.Data) { + bone := b.Get(i) + if strings.HasPrefix(bone.Name, "左") { + bone.AxisSign = -1 + } + if bone.IsIK() && bone.Ik != nil { + // IKのリンクとターゲット + for _, link := range bone.Ik.Links { + if b.Contains(link.BoneIndex) && + !slices.Contains(b.Get(link.BoneIndex).IkLinkBoneIndexes, bone.Index) { + // リンクボーンにフラグを立てる + linkBone := b.Get(link.BoneIndex) + linkBone.IkLinkBoneIndexes = append(linkBone.IkLinkBoneIndexes, bone.Index) + // リンクの制限をコピーしておく + linkBone.AngleLimit = link.AngleLimit + linkBone.MinAngleLimit = link.MinAngleLimit + linkBone.MaxAngleLimit = link.MaxAngleLimit + linkBone.LocalAngleLimit = link.LocalAngleLimit + linkBone.LocalMinAngleLimit = link.LocalMinAngleLimit + linkBone.LocalMaxAngleLimit = link.LocalMaxAngleLimit + } + } + if b.Contains(bone.Ik.BoneIndex) && + !slices.Contains(b.Get(bone.Ik.BoneIndex).IkTargetBoneIndexes, bone.Index) { + // ターゲットボーンにもフラグを立てる + b.Get(bone.Ik.BoneIndex).IkTargetBoneIndexes = append(b.Get(bone.Ik.BoneIndex).IkTargetBoneIndexes, bone.Index) + } + } + if bone.EffectIndex >= 0 && b.Contains(bone.EffectIndex) && + !slices.Contains(b.Get(bone.EffectIndex).EffectiveBoneIndexes, bone.Index) { + // 付与親の方に付与子情報を保持 + b.Get(bone.EffectIndex).EffectiveBoneIndexes = append(b.Get(bone.EffectIndex).EffectiveBoneIndexes, bone.Index) + } + } + + for i := range b.Len() { + bone := b.Get(i) + // 影響があるボーンINDEXリスト + bone.ParentBoneIndexes, bone.RelativeBoneIndexes = b.getRelativeBoneIndexes(bone.Index, make([]int, 0), make([]int, 0)) + + // ボーンINDEXリストからボーン名リストを作成 + bone.ParentBoneNames = make([]string, len(bone.ParentBoneIndexes)) + for i, parentBoneIndex := range bone.ParentBoneIndexes { + bone.ParentBoneNames[i] = b.Get(parentBoneIndex).Name + } + + // 親ボーンに子ボーンとして登録する + if bone.ParentIndex >= 0 && b.Contains(bone.ParentIndex) { + b.Get(bone.ParentIndex).ChildBoneIndexes = append(b.Get(bone.ParentIndex).ChildBoneIndexes, bone.Index) + } + // 親からの相対位置 + bone.ParentRelativePosition = b.getParentRelativePosition(bone.Index) + // 子への相対位置 + bone.ChildRelativePosition = b.getChildRelativePosition(bone.Index) + // ボーン単体のセットアップ + bone.setup() + } + + // 変形階層・ボーンINDEXでソート + + // 変形前と変形後に分けてINDEXリストを生成 + b.createLayerIndexes(false) + b.createLayerIndexes(true) + + // 変形階層順に親子を繋げていく + for _, isAfterPhysics := range []bool{false, true} { + ikLoop: + for i := range len(b.LayerSortedBones[isAfterPhysics]) { + bone := b.LayerSortedBones[isAfterPhysics][i] + if bone.IsIK() { + ikLayerBone := b.getIkTreeIndex(bone, isAfterPhysics, 0) + if ikLayerBone != nil { + // 合致するIKツリーがある場合、そのレイヤーに登録 + b.IkTreeIndexes[ikLayerBone.Index] = + append(b.IkTreeIndexes[ikLayerBone.Index], bone.Index) + continue ikLoop + } + for _, link := range bone.Ik.Links { + linkBone := b.Get(link.BoneIndex) + linkLayerBone := b.getIkTreeIndex(linkBone, isAfterPhysics, 0) + if linkLayerBone != nil { + // 合致するIKツリーがある場合、そのレイヤーに登録 + b.IkTreeIndexes[linkLayerBone.Index] = + append(b.IkTreeIndexes[linkLayerBone.Index], bone.Index) + continue ikLoop + } + } + + // 関連親がIKツリーに登録されていない場合、新規にIKツリーを作成 + linkBone := b.Get(bone.Ik.Links[len(bone.Ik.Links)-1].BoneIndex) + // b.IkTreeIndexes[linkBone.Index] = []int{bone.Index} + if linkBone.ParentIndex >= 0 && b.Contains(linkBone.ParentIndex) { + parentBone := b.Get(linkBone.ParentIndex) + b.IkTreeIndexes[parentBone.Index] = []int{bone.Index} + } else { + b.IkTreeIndexes[bone.Index] = []int{bone.Index} + } + } + } + } + + for _, bone := range b.Data { + // ボーンのデフォームINDEXリストを取得 + b.createLayerSortedIkBones(bone) + } +} + +func (b *Bones) createLayerSortedIkBones(bone *Bone) { + // 関連ボーンINDEXリスト（順不同） + relativeBoneIndexes := make(map[int]struct{}) + + // 対象のボーンは常に追加 + relativeBoneIndexes[bone.Index] = struct{}{} + + // 関連するボーンの追加 + for _, index := range bone.RelativeBoneIndexes { + if _, ok := relativeBoneIndexes[index]; !ok { + relativeBoneIndexes[index] = struct{}{} + } + } + + deformBoneIndexes := make([]int, 0) + for _, ap := range []bool{false, true} { + for _, bone := range b.LayerSortedBones[ap] { + if _, ok := relativeBoneIndexes[bone.Index]; ok { + deformBoneIndexes = append(deformBoneIndexes, bone.Index) + } + } + } + + b.DeformBoneIndexes[bone.Index] = deformBoneIndexes +} + +func (b *Bones) createLayerIndexes(isAfterPhysics bool) { + if _, ok := b.LayerSortedBones[isAfterPhysics]; !ok { + b.LayerSortedBones[isAfterPhysics] = make([]*Bone, 0) + } + if _, ok := b.LayerSortedNames[isAfterPhysics]; !ok { + b.LayerSortedNames[isAfterPhysics] = make(map[string]int) + } + + layerIndexes := b.GetLayerIndexes(isAfterPhysics) + + for i, boneIndex := range layerIndexes { + bone := b.Get(boneIndex) + b.LayerSortedNames[isAfterPhysics][bone.Name] = i + b.LayerSortedBones[isAfterPhysics] = append(b.LayerSortedBones[isAfterPhysics], bone) + } +} + +// 変形階層とINDEXのソート用構造体 +type LayerIndex struct { + Layer int + Index int +} + +type LayerIndexes []LayerIndex + +func (p LayerIndexes) Len() int { + return len(p) +} +func (p LayerIndexes) Less(i, j int) bool { + return p[i].Layer < p[j].Layer || (p[i].Layer == p[j].Layer && p[i].Index < p[j].Index) +} +func (p LayerIndexes) Swap(i, j int) { + p[i], p[j] = p[j], p[i] +} + +func (p LayerIndexes) Contains(index int) bool { + for _, layerIndex := range p { + if layerIndex.Index == index { + return true + } + } + return false +} diff --git a/pkg/pmx/bone_config.go b/pkg/pmx/bone_config.go new file mode 100644 index 00000000..9cef5d55 --- /dev/null +++ b/pkg/pmx/bone_config.go @@ -0,0 +1,533 @@ +package pmx + +import ( + "strings" + "sync" + + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +// MLIB_PREFIX システム用接頭辞 +const MLIB_PREFIX string = "[mlib]" + +type BoneFlag uint16 + +const ( + // 初期値 + BONE_FLAG_NONE BoneFlag = 0x0000 + // 接続先(PMD子ボーン指定)表示方法 -> 0:座標オフセットで指定 1:ボーンで指定 + BONE_FLAG_TAIL_IS_BONE BoneFlag = 0x0001 + // 回転可能 + BONE_FLAG_CAN_ROTATE BoneFlag = 0x0002 + // 移動可能 + BONE_FLAG_CAN_TRANSLATE BoneFlag = 0x0004 + // 表示 + BONE_FLAG_IS_VISIBLE BoneFlag = 0x0008 + // 操作可 + BONE_FLAG_CAN_MANIPULATE BoneFlag = 0x0010 + // IK + BONE_FLAG_IS_IK BoneFlag = 0x0020 + // ローカル付与 | 付与対象 0:ユーザー変形値／IKリンク／多重付与 1:親のローカル変形量 + BONE_FLAG_IS_EXTERNAL_LOCAL BoneFlag = 0x0080 + // 回転付与 + BONE_FLAG_IS_EXTERNAL_ROTATION BoneFlag = 0x0100 + // 移動付与 + BONE_FLAG_IS_EXTERNAL_TRANSLATION BoneFlag = 0x0200 + // 軸固定 + BONE_FLAG_HAS_FIXED_AXIS BoneFlag = 0x0400 + // ローカル軸 + BONE_FLAG_HAS_LOCAL_AXIS BoneFlag = 0x0800 + // 物理後変形 + BONE_FLAG_IS_AFTER_PHYSICS_DEFORM BoneFlag = 0x1000 + // 外部親変形 + BONE_FLAG_IS_EXTERNAL_PARENT_DEFORM BoneFlag = 0x2000 +) + +type BoneCategory int + +const ( + // ルート + CATEGORY_ROOT BoneCategory = iota + // 上半身 + CATEGORY_UPPER BoneCategory = iota + // 下半身 + CATEGORY_LOWER BoneCategory = iota + // 腕 + CATEGORY_ARM BoneCategory = iota + // 足 + CATEGORY_LEG BoneCategory = iota + // 指 + CATEGORY_FINGER BoneCategory = iota + // 足D + CATEGORY_LEG_D BoneCategory = iota + // 肩P + CATEGORY_SHOULDER_P BoneCategory = iota + // 足FK + CATEGORY_LEG_FK BoneCategory = iota + // 足首 + CATEGORY_ANKLE BoneCategory = iota + // 捩 + CATEGORY_TWIST BoneCategory = iota + // 頭 + CATEGORY_HEAD BoneCategory = iota + // ローカル軸行列計算で親のキャンセルをさせないボーン + CATEGORY_NO_LOCAL_CANCEL BoneCategory = iota +) + +type BoneConfig struct { + // 準標準ボーン名 + Name StandardBoneNames + // 親ボーン名候補リスト + ParentBoneNames []StandardBoneNames + // 表示先位置(該当ボーンの位置との相対位置) + TailPosition *mmath.MVec3 + // 末端ボーン名候補リスト + TailBoneNames []StandardBoneNames + // ボーンの特性 + BoneFlag BoneFlag + // ボーンカテゴリ + Categories []BoneCategory +} + +func NewBoneConfig( + name StandardBoneNames, + parentBoneNames []StandardBoneNames, + tailPosition *mmath.MVec3, + tailBoneNames []StandardBoneNames, + flag BoneFlag, + categories []BoneCategory, +) *BoneConfig { + return &BoneConfig{ + Name: name, + ParentBoneNames: parentBoneNames, + TailPosition: tailPosition, + TailBoneNames: tailBoneNames, + BoneFlag: flag, + Categories: categories, + } +} + +type StandardBoneNames string + +const ( + ROOT StandardBoneNames = "全ての親" + CENTER StandardBoneNames = "センター" + GROOVE StandardBoneNames = "グルーブ" + WAIST StandardBoneNames = "腰" + LOWER StandardBoneNames = "下半身" + LEG_CENTER StandardBoneNames = "足中心" + UPPER StandardBoneNames = "上半身" + UPPER2 StandardBoneNames = "上半身2" + UPPER3 StandardBoneNames = "上半身3" + NECK_ROOT StandardBoneNames = "首根元" + NECK StandardBoneNames = "首" + HEAD StandardBoneNames = "頭" + EYES StandardBoneNames = "両目" + EYE StandardBoneNames = "{d}目" + BUST StandardBoneNames = "{d}胸" + SHOULDER_ROOT StandardBoneNames = "{d}肩根元" + SHOULDER_P StandardBoneNames = "{d}肩P" + SHOULDER StandardBoneNames = "{d}肩" + SHOULDER_C StandardBoneNames = "{d}肩C" + ARM StandardBoneNames = "{d}腕" + ARM_TWIST StandardBoneNames = "{d}腕捩" + ELBOW StandardBoneNames = "{d}ひじ" + WRIST_TWIST StandardBoneNames = "{d}手捩" + WRIST StandardBoneNames = "{d}手首" + THUMB0 StandardBoneNames = "{d}親指０" + THUMB1 StandardBoneNames = "{d}親指１" + THUMB2 StandardBoneNames = "{d}親指２" + THUMB_TAIL StandardBoneNames = "{d}親指先" + INDEX1 StandardBoneNames = "{d}人指１" + INDEX2 StandardBoneNames = "{d}人指２" + INDEX3 StandardBoneNames = "{d}人指３" + INDEX_TAIL StandardBoneNames = "{d}人指先" + MIDDLE1 StandardBoneNames = "{d}中指１" + MIDDLE2 StandardBoneNames = "{d}中指２" + MIDDLE3 StandardBoneNames = "{d}中指３" + MIDDLE_TAIL StandardBoneNames = "{d}中指先" + RING1 StandardBoneNames = "{d}薬指１" + RING2 StandardBoneNames = "{d}薬指２" + RING3 StandardBoneNames = "{d}薬指３" + RING_TAIL StandardBoneNames = "{d}薬指先" + PINKY1 StandardBoneNames = "{d}小指１" + PINKY2 StandardBoneNames = "{d}小指２" + PINKY3 StandardBoneNames = "{d}小指３" + PINKY_TAIL StandardBoneNames = "{d}小指先" + WAIST_CANCEL StandardBoneNames = "腰キャンセル{d}" + LEG StandardBoneNames = "{d}足" + KNEE StandardBoneNames = "{d}ひざ" + ANKLE StandardBoneNames = "{d}足首" + TOE StandardBoneNames = "{d}つま先" + LEG_D StandardBoneNames = "{d}足D" + KNEE_D StandardBoneNames = "{d}ひざD" + ANKLE_D StandardBoneNames = "{d}足首D" + TOE_EX StandardBoneNames = "{d}足先EX" + LEG_IK_PARENT StandardBoneNames = "{d}足IK親" + LEG_IK StandardBoneNames = "{d}足ＩＫ" + TOE_IK StandardBoneNames = "{d}つま先ＩＫ" + HEEL StandardBoneNames = "{d}かかと" +) + +func (s StandardBoneNames) String() string { + return string(s) +} + +func (s StandardBoneNames) StringFromDirection(direction string) string { + return strings.ReplaceAll(string(s), "{d}", direction) +} + +func (s StandardBoneNames) Right() string { + return strings.ReplaceAll(string(s), "{d}", "右") +} + +func (s StandardBoneNames) Left() string { + return strings.ReplaceAll(string(s), "{d}", "左") +} + +var configOnce sync.Once +var standardBoneConfigs map[StandardBoneNames]*BoneConfig + +func GetStandardBoneConfigs() map[StandardBoneNames]*BoneConfig { + configOnce.Do(func() { + standardBoneConfigs = map[StandardBoneNames]*BoneConfig{ + ROOT: NewBoneConfig(ROOT, + []StandardBoneNames{}, + mmath.MVec3UnitY, + []StandardBoneNames{CENTER}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_TRANSLATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_ROOT}), + CENTER: NewBoneConfig(CENTER, + []StandardBoneNames{ROOT}, + mmath.MVec3UnitY, + []StandardBoneNames{GROOVE, WAIST, UPPER, LOWER}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_TRANSLATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_ROOT}), + GROOVE: NewBoneConfig(GROOVE, + []StandardBoneNames{CENTER}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{WAIST, UPPER, LOWER}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_TRANSLATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_ROOT}), + WAIST: NewBoneConfig(WAIST, + []StandardBoneNames{GROOVE, CENTER}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{UPPER, LOWER}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_TRANSLATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_ROOT}), + LOWER: NewBoneConfig(LOWER, + []StandardBoneNames{WAIST, GROOVE, CENTER}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{LEG_CENTER}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_LOWER}), + LEG_CENTER: NewBoneConfig(LEG_CENTER, + []StandardBoneNames{LOWER}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{LEG}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_LOWER}), + UPPER: NewBoneConfig(UPPER, + []StandardBoneNames{WAIST, GROOVE, CENTER}, + mmath.MVec3UnitY, + []StandardBoneNames{UPPER2}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_UPPER}), + UPPER2: NewBoneConfig(UPPER2, + []StandardBoneNames{UPPER}, + mmath.MVec3UnitY, + []StandardBoneNames{UPPER3, NECK_ROOT}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_UPPER}), + UPPER3: NewBoneConfig(UPPER3, + []StandardBoneNames{UPPER2}, + mmath.MVec3UnitY, + []StandardBoneNames{NECK_ROOT}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_UPPER}), + NECK_ROOT: NewBoneConfig(NECK_ROOT, + []StandardBoneNames{UPPER3, UPPER2, UPPER}, + mmath.MVec3UnitY, + []StandardBoneNames{NECK}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER}), + NECK: NewBoneConfig(NECK, + []StandardBoneNames{NECK_ROOT, UPPER3, UPPER2, UPPER}, + mmath.MVec3UnitY, + []StandardBoneNames{HEAD}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_HEAD}), + HEAD: NewBoneConfig(HEAD, + []StandardBoneNames{NECK}, + mmath.MVec3UnitY, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_HEAD}), + EYES: NewBoneConfig(EYES, + []StandardBoneNames{HEAD}, + mmath.MVec3UnitY, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_HEAD}), + EYE: NewBoneConfig(EYE, + []StandardBoneNames{HEAD}, + mmath.MVec3UnitY, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_IS_EXTERNAL_ROTATION), + []BoneCategory{CATEGORY_UPPER, CATEGORY_HEAD}), + BUST: NewBoneConfig(BUST, + []StandardBoneNames{UPPER3, UPPER2, UPPER}, + &mmath.MVec3{0, 0, -1}, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER}), + SHOULDER_ROOT: NewBoneConfig(SHOULDER_ROOT, + []StandardBoneNames{NECK_ROOT}, + mmath.MVec3UnitY, + []StandardBoneNames{SHOULDER_P, SHOULDER}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM}), + SHOULDER_P: NewBoneConfig(SHOULDER_P, + []StandardBoneNames{SHOULDER_ROOT}, + mmath.MVec3UnitY, + []StandardBoneNames{SHOULDER}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM}), + SHOULDER: NewBoneConfig(SHOULDER, + []StandardBoneNames{SHOULDER_P, SHOULDER_ROOT}, + mmath.MVec3UnitY, + []StandardBoneNames{SHOULDER_C, ARM}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM}), + SHOULDER_C: NewBoneConfig(SHOULDER_C, + []StandardBoneNames{SHOULDER}, + mmath.MVec3UnitY, + []StandardBoneNames{ARM}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_IS_EXTERNAL_ROTATION), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM}), + ARM: NewBoneConfig(ARM, + []StandardBoneNames{SHOULDER_C, SHOULDER}, + mmath.MVec3UnitY, + []StandardBoneNames{ARM_TWIST, ELBOW}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM}), + ARM_TWIST: NewBoneConfig(ARM_TWIST, + []StandardBoneNames{ARM}, + mmath.MVec3UnitY, + []StandardBoneNames{ELBOW}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_HAS_FIXED_AXIS), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_TWIST, CATEGORY_NO_LOCAL_CANCEL}), + ELBOW: NewBoneConfig(ELBOW, + []StandardBoneNames{ARM_TWIST, ARM}, + mmath.MVec3UnitY, + []StandardBoneNames{WRIST_TWIST, WRIST}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM}), + WRIST_TWIST: NewBoneConfig(WRIST_TWIST, + []StandardBoneNames{ELBOW}, + mmath.MVec3UnitY, + []StandardBoneNames{WRIST}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_HAS_FIXED_AXIS), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_TWIST, CATEGORY_NO_LOCAL_CANCEL}), + WRIST: NewBoneConfig(WRIST, + []StandardBoneNames{WRIST_TWIST, ELBOW}, + mmath.MVec3UnitY, + []StandardBoneNames{INDEX1, MIDDLE1, RING1, PINKY1}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM}), + THUMB0: NewBoneConfig(THUMB0, + []StandardBoneNames{WRIST}, + mmath.MVec3UnitY, + []StandardBoneNames{THUMB1}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + THUMB1: NewBoneConfig(THUMB1, + []StandardBoneNames{THUMB0}, + mmath.MVec3UnitY, + []StandardBoneNames{THUMB2}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + THUMB2: NewBoneConfig(THUMB2, + []StandardBoneNames{THUMB1}, + mmath.MVec3UnitY, + []StandardBoneNames{THUMB_TAIL}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + THUMB_TAIL: NewBoneConfig(THUMB_TAIL, + []StandardBoneNames{THUMB2}, + mmath.MVec3UnitY, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + INDEX1: NewBoneConfig(INDEX1, + []StandardBoneNames{WRIST}, + mmath.MVec3UnitY, + []StandardBoneNames{INDEX2}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + INDEX2: NewBoneConfig(INDEX2, + []StandardBoneNames{INDEX1}, + mmath.MVec3UnitY, + []StandardBoneNames{INDEX3}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + INDEX3: NewBoneConfig(INDEX3, + []StandardBoneNames{INDEX2}, + mmath.MVec3UnitY, + []StandardBoneNames{INDEX_TAIL}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + INDEX_TAIL: NewBoneConfig(INDEX_TAIL, + []StandardBoneNames{INDEX3}, + mmath.MVec3UnitY, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + MIDDLE1: NewBoneConfig(MIDDLE1, + []StandardBoneNames{WRIST}, + mmath.MVec3UnitY, + []StandardBoneNames{MIDDLE2}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + MIDDLE2: NewBoneConfig(MIDDLE2, + []StandardBoneNames{MIDDLE1}, + mmath.MVec3UnitY, + []StandardBoneNames{MIDDLE3}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + MIDDLE3: NewBoneConfig(MIDDLE3, + []StandardBoneNames{MIDDLE2}, + mmath.MVec3UnitY, + []StandardBoneNames{MIDDLE_TAIL}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + MIDDLE_TAIL: NewBoneConfig(MIDDLE_TAIL, + []StandardBoneNames{MIDDLE3}, + mmath.MVec3UnitY, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + RING1: NewBoneConfig(RING1, + []StandardBoneNames{WRIST}, + mmath.MVec3UnitY, + []StandardBoneNames{RING2}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + RING2: NewBoneConfig(RING2, + []StandardBoneNames{RING1}, + mmath.MVec3UnitY, + []StandardBoneNames{RING3}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + RING3: NewBoneConfig(RING3, + []StandardBoneNames{RING2}, + mmath.MVec3UnitY, + []StandardBoneNames{RING_TAIL}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + RING_TAIL: NewBoneConfig(RING_TAIL, + []StandardBoneNames{RING3}, + mmath.MVec3UnitY, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + PINKY1: NewBoneConfig(PINKY1, + []StandardBoneNames{WRIST}, + mmath.MVec3UnitY, + []StandardBoneNames{PINKY2}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + PINKY2: NewBoneConfig(PINKY2, + []StandardBoneNames{PINKY1}, + mmath.MVec3UnitY, + []StandardBoneNames{PINKY3}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + PINKY3: NewBoneConfig(PINKY3, + []StandardBoneNames{PINKY2}, + mmath.MVec3UnitY, + []StandardBoneNames{PINKY_TAIL}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_TAIL_IS_BONE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + PINKY_TAIL: NewBoneConfig(PINKY_TAIL, + []StandardBoneNames{PINKY3}, + mmath.MVec3UnitY, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_UPPER, CATEGORY_ARM, CATEGORY_FINGER, CATEGORY_NO_LOCAL_CANCEL}), + WAIST_CANCEL: NewBoneConfig(WAIST_CANCEL, + []StandardBoneNames{WAIST}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_IS_EXTERNAL_ROTATION), + []BoneCategory{CATEGORY_LOWER}), + LEG: NewBoneConfig(LEG, + []StandardBoneNames{WAIST_CANCEL, LEG_CENTER, LOWER}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{KNEE}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_LOWER, CATEGORY_LEG, CATEGORY_LEG_FK}), + KNEE: NewBoneConfig(KNEE, + []StandardBoneNames{LEG}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{ANKLE}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_LOWER, CATEGORY_LEG, CATEGORY_LEG_FK}), + ANKLE: NewBoneConfig(ANKLE, + []StandardBoneNames{KNEE}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{TOE}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_LOWER, CATEGORY_LEG, CATEGORY_LEG_FK, CATEGORY_ANKLE}), + TOE: NewBoneConfig(TOE, + []StandardBoneNames{ANKLE}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_LOWER, CATEGORY_LEG, CATEGORY_LEG_FK, CATEGORY_ANKLE}), + LEG_D: NewBoneConfig(LEG_D, + []StandardBoneNames{WAIST_CANCEL, LEG_CENTER, LOWER}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{KNEE_D}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_LOWER, CATEGORY_LEG, CATEGORY_LEG_D}), + KNEE_D: NewBoneConfig(KNEE_D, + []StandardBoneNames{LEG_D}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{ANKLE_D}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_LOWER, CATEGORY_LEG, CATEGORY_LEG_D}), + ANKLE_D: NewBoneConfig(ANKLE_D, + []StandardBoneNames{KNEE_D}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{TOE_EX}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_LOWER, CATEGORY_LEG, CATEGORY_LEG_D, CATEGORY_ANKLE}), + TOE_EX: NewBoneConfig(TOE_EX, + []StandardBoneNames{ANKLE_D}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_LOWER, CATEGORY_LEG, CATEGORY_LEG_D, CATEGORY_ANKLE, CATEGORY_NO_LOCAL_CANCEL}), + LEG_IK_PARENT: NewBoneConfig(LEG_IK_PARENT, + []StandardBoneNames{ROOT}, + mmath.MVec3UnitY, + []StandardBoneNames{LEG_IK}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_TRANSLATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE), + []BoneCategory{CATEGORY_LOWER}), + LEG_IK: NewBoneConfig(LEG_IK, + []StandardBoneNames{LEG_IK_PARENT, ROOT}, + mmath.MVec3UnitY, + []StandardBoneNames{TOE_IK}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_TRANSLATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_IS_IK|BONE_FLAG_TAIL_IS_BONE), + []BoneCategory{CATEGORY_LOWER}), + TOE_IK: NewBoneConfig(TOE_IK, + []StandardBoneNames{LEG_IK}, + &mmath.MVec3{0, -1, 0}, + []StandardBoneNames{}, + BoneFlag(BONE_FLAG_CAN_ROTATE|BONE_FLAG_CAN_TRANSLATE|BONE_FLAG_CAN_MANIPULATE|BONE_FLAG_IS_VISIBLE|BONE_FLAG_IS_IK), + []BoneCategory{CATEGORY_LOWER}), + } + }) + return standardBoneConfigs +} diff --git a/pkg/pmx/bone_cui.go b/pkg/pmx/bone_cui.go new file mode 100644 index 00000000..6977c876 --- /dev/null +++ b/pkg/pmx/bone_cui.go @@ -0,0 +1,26 @@ +//go:build linux +// +build linux + +package pmx + +import ( + "github.com/miu200521358/mlib_go/pkg/mcore" +) + +// ボーンリスト +type Bones struct { + *mcore.IndexNameModels[*Bone] + IkTreeIndexes map[int][]int + LayerSortedBones map[bool][]*Bone + LayerSortedNames map[bool]map[string]int + DeformBoneIndexes map[int][]int +} + +func NewBones(count int) *Bones { + return &Bones{ + IndexNameModels: mcore.NewIndexNameModels[*Bone](count, func() *Bone { return nil }), + IkTreeIndexes: make(map[int][]int), + LayerSortedBones: make(map[bool][]*Bone), + LayerSortedNames: make(map[bool]map[string]int), + } +} diff --git a/pkg/pmx/bone_gui.go b/pkg/pmx/bone_gui.go new file mode 100644 index 00000000..125bccbb --- /dev/null +++ b/pkg/pmx/bone_gui.go @@ -0,0 +1,255 @@ +//go:build windows +// +build windows + +package pmx + +import ( + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mview" +) + +var bone_colors_ik = []float32{1.0, 0.38, 0, 1.0} +var bone_colors_ik_normal = []float32{1.0, 0.58, 0.2, 0.7} +var bone_colors_ik_target = []float32{1.0, 0.57, 0.61, 1.0} +var bone_colors_ik_target_normal = []float32{1.0, 0.77, 0.81, 0.7} +var bone_colors_ik_link = []float32{1.0, 0.83, 0.49, 1.0} +var bone_colors_ik_link_normal = []float32{1.0, 1.0, 0.69, 0.7} +var bone_colors_fixed = []float32{0.72, 0.32, 1.0, 1.0} +var bone_colors_fixed_normal = []float32{0.92, 0.52, 1.0, 0.7} +var bone_colors_effect = []float32{0.68, 0.64, 1.0, 1.0} +var bone_colors_effect_normal = []float32{0.88, 0.84, 1.0, 0.7} +var bone_colors_translate = []float32{0.70, 1.0, 0.54, 1.0} +var bone_colors_translate_normal = []float32{0.90, 1.0, 0.74, 0.7} +var bone_colors_invisible = []float32{0.82, 0.82, 0.82, 1.0} +var bone_colors_invisible_normal = []float32{0.92, 0.92, 0.92, 0.7} +var bone_colors_rotate = []float32{0.56, 0.78, 1.0, 1.0} +var bone_colors_rotate_normal = []float32{0.76, 0.98, 1.00, 0.7} + +func (b *Bone) color(isNormal bool) []float32 { + // ボーンの種類で色を変える + if b.IsIK() { + // IKボーン + if isNormal { + return bone_colors_ik_normal + } + return bone_colors_ik + } else if len(b.IkTargetBoneIndexes) > 0 { + // IK先 + if isNormal { + return bone_colors_ik_target_normal + } + return bone_colors_ik_target + } else if len(b.IkLinkBoneIndexes) > 0 { + // IKリンク + if isNormal { + return bone_colors_ik_link_normal + } + return bone_colors_ik_link + } else if b.HasFixedAxis() { + // 軸制限 + if isNormal { + return bone_colors_fixed_normal + } + return bone_colors_fixed + } else if b.IsEffectorRotation() || b.IsEffectorTranslation() { + // 付与親 + if isNormal { + return bone_colors_effect_normal + } + return bone_colors_effect + } else if b.CanTranslate() { + // 移動可能 + if isNormal { + return bone_colors_translate_normal + } + return bone_colors_translate + } else if !b.IsVisible() { + // 非表示 + if isNormal { + return bone_colors_invisible_normal + } + return bone_colors_invisible + } + + // それ以外（回転） + if isNormal { + return bone_colors_rotate_normal + } + return bone_colors_rotate +} + +func (b *Bone) GL() []float32 { + p := b.Position.GL() + c := b.color(false) + return []float32{ + p[0], p[1], p[2], // 位置 + float32(b.BoneFlag), 0.0, 0.0, // 法線 + float32(0), float32(0), // UV + float32(0), float32(0), // 追加UV + float32(0), // エッジ倍率 + float32(b.Index), 0, 0, 0, // デフォームボーンINDEX + 1, 0, 0, 0, // デフォームボーンウェイト + 0, // SDEFであるか否か + 0, 0, 0, // SDEF-C + 0, 0, 0, // SDEF-R0 + 0, 0, 0, // SDEF-R1 + 0.0, 0.0, 0.0, // 頂点モーフ + 0.0, 0.0, 0.0, 0.0, // UVモーフ + c[0], c[1], c[2], c[3], // 追加UV1モーフ + 0.0, 0.0, 0.0, // 変形後頂点モーフ + } +} + +func (b *Bone) ParentGL() []float32 { + p := b.Position.Subed(b.ParentRelativePosition).GL() + c := b.color(false) + return []float32{ + p[0], p[1], p[2], // 位置 + float32(b.BoneFlag), 0.0, 0.0, // 法線 + float32(0), float32(0), // UV + float32(0), float32(0), // 追加UV + float32(0), // エッジ倍率 + float32(b.Index), 0, 0, 0, // デフォームボーンINDEX + 1, 0, 0, 0, // デフォームボーンウェイト + 0, // SDEFであるか否か + 0, 0, 0, // SDEF-C + 0, 0, 0, // SDEF-R0 + 0, 0, 0, // SDEF-R1 + 0.0, 0.0, 0.0, // 頂点モーフ + 0.0, 0.0, 0.0, 0.0, // UVモーフ + c[0], c[1], c[2], c[3], // 追加UV1モーフ + 0.0, 0.0, 0.0, // 変形後頂点モーフ + } +} + +func (b *Bone) TailGL() []float32 { + p := b.Position.Added(b.ChildRelativePosition).GL() + c := b.color(false) + return []float32{ + p[0], p[1], p[2], // 位置 + float32(b.BoneFlag), 0.0, 0.0, // 法線 + float32(0), float32(0), // UV + float32(0), float32(0), // 追加UV + float32(0), // エッジ倍率 + float32(b.Index), 0, 0, 0, // デフォームボーンINDEX + 1, 0, 0, 0, // デフォームボーンウェイト + 0, // SDEFであるか否か + 0, 0, 0, // SDEF-C + 0, 0, 0, // SDEF-R0 + 0, 0, 0, // SDEF-R1 + 0.0, 0.0, 0.0, // 頂点モーフ + 0.0, 0.0, 0.0, 0.0, // UVモーフ + c[0], c[1], c[2], c[3], // 追加UV1モーフ + 0.0, 0.0, 0.0, // 変形後頂点モーフ + } +} + +func (b *Bone) DeltaGL(isDrawBones map[BoneFlag]bool) []float32 { + c := b.color(false) + + ikAlpha := float32(1.0) + fixedAlpha := float32(1.0) + effectorRotateAlpha := float32(1.0) + effectorTranslateAlpha := float32(1.0) + rotateAlpha := float32(1.0) + translateAlpha := float32(1.0) + visibleAlpha := float32(1.0) + // IK + if (!isDrawBones[BONE_FLAG_IS_IK] && !isDrawBones[BONE_FLAG_NONE]) || + (isDrawBones[BONE_FLAG_IS_IK] && !(b.IsIK() || len(b.IkLinkBoneIndexes) > 0 || len(b.IkTargetBoneIndexes) > 0)) { + ikAlpha = float32(0.0) + } + // 付与親回転 + if (!isDrawBones[BONE_FLAG_IS_EXTERNAL_ROTATION] && !isDrawBones[BONE_FLAG_NONE]) || + (isDrawBones[BONE_FLAG_IS_EXTERNAL_ROTATION] && !(b.IsEffectorRotation() || len(b.EffectiveBoneIndexes) > 0)) { + effectorRotateAlpha = float32(0.0) + } + // 付与親移動 + if (!isDrawBones[BONE_FLAG_IS_EXTERNAL_TRANSLATION] && !isDrawBones[BONE_FLAG_NONE]) || + (isDrawBones[BONE_FLAG_IS_EXTERNAL_TRANSLATION] && !(b.IsEffectorTranslation() || len(b.EffectiveBoneIndexes) > 0)) { + effectorTranslateAlpha = float32(0.0) + } + // 軸固定 + if (!isDrawBones[BONE_FLAG_HAS_FIXED_AXIS] && !isDrawBones[BONE_FLAG_NONE]) || + (isDrawBones[BONE_FLAG_HAS_FIXED_AXIS] && !b.HasFixedAxis()) { + fixedAlpha = float32(0.0) + } + // 回転 + if (!isDrawBones[BONE_FLAG_CAN_ROTATE] && !isDrawBones[BONE_FLAG_NONE]) || + (isDrawBones[BONE_FLAG_CAN_ROTATE] && !b.CanRotate()) { + rotateAlpha = float32(0.0) + } + // 移動 + if (!isDrawBones[BONE_FLAG_CAN_TRANSLATE] && !isDrawBones[BONE_FLAG_NONE]) || + (isDrawBones[BONE_FLAG_CAN_TRANSLATE] && !b.CanTranslate()) { + translateAlpha = float32(0.0) + } + // 表示 + if (!isDrawBones[BONE_FLAG_IS_VISIBLE] && !isDrawBones[BONE_FLAG_NONE]) || + (isDrawBones[BONE_FLAG_IS_VISIBLE] && !b.IsVisible()) { + visibleAlpha = float32(0.0) + } + + // それぞれのボーン種別による透明度最大値を採用 + alpha := max(ikAlpha, fixedAlpha, effectorRotateAlpha, effectorTranslateAlpha, + rotateAlpha, translateAlpha, visibleAlpha) + return []float32{ + 0.0, 0.0, 0.0, // 頂点モーフ + 0.0, 0.0, 0.0, 0.0, // UVモーフ + c[0], c[1], c[2], c[3] * alpha, // 追加UV1モーフ + 0.0, 0.0, 0.0, // 変形後頂点モーフ + } +} + +func (b *Bone) NormalGL() []float32 { + p := b.LocalMatrix.MulVec3(&mmath.MVec3{0, 0.6, 0}).GL() + c := b.color(true) + return []float32{ + p[0], p[1], p[2], // 位置 + 0.0, 0.0, 0.0, // 法線 + float32(0), float32(0), // UV + float32(0), float32(0), // 追加UV + float32(0), // エッジ倍率 + float32(b.Index), 0, 0, 0, // デフォームボーンINDEX + 1, 0, 0, 0, // デフォームボーンウェイト + 0, // SDEFであるか否か + 0, 0, 0, // SDEF-C + 0, 0, 0, // SDEF-R0 + 0, 0, 0, // SDEF-R1 + 0.0, 0.0, 0.0, // 頂点モーフ + 0.0, 0.0, 0.0, 0.0, // UVモーフ + c[0], c[1], c[2], c[3], // 追加UV1モーフ + 0.0, 0.0, 0.0, // 変形後頂点モーフ + } +} + +// ボーンリスト +type Bones struct { + *mcore.IndexNameModels[*Bone] + IkTreeIndexes map[int][]int + LayerSortedBones map[bool][]*Bone + LayerSortedNames map[bool]map[string]int + DeformBoneIndexes map[int][]int + positionVao *mview.VAO + positionIbo *mview.IBO + positionIboCount int32 + normalVao *mview.VAO + normalIbo *mview.IBO + normalIboCount int32 +} + +func NewBones(count int) *Bones { + return &Bones{ + IndexNameModels: mcore.NewIndexNameModels[*Bone](count, func() *Bone { return nil }), + IkTreeIndexes: make(map[int][]int), + LayerSortedBones: make(map[bool][]*Bone), + LayerSortedNames: make(map[bool]map[string]int), + positionVao: nil, + positionIbo: nil, + positionIboCount: 0, + normalVao: nil, + normalIbo: nil, + normalIboCount: 0, + } +} diff --git a/pkg/pmx/bone_test.go b/pkg/pmx/bone_test.go new file mode 100644 index 00000000..8a82ee60 --- /dev/null +++ b/pkg/pmx/bone_test.go @@ -0,0 +1,294 @@ +package pmx + +import ( + "testing" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +func TestIkLink_Copy(t *testing.T) { + ikLink := &IkLink{ + BoneIndex: 0, + AngleLimit: true, + MinAngleLimit: mmath.NewRotation(), + MaxAngleLimit: mmath.NewRotation(), + LocalAngleLimit: true, + LocalMinAngleLimit: mmath.NewRotation(), + LocalMaxAngleLimit: mmath.NewRotation(), + } + + copied := ikLink.Copy() + + if copied == ikLink { + t.Error("Expected Copy() to return a different instance") + } + + if copied.BoneIndex != ikLink.BoneIndex { + t.Error("Expected BoneIndex to match the original") + } + if copied.AngleLimit != ikLink.AngleLimit { + t.Error("Expected AngleLimit to match the original") + } + if copied.MinAngleLimit.String() != ikLink.MinAngleLimit.String() { + t.Error("Expected MinAngleLimit to match the original") + } + if copied.MaxAngleLimit.String() != ikLink.MaxAngleLimit.String() { + t.Error("Expected MaxAngleLimit to match the original") + } + if copied.LocalAngleLimit != ikLink.LocalAngleLimit { + t.Error("Expected LocalAngleLimit to match the original") + } + if copied.LocalMinAngleLimit.String() != ikLink.LocalMinAngleLimit.String() { + t.Error("Expected LocalMinAngleLimit to match the original") + } + if copied.LocalMaxAngleLimit.String() != ikLink.LocalMaxAngleLimit.String() { + t.Error("Expected LocalMaxAngleLimit to match the original") + } +} + +func TestIk_Copy(t *testing.T) { + ik := &Ik{ + BoneIndex: 0, + LoopCount: 1, + UnitRotation: mmath.NewRotationFromDegrees(&mmath.MVec3{1, 2, 3}), + Links: []*IkLink{ + { + BoneIndex: 0, + AngleLimit: true, + MinAngleLimit: mmath.NewRotationFromDegrees(&mmath.MVec3{1, 2, 3}), + MaxAngleLimit: mmath.NewRotationFromDegrees(&mmath.MVec3{4, 5, 6}), + LocalAngleLimit: true, + LocalMinAngleLimit: mmath.NewRotationFromDegrees(&mmath.MVec3{7, 8, 9}), + LocalMaxAngleLimit: mmath.NewRotationFromDegrees(&mmath.MVec3{10, 11, 12}), + }, + }, + } + + copied := ik.Copy() + + if copied.BoneIndex != ik.BoneIndex { + t.Error("Expected BoneIndex to match the original") + } + + if copied.LoopCount != ik.LoopCount { + t.Error("Expected LoopCount to match the original") + } + + if !copied.UnitRotation.GetDegrees().NearEquals(ik.UnitRotation.GetDegrees(), 1e-8) { + t.Error("Expected UnitRotation to match the original") + } + + if len(copied.Links) != len(ik.Links) { + t.Error("Expected the length of Links to match the original") + } + + if &copied.Links[0] == &ik.Links[0] { + t.Error("Expected Links[0] to be a different instance") + } +} + +func TestBone_NormalizeFixedAxis(t *testing.T) { + b := &Bone{} + correctedFixedAxis := mmath.MVec3{1, 0, 0} + b.NormalizeFixedAxis(&correctedFixedAxis) + + if !b.NormalizedFixedAxis.Equals(correctedFixedAxis.Normalize()) { + t.Errorf("Expected NormalizedFixedAxis to be normalized") + } +} + +func TestBone_IsTailBone(t *testing.T) { + b := &Bone{BoneFlag: BONE_FLAG_TAIL_IS_BONE} + if !b.IsTailBone() { + t.Errorf("Expected IsTailBone to return true") + } + + b.BoneFlag = 0 + if b.IsTailBone() { + t.Errorf("Expected IsTailBone to return false") + } +} + +func TestBone_IsLegD(t *testing.T) { + b1 := NewBoneByName("左足D") + if !b1.IsLegD() { + t.Errorf("Expected IsLegD to return true") + } + + b2 := NewBoneByName("右腕") + if b2.IsLegD() { + t.Errorf("Expected IsLegD to return false") + } +} + +func TestBone_Copy(t *testing.T) { + t.Run("Test Copy", func(t *testing.T) { + b := &Bone{ + IndexNameModel: &mcore.IndexNameModel{Index: 0, Name: "Bone"}, + Ik: NewIk(), + Position: &mmath.MVec3{1, 2, 3}, + TailPosition: &mmath.MVec3{4, 5, 6}, + FixedAxis: &mmath.MVec3{7, 8, 9}, + LocalAxisX: &mmath.MVec3{10, 11, 12}, + LocalAxisZ: &mmath.MVec3{13, 14, 15}, + NormalizedLocalAxisZ: &mmath.MVec3{16, 17, 18}, + NormalizedLocalAxisX: &mmath.MVec3{19, 20, 21}, + NormalizedLocalAxisY: &mmath.MVec3{22, 23, 24}, + LocalAxis: &mmath.MVec3{25, 26, 27}, + ParentRelativePosition: &mmath.MVec3{28, 29, 30}, + ChildRelativePosition: &mmath.MVec3{31, 32, 33}, + NormalizedFixedAxis: &mmath.MVec3{34, 35, 36}, + IkLinkBoneIndexes: []int{1, 3, 5}, + IkTargetBoneIndexes: []int{2, 4, 6}, + TreeBoneIndexes: []int{3, 5, 7}, + RevertOffsetMatrix: &mmath.MMat4{}, + OffsetMatrix: &mmath.MMat4{}, + RelativeBoneIndexes: []int{8, 9, 10}, + ChildBoneIndexes: []int{10, 11, 12}, + EffectiveBoneIndexes: []int{16, 17, 18}, + MinAngleLimit: mmath.NewRotationFromRadians(&mmath.MVec3{1, 2, 3}), + MaxAngleLimit: mmath.NewRotationFromRadians(&mmath.MVec3{5, 6, 7}), + LocalMinAngleLimit: mmath.NewRotationFromRadians(&mmath.MVec3{10, 11, 12}), + LocalMaxAngleLimit: mmath.NewRotationFromRadians(&mmath.MVec3{16, 17, 18}), + } + + copied := b.Copy().(*Bone) + + // Assert copied fields are not the same as original + if copied == b { + t.Errorf("Expected copied bone to be different from original") + } + + // Assert copied fields are deep copies + if copied.Ik == b.Ik { + t.Errorf("Expected copied Ik to be a deep copy") + } + if !copied.Position.NearEquals(b.Position, 1e-10) { + t.Errorf("Expected copied Position to be a deep copy of original Position %s %s", copied.Position.String(), b.Position.String()) + } + if &copied.Position == &b.Position { + t.Errorf("Expected copied Position to be a deep copy of original Position %s %s", copied.Position.String(), b.Position.String()) + } + if !copied.TailPosition.NearEquals(b.TailPosition, 1e-10) { + t.Errorf("Expected copied TailPosition to be a deep copy of original TailPosition %s %s", copied.TailPosition.String(), b.TailPosition.String()) + } + if &copied.TailPosition == &b.TailPosition { + t.Errorf("Expected copied TailPosition to be a deep copy of original TailPosition %s %s", copied.TailPosition.String(), b.TailPosition.String()) + } + if !copied.FixedAxis.NearEquals(b.FixedAxis, 1e-10) { + t.Errorf("Expected copied FixedAxis to be a deep copy of original FixedAxis %s %s", copied.FixedAxis.String(), b.FixedAxis.String()) + } + if &copied.FixedAxis == &b.FixedAxis { + t.Errorf("Expected copied FixedAxis to be a deep copy of original FixedAxis %s %s", copied.FixedAxis.String(), b.FixedAxis.String()) + } + if !copied.LocalAxisX.NearEquals(b.LocalAxisX, 1e-10) { + t.Errorf("Expected copied LocalXVector to be a deep copy of original LocalXVector %s %s", copied.LocalAxisX.String(), b.LocalAxisX.String()) + } + if &copied.LocalAxisX == &b.LocalAxisX { + t.Errorf("Expected copied LocalXVector to be a deep copy of original LocalXVector %s %s", copied.LocalAxisX.String(), b.LocalAxisX.String()) + } + if !copied.LocalAxisZ.NearEquals(b.LocalAxisZ, 1e-10) { + t.Errorf("Expected copied LocalZVector to be a deep copy of original LocalZVector %s %s", copied.LocalAxisZ.String(), b.LocalAxisZ.String()) + } + if &copied.LocalAxisZ == &b.LocalAxisZ { + t.Errorf("Expected copied LocalZVector to be a deep copy of original LocalZVector %s %s", copied.LocalAxisZ.String(), b.LocalAxisZ.String()) + } + if !copied.NormalizedLocalAxisZ.NearEquals(b.NormalizedLocalAxisZ, 1e-10) { + t.Errorf("Expected copied NormalizedLocalXVector to be a deep copy of original NormalizedLocalXVector %s %s", copied.NormalizedLocalAxisZ.String(), b.NormalizedLocalAxisZ.String()) + } + if &copied.NormalizedLocalAxisZ == &b.NormalizedLocalAxisZ { + t.Errorf("Expected copied NormalizedLocalXVector to be a deep copy of original NormalizedLocalXVector %s %s", copied.NormalizedLocalAxisZ.String(), b.NormalizedLocalAxisZ.String()) + } + if !copied.NormalizedLocalAxisX.NearEquals(b.NormalizedLocalAxisX, 1e-10) { + t.Errorf("Expected copied NormalizedLocalYVector to be a deep copy of original NormalizedLocalYVector %s %s", copied.NormalizedLocalAxisX.String(), b.NormalizedLocalAxisX.String()) + } + if &copied.NormalizedLocalAxisX == &b.NormalizedLocalAxisX { + t.Errorf("Expected copied NormalizedLocalYVector to be a deep copy of original NormalizedLocalYVector %s %s", copied.NormalizedLocalAxisX.String(), b.NormalizedLocalAxisX.String()) + } + if !copied.NormalizedLocalAxisY.NearEquals(b.NormalizedLocalAxisY, 1e-10) { + t.Errorf("Expected copied NormalizedLocalZVector to be a deep copy of original NormalizedLocalZVector %s %s", copied.NormalizedLocalAxisY.String(), b.NormalizedLocalAxisY.String()) + } + if &copied.NormalizedLocalAxisY == &b.NormalizedLocalAxisY { + t.Errorf("Expected copied NormalizedLocalZVector to be a deep copy of original NormalizedLocalZVector %s %s", copied.NormalizedLocalAxisY.String(), b.NormalizedLocalAxisY.String()) + } + if !copied.LocalAxis.NearEquals(b.LocalAxis, 1e-10) { + t.Errorf("Expected copied LocalAxis to be a deep copy of original LocalAxis %s %s", copied.LocalAxis.String(), b.LocalAxis.String()) + } + if &copied.LocalAxis == &b.LocalAxis { + t.Errorf("Expected copied LocalAxis to be a deep copy of original LocalAxis %s %s", copied.LocalAxis.String(), b.LocalAxis.String()) + } + if !copied.ParentRelativePosition.NearEquals(b.ParentRelativePosition, 1e-10) { + t.Errorf("Expected copied ParentRelativePosition to be a deep copy of original ParentRelativePosition %s %s", copied.ParentRelativePosition.String(), b.ParentRelativePosition.String()) + } + if &copied.ParentRelativePosition == &b.ParentRelativePosition { + t.Errorf("Expected copied ParentRelativePosition to be a deep copy of original ParentRelativePosition %s %s", copied.ParentRelativePosition.String(), b.ParentRelativePosition.String()) + } + if !copied.ChildRelativePosition.NearEquals(b.ChildRelativePosition, 1e-10) { + t.Errorf("Expected copied TailRelativePosition to be a deep copy of original TailRelativePosition %s %s", copied.ChildRelativePosition.String(), b.ChildRelativePosition.String()) + } + if &copied.ChildRelativePosition == &b.ChildRelativePosition { + t.Errorf("Expected copied TailRelativePosition to be a deep copy of original TailRelativePosition %s %s", copied.ChildRelativePosition.String(), b.ChildRelativePosition.String()) + } + if !copied.NormalizedFixedAxis.NearEquals(b.NormalizedFixedAxis, 1e-10) { + t.Errorf("Expected copied NormalizedFixedAxis to be a deep copy of original NormalizedFixedAxis %s %s", copied.NormalizedFixedAxis.String(), b.NormalizedFixedAxis.String()) + } + if &copied.NormalizedFixedAxis == &b.NormalizedFixedAxis { + t.Errorf("Expected copied NormalizedFixedAxis to be a deep copy of original NormalizedFixedAxis %s %s", copied.NormalizedFixedAxis.String(), b.NormalizedFixedAxis.String()) + } + if len(copied.IkLinkBoneIndexes) != len(b.IkLinkBoneIndexes) { + t.Errorf("Expected copied IkLinkIndexes to have the same length as original") + } + if len(copied.IkTargetBoneIndexes) != len(b.IkTargetBoneIndexes) { + t.Errorf("Expected copied IkTargetIndexes to have the same length as original") + } + if len(copied.TreeBoneIndexes) != len(b.TreeBoneIndexes) { + t.Errorf("Expected copied TreeIndexes to have the same length as original") + } + if !copied.RevertOffsetMatrix.NearEquals(b.RevertOffsetMatrix, 1e-10) { + t.Errorf("Expected copied ParentRevertMatrix to be a deep copy %s %s", copied.RevertOffsetMatrix.String(), b.RevertOffsetMatrix.String()) + } + if &copied.RevertOffsetMatrix == &b.RevertOffsetMatrix { + t.Errorf("Expected copied ParentRevertMatrix to be a deep copy") + } + if !copied.OffsetMatrix.NearEquals(b.OffsetMatrix, 1e-10) { + t.Errorf("Expected copied OffsetMatrix to be a deep copy %s %s", copied.OffsetMatrix.String(), b.OffsetMatrix.String()) + } + if &copied.OffsetMatrix == &b.OffsetMatrix { + t.Errorf("Expected copied OffsetMatrix to be a deep copy") + } + if len(copied.RelativeBoneIndexes) != len(b.RelativeBoneIndexes) { + t.Errorf("Expected copied RelativeBoneIndexes to have the same length as original") + } + if len(copied.ChildBoneIndexes) != len(b.ChildBoneIndexes) { + t.Errorf("Expected copied ChildBoneIndexes to have the same length as original") + } + if len(copied.EffectiveBoneIndexes) != len(b.EffectiveBoneIndexes) { + t.Errorf("Expected copied EffectiveBoneIndexes to have the same length as original") + } + if !copied.MinAngleLimit.GetDegrees().NearEquals(b.MinAngleLimit.GetDegrees(), 1e-10) { + t.Errorf("Expected copied MinAngleLimit to be a deep copy %s %s", copied.MinAngleLimit.GetDegrees().String(), b.MinAngleLimit.GetDegrees().String()) + } + if &copied.MinAngleLimit == &b.MinAngleLimit { + t.Errorf("Expected copied MinAngleLimit to be a deep copy") + } + if !copied.MaxAngleLimit.GetDegrees().NearEquals(b.MaxAngleLimit.GetDegrees(), 1e-10) { + t.Errorf("Expected copied MaxAngleLimit to be a deep copy %s %s", copied.MaxAngleLimit.GetDegrees().String(), b.MaxAngleLimit.GetDegrees().String()) + } + if &copied.MaxAngleLimit == &b.MaxAngleLimit { + t.Errorf("Expected copied MaxAngleLimit to be a deep copy") + } + if !copied.LocalMinAngleLimit.GetDegrees().NearEquals(b.LocalMinAngleLimit.GetDegrees(), 1e-10) { + t.Errorf("Expected copied LocalMinAngleLimit to be a deep copy %s %s", copied.LocalMinAngleLimit.GetDegrees().String(), b.LocalMinAngleLimit.GetDegrees().String()) + } + if &copied.LocalMinAngleLimit == &b.LocalMinAngleLimit { + t.Errorf("Expected copied LocalMinAngleLimit to be a deep copy") + } + if !copied.LocalMaxAngleLimit.GetDegrees().NearEquals(b.LocalMaxAngleLimit.GetDegrees(), 1e-10) { + t.Errorf("Expected copied LocalMaxAngleLimit to be a deep copy %s %s", copied.LocalMaxAngleLimit.GetDegrees().String(), b.LocalMaxAngleLimit.GetDegrees().String()) + } + if &copied.LocalMaxAngleLimit == &b.LocalMaxAngleLimit { + t.Errorf("Expected copied LocalMaxAngleLimit to be a deep copy") + } + }) +} diff --git a/pkg/pmx/deform.go b/pkg/pmx/deform.go new file mode 100644 index 00000000..283b89ca --- /dev/null +++ b/pkg/pmx/deform.go @@ -0,0 +1,278 @@ +package pmx + +import ( + "sort" + + "github.com/go-gl/mathgl/mgl32" + + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +// DeformType ウェイト変形方式 +type DeformType byte + +const ( + BDEF1 DeformType = 0 + BDEF2 DeformType = 1 + BDEF4 DeformType = 2 + SDEF DeformType = 3 +) + +type IDeform interface { + GetType() DeformType + GetAllIndexes() []int + GetAllWeights() []float64 + GetIndexes(weightThreshold float64) []int + GetWeights(weightThreshold float64) []float64 + NormalizedDeform() [8]float32 + GetSdefParams() (mgl32.Vec3, mgl32.Vec3, mgl32.Vec3) +} + +// Deform デフォーム既定構造体 +type Deform struct { + Indexes []int // ボーンINDEXリスト + Weights []float64 // ウェイトリスト + Count int // デフォームボーン個数 +} + +// NewDeform creates a new Deform instance. +func NewDeform(indexes []int, weights []float64, count int) Deform { + return Deform{ + Indexes: indexes, + Weights: weights, + Count: count, + } +} + +func (d *Deform) GetAllIndexes() []int { + return d.Indexes +} + +func (d *Deform) GetAllWeights() []float64 { + return d.Weights +} + +// GetIndexes ウェイト閾値以上のウェイトを持っているINDEXのみを取得する +func (d *Deform) GetIndexes(weightThreshold float64) []int { + var indexes []int + for i, weight := range d.Weights { + if weight >= weightThreshold { + indexes = append(indexes, d.Indexes[i]) + } + } + return indexes +} + +// GetWeights ウェイト閾値以上のウェイトを持っているウェイトのみを取得する +func (d *Deform) GetWeights(weightThreshold float64) []float64 { + var weights []float64 + for _, weight := range d.Weights { + if weight >= weightThreshold { + weights = append(weights, weight) + } + } + return weights +} + +// Normalize ウェイト正規化 +func (d *Deform) Normalize(align bool) { + if align { + // ウェイトを統合する + indexWeights := make(map[int]float64) + for i, index := range d.Indexes { + if _, ok := indexWeights[index]; !ok { + indexWeights[index] = 0.0 + } + indexWeights[index] += d.Weights[i] + } + + // 揃える必要がある場合、数が足りるよう、かさ増しする + ilist := make([]int, 0, len(indexWeights)+4) + wlist := make([]float64, 0, len(indexWeights)+4) + for index, weight := range indexWeights { + ilist = append(ilist, index) + wlist = append(wlist, weight) + } + for i := len(indexWeights); i < d.Count; i++ { + ilist = append(ilist, 0) + wlist = append(wlist, 0) + } + + // 正規化 + sum := 0.0 + for _, weight := range wlist { + sum += weight + } + for i := range wlist { + wlist[i] /= sum + } + + // ウェイトの大きい順に指定個数までを対象とする + d.Indexes, d.Weights = sortIndexesByWeight(ilist, wlist) + } + + // ウェイト正規化 + sum := 0.0 + for _, weight := range d.Weights { + sum += weight + } + for i := range d.Weights { + d.Weights[i] /= sum + } +} + +// NormalizedDeform 4つのボーンINDEXとウェイトを返す（合計8個） +func (d *Deform) NormalizedDeform() [8]float32 { + normalizedDeform := [8]float32{0, 0, 0, 0, 0, 0, 0, 0} + for i, index := range d.Indexes { + normalizedDeform[i] = float32(index) + } + for i, weight := range d.Weights { + normalizedDeform[i+4] = float32(weight) + } + + return normalizedDeform +} + +// SDEF用パラメーターを返す +func (d *Deform) GetSdefParams() (mgl32.Vec3, mgl32.Vec3, mgl32.Vec3) { + return mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 0, 0} +} + +// sortIndexesByWeight ウェイトの大きい順に指定個数までを対象とする +func sortIndexesByWeight(indexes []int, weights []float64) ([]int, []float64) { + sort.SliceStable(weights, func(i, j int) bool { + return weights[i] > weights[j] + }) + + sortedIndexes := make([]int, len(indexes)) + sortedWeights := make([]float64, len(weights)) + + for i, weight := range weights { + for j, w := range weights { + if weight == w { + sortedIndexes[i] = indexes[j] + sortedWeights[i] = w + break + } + } + } + + return sortedIndexes, sortedWeights +} + +// Bdef1 represents the BDEF1 deformation. +type Bdef1 struct { + Deform +} + +// NewBdef1 creates a new Bdef1 instance. +func NewBdef1(index0 int) *Bdef1 { + return &Bdef1{ + Deform: Deform{ + Indexes: []int{index0}, + Weights: []float64{1.0}, + Count: 1, + }, + } +} + +// GetType returns the deformation type. +func (b *Bdef1) GetType() DeformType { + return BDEF1 +} + +// NormalizedDeform 4つのボーンINDEXとウェイトを返す（合計8個） +func (d *Bdef1) NormalizedDeform() [8]float32 { + return [8]float32{float32(d.Indexes[0]), 0, 0, 0, 1.0, 0, 0, 0} +} + +// Bdef2 represents the BDEF2 deformation. +type Bdef2 struct { + Deform +} + +// NewBdef2 creates a new Bdef2 instance. +func NewBdef2(index0, index1 int, weight0 float64) *Bdef2 { + return &Bdef2{ + Deform: Deform{ + Indexes: []int{index0, index1}, + Weights: []float64{weight0, 1 - weight0}, + Count: 2, + }, + } +} + +// GetType returns the deformation type. +func (b *Bdef2) GetType() DeformType { + return BDEF2 +} + +// NormalizedDeform 4つのボーンINDEXとウェイトを返す（合計8個） +func (d *Bdef2) NormalizedDeform() [8]float32 { + return [8]float32{ + float32(d.Indexes[0]), float32(d.Indexes[1]), 0, 0, + float32(d.Weights[0]), float32(1 - d.Weights[0]), 0, 0} +} + +// Bdef4 represents the BDEF4 deformation. +type Bdef4 struct { + Deform +} + +// NewBdef4 creates a new Bdef4 instance. +func NewBdef4(index0, index1, index2, index3 int, weight0, weight1, weight2, weight3 float64) *Bdef4 { + return &Bdef4{ + Deform: Deform{ + Indexes: []int{index0, index1, index2, index3}, + Weights: []float64{weight0, weight1, weight2, weight3}, + Count: 4, + }, + } +} + +// GetType returns the deformation type. +func (b *Bdef4) GetType() DeformType { + return BDEF4 +} + +// NormalizedDeform 4つのボーンINDEXとウェイトを返す（合計8個） +func (d *Bdef4) NormalizedDeform() [8]float32 { + return [8]float32{ + float32(d.Indexes[0]), float32(d.Indexes[1]), float32(d.Indexes[2]), float32(d.Indexes[3]), + float32(d.Weights[0]), float32(d.Weights[1]), float32(d.Weights[2]), float32(d.Weights[3])} +} + +// Sdef represents the SDEF deformation. +type Sdef struct { + Deform + SdefC *mmath.MVec3 + SdefR0 *mmath.MVec3 + SdefR1 *mmath.MVec3 +} + +// NewSdef creates a new Sdef instance. +func NewSdef(index0, index1 int, weight0 float64, sdefC, sdefR0, sdefR1 *mmath.MVec3) *Sdef { + return &Sdef{ + Deform: Deform{ + Indexes: []int{index0, index1}, + Weights: []float64{weight0, 1 - weight0}, + Count: 2, + }, + SdefC: sdefC, + SdefR0: sdefR0, + SdefR1: sdefR1, + } +} + +// GetType returns the deformation type. +func (s *Sdef) GetType() DeformType { + return SDEF +} + +// NormalizedDeform 4つのボーンINDEXとウェイトを返す（合計8個） +func (d *Sdef) NormalizedDeform() [8]float32 { + return [8]float32{ + float32(d.Indexes[0]), float32(d.Indexes[1]), 0, 0, + float32(d.Weights[0]), float32(1 - d.Weights[0]), 0, 0} +} diff --git a/pkg/pmx/deform_gui.go b/pkg/pmx/deform_gui.go new file mode 100644 index 00000000..9d15c2b3 --- /dev/null +++ b/pkg/pmx/deform_gui.go @@ -0,0 +1,21 @@ +//go:build windows +// +build windows + +package pmx + +import "github.com/go-gl/mathgl/mgl32" + +// SDEF用パラメーターを返す +func (s *Sdef) GetSdefParams() (mgl32.Vec3, mgl32.Vec3, mgl32.Vec3) { + // CがR0とR1より先にいかないよう、重みに基づいて補正 + copiedSdefR0 := s.SdefR0.Copy() + copiedSdefR1 := s.SdefR1.Copy() + copiedSdefCR0 := s.SdefC.Copy() + copiedSdefCR1 := s.SdefC.Copy() + + weight := copiedSdefR0.MulScalar(s.Weights[0]).Add(copiedSdefR1.MulScalar(1 - s.Weights[0])) + sdefR0 := copiedSdefCR0.Add(s.SdefR0).Sub(weight) + sdefR1 := copiedSdefCR1.Add(s.SdefR1).Sub(weight) + + return s.SdefC.GL(), sdefR0.GL(), sdefR1.GL() +} diff --git a/pkg/pmx/display_slot.go b/pkg/pmx/display_slot.go new file mode 100644 index 00000000..ce433b73 --- /dev/null +++ b/pkg/pmx/display_slot.go @@ -0,0 +1,70 @@ +package pmx + +import ( + "github.com/jinzhu/copier" + + "github.com/miu200521358/mlib_go/pkg/mcore" +) + +// 表示枠要素タイプ +type DisplayType int + +const ( + DISPLAY_TYPE_BONE DisplayType = 0 // ボーン + DISPLAY_TYPE_MORPH DisplayType = 1 // モーフ +) + +type Reference struct { + DisplayType DisplayType // 要素対象 0:ボーン 1:モーフ + DisplayIndex int // ボーンIndex or モーフIndex +} + +func NewDisplaySlotReference() *Reference { + return &Reference{ + DisplayType: 0, + DisplayIndex: -1, + } +} + +// 特殊枠フラグ - 0:通常枠 1:特殊枠 +type SpecialFlag int + +const ( + SPECIAL_FLAG_OFF SpecialFlag = 0 // 通常枠 + SPECIAL_FLAG_ON SpecialFlag = 1 // 特殊枠（Rootと表情） +) + +type DisplaySlot struct { + *mcore.IndexNameModel + SpecialFlag SpecialFlag // 特殊枠フラグ - 0:通常枠 1:特殊枠 + References []Reference // 表示枠要素 + IsSystem bool // ツール側で追加した表示枠 +} + +// NewDisplaySlot +func NewDisplaySlot() *DisplaySlot { + return &DisplaySlot{ + IndexNameModel: &mcore.IndexNameModel{Index: -1, Name: "", EnglishName: ""}, + SpecialFlag: SPECIAL_FLAG_OFF, + References: make([]Reference, 0), + IsSystem: false, + } +} + +// Copy +func (v *DisplaySlot) Copy() mcore.IIndexModel { + copied := NewDisplaySlot() + copier.CopyWithOption(copied, v, copier.Option{DeepCopy: true}) + return copied +} + +// 表示枠リスト +type DisplaySlots struct { + *mcore.IndexModels[*DisplaySlot] +} + +func NewDisplaySlots(count int) *DisplaySlots { + return &DisplaySlots{ + IndexModels: mcore.NewIndexModels[*DisplaySlot](count, func() *DisplaySlot { return nil }), + } +} diff --git a/pkg/pmx/face.go b/pkg/pmx/face.go new file mode 100644 index 00000000..8c2a09f4 --- /dev/null +++ b/pkg/pmx/face.go @@ -0,0 +1,40 @@ +package pmx + +import ( + "github.com/jinzhu/copier" + "github.com/miu200521358/mlib_go/pkg/mcore" +) + +// 面データ +type Face struct { + *mcore.IndexModel + VertexIndexes [3]int // 頂点INDEXリスト +} + +type FaceGL struct { + VertexIndexes [3]uint32 +} + +func NewFace() *Face { + return &Face{ + IndexModel: &mcore.IndexModel{Index: -1}, + VertexIndexes: [3]int{0, 0, 0}, + } +} + +func (f *Face) Copy() mcore.IIndexModel { + copied := NewFace() + copier.CopyWithOption(copied, f, copier.Option{DeepCopy: true}) + return copied +} + +// 面リスト +type Faces struct { + *mcore.IndexModels[*Face] +} + +func NewFaces(count int) *Faces { + return &Faces{ + IndexModels: mcore.NewIndexModels[*Face](count, func() *Face { return nil }), + } +} diff --git a/pkg/pmx/joint.go b/pkg/pmx/joint.go new file mode 100644 index 00000000..0e2d13b7 --- /dev/null +++ b/pkg/pmx/joint.go @@ -0,0 +1,76 @@ +package pmx + +import ( + "github.com/jinzhu/copier" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +type JointParam struct { + TranslationLimitMin *mmath.MVec3 // 移動制限-下限(x,y,z) + TranslationLimitMax *mmath.MVec3 // 移動制限-上限(x,y,z) + RotationLimitMin *mmath.MRotation // 回転制限-下限 + RotationLimitMax *mmath.MRotation // 回転制限-上限 + SpringConstantTranslation *mmath.MVec3 // バネ定数-移動(x,y,z) + SpringConstantRotation *mmath.MRotation // バネ定数-回転(x,y,z) +} + +func NewJointParam() *JointParam { + return &JointParam{ + TranslationLimitMin: mmath.NewMVec3(), + TranslationLimitMax: mmath.NewMVec3(), + RotationLimitMin: mmath.NewRotation(), + RotationLimitMax: mmath.NewRotation(), + SpringConstantTranslation: mmath.NewMVec3(), + SpringConstantRotation: mmath.NewRotation(), + } +} + +type Joint struct { + *mcore.IndexNameModel + JointType byte // Joint種類 - 0:スプリング6DOF | PMX2.0では 0 のみ(拡張用) + RigidbodyIndexA int // 関連剛体AのIndex + RigidbodyIndexB int // 関連剛体BのIndex + Position *mmath.MVec3 // 位置(x,y,z) + Rotation *mmath.MRotation // 回転 + JointParam *JointParam // ジョイントパラメーター + IsSystem bool +} + +func NewJoint() *Joint { + return &Joint{ + IndexNameModel: &mcore.IndexNameModel{Index: -1, Name: "", EnglishName: ""}, + // Joint種類 - 0:スプリング6DOF | PMX2.0では 0 のみ(拡張用) + JointType: 0, + RigidbodyIndexA: -1, + RigidbodyIndexB: -1, + Position: mmath.NewMVec3(), + Rotation: mmath.NewRotation(), + JointParam: NewJointParam(), + IsSystem: false, + } +} + +func (j *Joint) Copy() mcore.IIndexNameModel { + copied := NewJoint() + copier.CopyWithOption(copied, j, copier.Option{DeepCopy: true}) + return copied +} + +func NewJointByName(name string) *Joint { + j := NewJoint() + j.Name = name + return j +} + +// ジョイントリスト +type Joints struct { + *mcore.IndexNameModels[*Joint] +} + +func NewJoints(count int) *Joints { + return &Joints{ + IndexNameModels: mcore.NewIndexNameModels[*Joint](count, func() *Joint { return nil }), + } +} diff --git a/pkg/pmx/joint_gui.go b/pkg/pmx/joint_gui.go new file mode 100644 index 00000000..db0543b9 --- /dev/null +++ b/pkg/pmx/joint_gui.go @@ -0,0 +1,97 @@ +//go:build windows +// +build windows + +package pmx + +import ( + "github.com/miu200521358/mlib_go/pkg/mphysics" + "github.com/miu200521358/mlib_go/pkg/mphysics/mbt" +) + +func (j *Joint) initPhysics( + modelIndex int, modelPhysics *mphysics.MPhysics, rigidBodyA *RigidBody, rigidBodyB *RigidBody, +) { + // ジョイントの位置と向き + jointTransform := mbt.NewBtTransform(j.Rotation.Bullet(), j.Position.Bullet()) + + btRigidBodyA, _ := modelPhysics.GetRigidBody(modelIndex, rigidBodyA.Index) + btRigidBodyB, _ := modelPhysics.GetRigidBody(modelIndex, rigidBodyB.Index) + if btRigidBodyA == nil || btRigidBodyB == nil { + return + } + + // 剛体Aの現在の位置と向きを取得 + worldTransformA := btRigidBodyA.GetWorldTransform().(mbt.BtTransform) + + // 剛体Aのローカル座標系におけるジョイント + jointLocalTransformA := mbt.NewBtTransform() + jointLocalTransformA.SetIdentity() + jointLocalTransformA.Mult(worldTransformA.Inverse(), jointTransform) + + // 剛体Bの現在の位置と向きを取得 + worldTransformB := btRigidBodyB.GetWorldTransform().(mbt.BtTransform) + + // 剛体Bのローカル座標系におけるジョイント + jointLocalTransformB := mbt.NewBtTransform() + jointLocalTransformB.SetIdentity() + jointLocalTransformB.Mult(worldTransformB.Inverse(), jointTransform) + + // ジョイント係数 + constraint := mbt.NewBtGeneric6DofSpringConstraint( + btRigidBodyA, btRigidBodyB, jointLocalTransformA, jointLocalTransformB, true) + // 係数は符号を調整する必要がないため、そのまま設定 + constraint.SetLinearLowerLimit(mbt.NewBtVector3( + float32(j.JointParam.TranslationLimitMin.GetX()), + float32(j.JointParam.TranslationLimitMin.GetY()), + float32(j.JointParam.TranslationLimitMin.GetZ()))) + constraint.SetLinearUpperLimit(mbt.NewBtVector3( + float32(j.JointParam.TranslationLimitMax.GetX()), + float32(j.JointParam.TranslationLimitMax.GetY()), + float32(j.JointParam.TranslationLimitMax.GetZ()))) + constraint.SetAngularLowerLimit(mbt.NewBtVector3( + float32(j.JointParam.RotationLimitMin.GetRadians().GetX()), + float32(j.JointParam.RotationLimitMin.GetRadians().GetY()), + float32(j.JointParam.RotationLimitMin.GetRadians().GetZ()))) + constraint.SetAngularUpperLimit(mbt.NewBtVector3( + float32(j.JointParam.RotationLimitMax.GetRadians().GetX()), + float32(j.JointParam.RotationLimitMax.GetRadians().GetY()), + float32(j.JointParam.RotationLimitMax.GetRadians().GetZ()))) + + if rigidBodyB.PhysicsType != PHYSICS_TYPE_STATIC { + // 剛体Bがボーン追従剛体の場合は、バネの値を設定しない + constraint.EnableSpring(0, true) + constraint.SetStiffness(0, float32(j.JointParam.SpringConstantTranslation.GetX())) + constraint.EnableSpring(1, true) + constraint.SetStiffness(1, float32(j.JointParam.SpringConstantTranslation.GetY())) + constraint.EnableSpring(2, true) + constraint.SetStiffness(2, float32(j.JointParam.SpringConstantTranslation.GetZ())) + constraint.EnableSpring(3, true) + constraint.SetStiffness(3, float32(j.JointParam.SpringConstantRotation.GetRadians().GetX())) + constraint.EnableSpring(4, true) + constraint.SetStiffness(4, float32(j.JointParam.SpringConstantRotation.GetRadians().GetY())) + constraint.EnableSpring(5, true) + constraint.SetStiffness(5, float32(j.JointParam.SpringConstantRotation.GetRadians().GetZ())) + } + + constraint.SetParam(int(mbt.BT_CONSTRAINT_ERP), float32(0.5), 0) + constraint.SetParam(int(mbt.BT_CONSTRAINT_STOP_ERP), float32(0.5), 0) + constraint.SetParam(int(mbt.BT_CONSTRAINT_CFM), float32(0.1), 0) + constraint.SetParam(int(mbt.BT_CONSTRAINT_STOP_CFM), float32(0.1), 0) + + // デバッグ円の表示サイズ + constraint.SetDbgDrawSize(float32(1.5)) + + modelPhysics.AddJoint(modelIndex, j.Index, constraint) +} + +func (j *Joints) initPhysics(modelIndex int, modelPhysics *mphysics.MPhysics, rigidBodies *RigidBodies) { + // ジョイントを順番に剛体と紐付けていく + for _, joint := range j.Data { + if joint.RigidbodyIndexA >= 0 && rigidBodies.Contains(joint.RigidbodyIndexA) && + joint.RigidbodyIndexB >= 0 && rigidBodies.Contains(joint.RigidbodyIndexB) { + joint.initPhysics( + modelIndex, modelPhysics, rigidBodies.Get(joint.RigidbodyIndexA), + rigidBodies.Get(joint.RigidbodyIndexB)) + } + } +} diff --git a/pkg/pmx/material.go b/pkg/pmx/material.go new file mode 100644 index 00000000..a7fdd37f --- /dev/null +++ b/pkg/pmx/material.go @@ -0,0 +1,202 @@ +package pmx + +import ( + "slices" + + "github.com/jinzhu/copier" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +// スフィアモード +type SphereMode byte + +const ( + // 無効 + SPHERE_MODE_INVALID SphereMode = 0 + // 乗算(sph) + SPHERE_MODE_MULTIPLICATION SphereMode = 1 + // 加算(spa) + SPHERE_MODE_ADDITION SphereMode = 2 + // サブテクスチャ(追加UV1のx,yをUV参照して通常テクスチャ描画を行う) + SPHERE_MODE_SUBTEXTURE SphereMode = 3 +) + +type DrawFlag byte + +const ( + // 初期値 + DRAW_FLAG_NONE DrawFlag = 0x0000 + // 0x01:両面描画 + DRAW_FLAG_DOUBLE_SIDED_DRAWING DrawFlag = 0x0001 + // 0x02:地面影 + DRAW_FLAG_GROUND_SHADOW DrawFlag = 0x0002 + // 0x04:セルフシャドウマップへの描画 + DRAW_FLAG_DRAWING_ON_SELF_SHADOW_MAPS DrawFlag = 0x0004 + // 0x08:セルフシャドウの描画 + DRAW_FLAG_DRAWING_SELF_SHADOWS DrawFlag = 0x0008 + // 0x10:エッジ描画 + DRAW_FLAG_DRAWING_EDGE DrawFlag = 0x0010 +) + +// 0x01:両面描画 +func (d DrawFlag) IsDoubleSidedDrawing() bool { + return d&DRAW_FLAG_DOUBLE_SIDED_DRAWING == DRAW_FLAG_DOUBLE_SIDED_DRAWING +} + +// 0x02:地面影 +func (d DrawFlag) IsGroundShadow() bool { + return d&DRAW_FLAG_GROUND_SHADOW == DRAW_FLAG_GROUND_SHADOW +} + +// 0x04:セルフシャドウマップへの描画 +func (d DrawFlag) IsDrawingOnSelfShadowMaps() bool { + return d&DRAW_FLAG_DRAWING_ON_SELF_SHADOW_MAPS == DRAW_FLAG_DRAWING_ON_SELF_SHADOW_MAPS +} + +// 0x08:セルフシャドウの描画 +func (d DrawFlag) IsDrawingSelfShadows() bool { + return d&DRAW_FLAG_DRAWING_SELF_SHADOWS == DRAW_FLAG_DRAWING_SELF_SHADOWS +} + +// 0x10:エッジ描画 +func (d DrawFlag) IsDrawingEdge() bool { + return d&DRAW_FLAG_DRAWING_EDGE == DRAW_FLAG_DRAWING_EDGE +} + +func (d DrawFlag) SetDrawingEdge(flag bool) DrawFlag { + if flag { + return d | DRAW_FLAG_DRAWING_EDGE + } + return d &^ DRAW_FLAG_DRAWING_EDGE +} + +func (d DrawFlag) SetDoubleSidedDrawing(flag bool) DrawFlag { + if flag { + return d | DRAW_FLAG_DOUBLE_SIDED_DRAWING + } + return d &^ DRAW_FLAG_DOUBLE_SIDED_DRAWING +} + +func (d DrawFlag) SetGroundShadow(flag bool) DrawFlag { + if flag { + return d | DRAW_FLAG_GROUND_SHADOW + } + return d &^ DRAW_FLAG_GROUND_SHADOW +} + +func (d DrawFlag) SetDrawingOnSelfShadowMaps(flag bool) DrawFlag { + if flag { + return d | DRAW_FLAG_DRAWING_ON_SELF_SHADOW_MAPS + } + return d &^ DRAW_FLAG_DRAWING_ON_SELF_SHADOW_MAPS +} + +func (d DrawFlag) SetDrawingSelfShadows(flag bool) DrawFlag { + if flag { + return d | DRAW_FLAG_DRAWING_SELF_SHADOWS + } + return d &^ DRAW_FLAG_DRAWING_SELF_SHADOWS +} + +// 共有Toonフラグ +type ToonSharing byte + +const ( + // 0:継続値は個別Toon + TOON_SHARING_INDIVIDUAL ToonSharing = 0 + // 1:継続値は共有Toon + TOON_SHARING_SHARING ToonSharing = 1 +) + +type Material struct { + *mcore.IndexNameModel + Diffuse *mmath.MVec4 // Diffuse (R,G,B,A)(拡散色＋非透過度) + Specular *mmath.MVec4 // Specular (R,G,B,A)(反射色 + 反射強度) + Ambient *mmath.MVec3 // Ambient (R,G,B)(環境色) + DrawFlag DrawFlag // 描画フラグ(8bit) - 各bit 0:OFF 1:ON + Edge *mmath.MVec4 // エッジ色 (R,G,B,A) + EdgeSize float64 // エッジサイズ + TextureIndex int // 通常テクスチャINDEX + SphereTextureIndex int // スフィアテクスチャINDEX + SphereMode SphereMode // スフィアモード + ToonSharingFlag ToonSharing // 共有Toonフラグ + ToonTextureIndex int // ToonテクスチャINDEX + Memo string // メモ + VerticesCount int // 材質に対応する面(頂点)数 (必ず3の倍数になる) + TextureFactor *mmath.MVec4 // テクスチャ係数 + SphereTextureFactor *mmath.MVec4 // スフィアテクスチャ係数 + ToonTextureFactor *mmath.MVec4 // トゥーンテクスチャ係数 +} + +func NewMaterial() *Material { + return &Material{ + IndexNameModel: &mcore.IndexNameModel{Index: -1, Name: "", EnglishName: ""}, + Diffuse: mmath.NewMVec4(), + Specular: mmath.NewMVec4(), + Ambient: mmath.NewMVec3(), + DrawFlag: DRAW_FLAG_NONE, + Edge: mmath.NewMVec4(), + EdgeSize: 0.0, + TextureIndex: -1, + SphereTextureIndex: -1, + SphereMode: SPHERE_MODE_INVALID, + ToonSharingFlag: TOON_SHARING_INDIVIDUAL, + ToonTextureIndex: -1, + Memo: "", + VerticesCount: 0, + TextureFactor: mmath.NewMVec4(), + SphereTextureFactor: mmath.NewMVec4(), + ToonTextureFactor: mmath.NewMVec4(), + } +} + +func NewMaterialByName(name string) *Material { + m := NewMaterial() + m.Name = name + return m +} + +// 材質リスト +type Materials struct { + *mcore.IndexNameModels[*Material] + Vertices map[int][]int + Faces map[int][]int +} + +func NewMaterials(count int) *Materials { + return &Materials{ + IndexNameModels: mcore.NewIndexNameModels[*Material](count, func() *Material { return nil }), + Vertices: make(map[int][]int), + Faces: make(map[int][]int), + } +} + +func (m *Material) Copy() mcore.IIndexNameModel { + copied := NewMaterial() + copier.CopyWithOption(copied, m, copier.Option{DeepCopy: true}) + return copied +} + +func (ms *Materials) setup(vertices *Vertices, faces *Faces) { + prevVertexCount := 0 + + for _, v := range vertices.Data { + v.MaterialIndexes = make([]int, 0) + } + + for _, m := range ms.Data { + for j := prevVertexCount; j < prevVertexCount+int(m.VerticesCount/3); j++ { + face := faces.Get(j) + for _, vertexIndexes := range face.VertexIndexes { + if !slices.Contains(vertices.Get(vertexIndexes).MaterialIndexes, m.Index) { + vertices.Get(vertexIndexes).MaterialIndexes = + append(vertices.Get(vertexIndexes).MaterialIndexes, m.Index) + } + } + } + + prevVertexCount += int(m.VerticesCount / 3) + } +} diff --git a/pkg/pmx/material_gui.go b/pkg/pmx/material_gui.go new file mode 100644 index 00000000..e508b7e9 --- /dev/null +++ b/pkg/pmx/material_gui.go @@ -0,0 +1,44 @@ +//go:build windows +// +build windows + +package pmx + +type MaterialGL struct { + *Material + Texture *TextureGL // 通常テクスチャ + SphereTexture *TextureGL // スフィアテクスチャ + ToonTexture *TextureGL // トゥーンテクスチャ + PrevVerticesCount int // 前の材質までの頂点数 +} + +func (m *Material) GL( + modelPath string, + texture *Texture, + toonTexture *Texture, + sphereTexture *Texture, + windowIndex int, + prevVerticesCount int, +) *MaterialGL { + var textureGL *TextureGL + if texture != nil { + textureGL = texture.GL(modelPath, TEXTURE_TYPE_TEXTURE, windowIndex) + } + + var sphereTextureGL *TextureGL + if sphereTexture != nil { + sphereTextureGL = sphereTexture.GL(modelPath, TEXTURE_TYPE_SPHERE, windowIndex) + } + + var tooTextureGL *TextureGL + if toonTexture != nil { + tooTextureGL = toonTexture.GL(modelPath, TEXTURE_TYPE_TOON, windowIndex) + } + + return &MaterialGL{ + Material: m, + Texture: textureGL, + SphereTexture: sphereTextureGL, + ToonTexture: tooTextureGL, + PrevVerticesCount: prevVerticesCount * 4, + } +} diff --git a/pkg/pmx/mesh.go b/pkg/pmx/mesh.go new file mode 100644 index 00000000..3287263d --- /dev/null +++ b/pkg/pmx/mesh.go @@ -0,0 +1,304 @@ +//go:build windows +// +build windows + +package pmx + +import ( + "unsafe" + + "github.com/go-gl/gl/v4.4-core/gl" + "github.com/go-gl/mathgl/mgl32" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mview" +) + +type Mesh struct { + material MaterialGL // 描画用材質 + prevVerticesCount int // 前の頂点数 + ibo *mview.IBO // 頂点インデックスバッファ +} + +type MeshDelta struct { + Diffuse mgl32.Vec4 + Specular mgl32.Vec4 + Ambient mgl32.Vec3 + Edge mgl32.Vec4 + EdgeSize float32 + TextureMulFactor mgl32.Vec4 + TextureAddFactor mgl32.Vec4 + SphereMulFactor mgl32.Vec4 + SphereAddFactor mgl32.Vec4 + ToonMulFactor mgl32.Vec4 + ToonAddFactor mgl32.Vec4 +} + +func NewMesh( + allFaces []uint32, + material *MaterialGL, + prevVerticesCount int, +) *Mesh { + faces := allFaces[prevVerticesCount:(prevVerticesCount + material.VerticesCount)] + // println( + // "faces", + // mutils.JoinSlice(mutils.ConvertUint32ToInterfaceSlice(faces)), + // "prevVerticesCount", + // prevVerticesCount, + // "material.VerticesCount", + // material.VerticesCount, + // ) + + ibo := mview.NewIBO(gl.Ptr(faces), len(faces)) + + return &Mesh{ + material: *material, + prevVerticesCount: prevVerticesCount, + ibo: ibo, + } +} + +func (m *Mesh) drawModel( + shader *mview.MShader, + windowIndex int, + paddedMatrixes []float32, + width, height int, + meshDelta *MeshDelta, +) { + if m.material.DrawFlag.IsDoubleSidedDrawing() { + // 両面描画 + // カリングOFF + gl.Disable(gl.CULL_FACE) + } else { + // 片面描画 + // カリングON + gl.Enable(gl.CULL_FACE) + defer gl.Disable(gl.CULL_FACE) + + gl.CullFace(gl.BACK) + } + + // ボーンデフォームテクスチャ設定 + bindBoneMatrixes(paddedMatrixes, width, height, shader, shader.ModelProgram) + defer UnbindBoneMatrixes() + + // ------------------ + // 材質色設定 + // full.fx の AmbientColor相当 + diffuseUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_DIFFUSE)) + gl.Uniform4fv(diffuseUniform, 1, &meshDelta.Diffuse[0]) + + ambientUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_AMBIENT)) + gl.Uniform3fv(ambientUniform, 1, &meshDelta.Ambient[0]) + + specularUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_SPECULAR)) + gl.Uniform4fv(specularUniform, 1, &meshDelta.Specular[0]) + + // テクスチャ使用有無 + useTextureUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_USE_TEXTURE)) + gl.Uniform1i(useTextureUniform, int32(mmath.BoolToInt(m.material.Texture != nil))) + if m.material.Texture != nil { + m.material.Texture.Bind() + defer m.material.Texture.Unbind() + textureUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_TEXTURE_SAMPLER)) + gl.Uniform1i(textureUniform, int32(m.material.Texture.TextureUnitNo)) + + textureMulFactorUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_TEXTURE_MUL_FACTOR)) + gl.Uniform4fv(textureMulFactorUniform, 1, &meshDelta.TextureMulFactor[0]) + + textureAddFactorUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_TEXTURE_ADD_FACTOR)) + gl.Uniform4fv(textureAddFactorUniform, 1, &meshDelta.TextureAddFactor[0]) + } + + // Toon使用有無 + useToonUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_USE_TOON)) + gl.Uniform1i(useToonUniform, int32(mmath.BoolToInt(m.material.ToonTexture != nil))) + if m.material.ToonTexture != nil { + m.material.ToonTexture.Bind() + defer m.material.ToonTexture.Unbind() + toonUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_TOON_SAMPLER)) + gl.Uniform1i(toonUniform, int32(m.material.ToonTexture.TextureUnitNo)) + + toonMulFactorUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_TOON_MUL_FACTOR)) + gl.Uniform4fv(toonMulFactorUniform, 1, &meshDelta.ToonMulFactor[0]) + + toonAddFactorUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_TOON_ADD_FACTOR)) + gl.Uniform4fv(toonAddFactorUniform, 1, &meshDelta.ToonAddFactor[0]) + } + + // Sphere使用有無 + useSphereUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_USE_SPHERE)) + gl.Uniform1i(useSphereUniform, int32(mmath.BoolToInt(m.material.SphereTexture != nil && m.material.SphereTexture.Valid))) + if m.material.SphereTexture != nil && m.material.SphereTexture.Valid { + m.material.SphereTexture.Bind() + defer m.material.SphereTexture.Unbind() + sphereUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_SPHERE_SAMPLER)) + gl.Uniform1i(sphereUniform, int32(m.material.SphereTexture.TextureUnitNo)) + + sphereMulFactorUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_SPHERE_MUL_FACTOR)) + gl.Uniform4fv(sphereMulFactorUniform, 1, &meshDelta.SphereMulFactor[0]) + + sphereAddFactorUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_SPHERE_ADD_FACTOR)) + gl.Uniform4fv(sphereAddFactorUniform, 1, &meshDelta.SphereAddFactor[0]) + } + + // SphereMode + sphereModeUniform := gl.GetUniformLocation(shader.ModelProgram, gl.Str(mview.SHADER_SPHERE_MODE)) + gl.Uniform1i(sphereModeUniform, int32(m.material.SphereMode)) + + // // ウェイト描写 + // gl.Uniform1i( + // shader.IsShowBoneWeightUniform[mview.PROGRAM_TYPE_MODEL], + // mutils.BoolToInt(isShowBoneWeight), + // ) + // gl.Uniform1iv( + // shader.ShowBoneIndexesUniform[mview.PROGRAM_TYPE_MODEL], + // int32(len(showBoneIndexes)), + // (*int32)(unsafe.Pointer(&showBoneIndexes[0])), + // ) + + // prevVerticesSize := m.prevVerticesCount * int(ibo.Dtype) + + // if err := CheckGLError(); err != nil { + // panic(fmt.Errorf("Mesh DrawElements failed: %v", err)) + // } + + // gl.DrawElements( + // gl.TRIANGLES, + // int32(m.material.VerticesCount), + // ibo.Dtype, + // unsafe.Pointer(&prevVerticesCount), + // ) + + // 三角形描画 + gl.DrawElements( + gl.TRIANGLES, + int32(m.material.VerticesCount), + gl.UNSIGNED_INT, + nil, + ) +} + +func (m *Mesh) drawEdge( + shader *mview.MShader, + windowIndex int, + paddedMatrixes []float32, + width, height int, + meshDelta *MeshDelta, +) { + gl.Enable(gl.CULL_FACE) + defer gl.Disable(gl.CULL_FACE) + + gl.CullFace(gl.FRONT) + + // ボーンデフォームテクスチャ設定 + bindBoneMatrixes(paddedMatrixes, width, height, shader, shader.EdgeProgram) + defer UnbindBoneMatrixes() + + // ------------------ + // エッジ色設定 + edgeColorUniform := gl.GetUniformLocation(shader.EdgeProgram, gl.Str(mview.SHADER_EDGE_COLOR)) + gl.Uniform4fv(edgeColorUniform, 1, &meshDelta.Edge[0]) + + // エッジサイズ + edgeSizeUniform := gl.GetUniformLocation(shader.EdgeProgram, gl.Str(mview.SHADER_EDGE_SIZE)) + gl.Uniform1f(edgeSizeUniform, meshDelta.EdgeSize) + + // 三角形描画 + gl.DrawElements( + gl.TRIANGLES, + int32(m.material.VerticesCount), + gl.UNSIGNED_INT, + nil, + ) +} + +func (m *Mesh) drawWire( + shader *mview.MShader, + windowIndex int, + paddedMatrixes []float32, + width, height int, + invisibleMesh bool, +) { + // カリングOFF + gl.Disable(gl.CULL_FACE) + + // ボーンデフォームテクスチャ設定 + bindBoneMatrixes(paddedMatrixes, width, height, shader, shader.WireProgram) + defer UnbindBoneMatrixes() + + var wireColor mgl32.Vec4 + if invisibleMesh { + wireColor = mgl32.Vec4{0.0, 0.0, 0.0, 0.0} + } else { + wireColor = mgl32.Vec4{0.2, 0.6, 0.2, 0.5} + } + specularUniform := gl.GetUniformLocation(shader.WireProgram, gl.Str(mview.SHADER_COLOR)) + gl.Uniform4fv(specularUniform, 1, &wireColor[0]) + + // 描画モードをワイヤーフレームに変更 + gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE) + + // 三角形描画 + gl.DrawElements( + gl.TRIANGLES, + int32(m.material.VerticesCount), + gl.UNSIGNED_INT, + nil, + ) + + // 描画モードを元に戻す + gl.PolygonMode(gl.FRONT_AND_BACK, gl.FILL) +} + +func (m *Mesh) delete() { + m.ibo.Delete() + if m.material.Texture != nil { + m.material.Texture.delete() + } +} + +func bindBoneMatrixes( + paddedMatrixes []float32, + width, height int, + shader *mview.MShader, + program uint32, +) { + // テクスチャをアクティブにする + gl.ActiveTexture(gl.TEXTURE20) + + // テクスチャをバインドする + gl.BindTexture(gl.TEXTURE_2D, shader.BoneTextureId) + + // テクスチャのパラメーターの設定 + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAX_LEVEL, 0) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST) + + // テクスチャをシェーダーに渡す + gl.TexImage2D( + gl.TEXTURE_2D, + 0, + gl.RGBA32F, + int32(width), + int32(height), + 0, + gl.RGBA, + gl.FLOAT, + unsafe.Pointer(&paddedMatrixes[0]), + ) + + modelUniform := gl.GetUniformLocation(program, gl.Str(mview.SHADER_BONE_MATRIX_TEXTURE)) + gl.Uniform1i(modelUniform, 20) + + modelWidthUniform := gl.GetUniformLocation(program, gl.Str(mview.SHADER_BONE_MATRIX_TEXTURE_WIDTH)) + gl.Uniform1i(modelWidthUniform, int32(width)) + + modelHeightUniform := gl.GetUniformLocation(program, gl.Str(mview.SHADER_BONE_MATRIX_TEXTURE_HEIGHT)) + gl.Uniform1i(modelHeightUniform, int32(height)) +} + +func UnbindBoneMatrixes() { + gl.BindTexture(gl.TEXTURE_2D, 0) +} diff --git a/pkg/pmx/meshes.go b/pkg/pmx/meshes.go new file mode 100644 index 00000000..840280db --- /dev/null +++ b/pkg/pmx/meshes.go @@ -0,0 +1,8 @@ +//go:build linux +// +build linux + +package pmx + +type Meshes struct { + vertices []float32 +} diff --git a/pkg/pmx/meshes_gui.go b/pkg/pmx/meshes_gui.go new file mode 100644 index 00000000..f612465d --- /dev/null +++ b/pkg/pmx/meshes_gui.go @@ -0,0 +1,508 @@ +//go:build windows +// +build windows + +package pmx + +import ( + "math" + "slices" + "sync" + "unsafe" + + "github.com/go-gl/gl/v4.4-core/gl" + "github.com/go-gl/mathgl/mgl32" + + "github.com/miu200521358/mlib_go/pkg/mview" +) + +type Meshes struct { + meshes []*Mesh + vertices []float32 + vao *mview.VAO + vbo *mview.VBO + normals []float32 + normalVao *mview.VAO + normalVbo *mview.VBO + normalIbo *mview.IBO + selectedVertexVao *mview.VAO + selectedVertexVbo *mview.VBO + selectedVertexIbo *mview.IBO + bones []float32 + boneVao *mview.VAO + boneVbo *mview.VBO + boneIbo *mview.IBO + boneIndexes []int + ssbo uint32 + vertexCount int +} + +func NewMeshes( + model *PmxModel, + windowIndex int, +) *Meshes { + // 頂点情報 + vertices := make([]float32, 0, len(model.Vertices.Data)) + normalVertices := make([]float32, 0, len(model.Vertices.Data)*2) + normalFaces := make([]uint32, 0, len(model.Vertices.Data)*2) + selectedVertices := make([]float32, 0, len(model.Vertices.Data)) + selectedVertexFaces := make([]uint32, 0, len(model.Vertices.Data)) + + // WaitGroupを用いて並列処理を管理 + var wg sync.WaitGroup + var mu sync.Mutex + + // 頂点情報の並列処理 + wg.Add(1) + go func() { + defer wg.Done() + n := 0 + for i, vertex := range model.Vertices.Data { + vgl := vertex.GL() + + mu.Lock() + vertices = append(vertices, vgl...) + + // 法線 + normalVertices = append(normalVertices, vgl...) + normalVertices = append(normalVertices, vertex.NormalGL()...) + normalFaces = append(normalFaces, uint32(n), uint32(n+1)) + + // 選択頂点 + selectedVertices = append(selectedVertices, vertex.SelectedGL()...) + selectedVertexFaces = append(selectedVertexFaces, uint32(i)) + + mu.Unlock() + n += 2 + } + }() + + // 面情報の並列処理 + faces := make([]uint32, 0, len(model.Faces.Data)*3) + + wg.Add(1) + go func() { + defer wg.Done() + n := 0 + for _, face := range model.Faces.Data { + vertices := face.VertexIndexes + mu.Lock() + faces = append(faces, uint32(vertices[2]), uint32(vertices[1]), uint32(vertices[0])) + mu.Unlock() + + n += 3 + } + }() + + // メッシュ情報の並列処理 + meshes := make([]*Mesh, len(model.Materials.Data)) + prevVerticesCount := 0 + + // テクスチャの gl.GenTextures はスレッドセーフではないので、並列化しない + for i, m := range model.Materials.Data { + // テクスチャ + var texture *Texture + if m.TextureIndex != -1 && model.Textures.Contains(m.TextureIndex) { + texture = model.Textures.Get(m.TextureIndex) + } + + var toonTexture *Texture + // 個別Toon + if m.ToonSharingFlag == TOON_SHARING_INDIVIDUAL && + m.ToonTextureIndex != -1 && + model.Textures.Contains(m.ToonTextureIndex) { + toonTexture = model.Textures.Get(m.ToonTextureIndex) + } + // 共有Toon + if m.ToonSharingFlag == TOON_SHARING_SHARING && + m.ToonTextureIndex != -1 && + model.ToonTextures.Contains(m.ToonTextureIndex) { + toonTexture = model.ToonTextures.Get(m.ToonTextureIndex) + } + + var sphereTexture *Texture + if m.SphereMode != SPHERE_MODE_INVALID && + m.SphereTextureIndex != -1 && + model.Textures.Contains(m.SphereTextureIndex) { + sphereTexture = model.Textures.Get(m.SphereTextureIndex) + } + + materialGl := m.GL( + model.Path, + texture, + toonTexture, + sphereTexture, + windowIndex, + prevVerticesCount, + ) + mesh := NewMesh( + faces, + materialGl, + prevVerticesCount, + ) + mu.Lock() + meshes[i] = mesh + mu.Unlock() + + prevVerticesCount += m.VerticesCount + } + + // ボーン情報の並列処理 + bones := make([]float32, 0, len(model.Bones.Data)*4) + boneFaces := make([]uint32, 0, len(model.Bones.Data)*4) + boneIndexes := make([]int, 0, len(model.Bones.Data)*4) + + wg.Add(1) + go func() { + defer wg.Done() + n := 0 + for _, bone := range model.Bones.Data { + mu.Lock() + bones = append(bones, bone.GL()...) + bones = append(bones, bone.TailGL()...) + boneFaces = append(boneFaces, uint32(n), uint32(n+1)) + boneIndexes = append(boneIndexes, bone.Index, bone.Index) + mu.Unlock() + + n += 2 + + if bone.ParentIndex >= 0 && model.Bones.Contains(bone.ParentIndex) && + !model.Bones.Get(bone.ParentIndex).Position.IsZero() { + mu.Lock() + bones = append(bones, bone.GL()...) + bones = append(bones, bone.ParentGL()...) + boneFaces = append(boneFaces, uint32(n), uint32(n+1)) + boneIndexes = append(boneIndexes, bone.Index, bone.ParentIndex) + mu.Unlock() + + n += 2 + } + } + }() + + // WaitGroupの完了を待つ + wg.Wait() + + // 以下の部分は並列化する必要がないのでそのままにする + vao := mview.NewVAO() + vao.Bind() + + vbo := mview.NewVBOForVertex(gl.Ptr(vertices), len(vertices)) + vbo.BindVertex(nil, nil) + vbo.Unbind() + vao.Unbind() + + normalVao := mview.NewVAO() + normalVao.Bind() + normalVbo := mview.NewVBOForVertex(gl.Ptr(normalVertices), len(normalVertices)) + normalVbo.BindVertex(nil, nil) + normalIbo := mview.NewIBO(gl.Ptr(normalFaces), len(normalFaces)) + normalIbo.Bind() + normalIbo.Unbind() + normalVbo.Unbind() + normalVao.Unbind() + + boneVao := mview.NewVAO() + boneVao.Bind() + boneVbo := mview.NewVBOForVertex(gl.Ptr(bones), len(bones)) + boneVbo.BindVertex(nil, nil) + boneIbo := mview.NewIBO(gl.Ptr(boneFaces), len(boneFaces)) + boneIbo.Bind() + boneIbo.Unbind() + boneVbo.Unbind() + boneVao.Unbind() + + selectedVertexVao := mview.NewVAO() + selectedVertexVao.Bind() + selectedVertexVbo := mview.NewVBOForVertex(gl.Ptr(selectedVertices), len(selectedVertices)) + selectedVertexVbo.BindVertex(nil, nil) + selectedVertexIbo := mview.NewIBO(gl.Ptr(selectedVertexFaces), len(selectedVertexFaces)) + selectedVertexIbo.Bind() + selectedVertexIbo.Unbind() + selectedVertexVbo.Unbind() + selectedVertexVao.Unbind() + + // SSBOの作成 + var ssbo uint32 + gl.GenBuffers(1, &ssbo) + gl.BindBuffer(gl.SHADER_STORAGE_BUFFER, ssbo) + gl.BufferData(gl.SHADER_STORAGE_BUFFER, model.Vertices.Len()*4*4, nil, gl.DYNAMIC_DRAW) + gl.BindBufferBase(gl.SHADER_STORAGE_BUFFER, 0, ssbo) + + return &Meshes{ + meshes: meshes, + vertices: vertices, + vao: vao, + vbo: vbo, + normals: normalVertices, + normalVao: normalVao, + normalVbo: normalVbo, + normalIbo: normalIbo, + selectedVertexVao: selectedVertexVao, + selectedVertexVbo: selectedVertexVbo, + selectedVertexIbo: selectedVertexIbo, + bones: bones, + boneVao: boneVao, + boneVbo: boneVbo, + boneIbo: boneIbo, + boneIndexes: boneIndexes, + ssbo: ssbo, + vertexCount: model.Vertices.Len(), + } +} + +func (m *Meshes) delete() { + for _, mesh := range m.meshes { + mesh.delete() + } + m.vao.Delete() + m.vbo.Delete() +} + +func (m *Meshes) Draw( + shader *mview.MShader, boneDeltas []mgl32.Mat4, + vertexMorphIndexes []int, vertexMorphDeltas [][]float32, + selectedVertexIndexes []int, selectedVertexDeltas [][]float32, meshDeltas []*MeshDelta, + invisibleMaterialIndexes []int, nextInvisibleMaterialIndexes []int, windowIndex int, + isDrawNormal, isDrawWire, isDrawSelectedVertex bool, isDrawBones map[BoneFlag]bool, bones *Bones, +) [][]float32 { + m.vao.Bind() + defer m.vao.Unbind() + + m.vbo.BindVertex(vertexMorphIndexes, vertexMorphDeltas) + defer m.vbo.Unbind() + + paddedMatrixes, matrixWidth, matrixHeight := m.createBoneMatrixes(boneDeltas) + + for i, mesh := range m.meshes { + mesh.ibo.Bind() + + shader.Use(mview.PROGRAM_TYPE_MODEL) + mesh.drawModel(shader, windowIndex, paddedMatrixes, matrixWidth, matrixHeight, meshDeltas[i]) + shader.Unuse() + + if mesh.material.DrawFlag.IsDrawingEdge() { + // エッジ描画 + shader.Use(mview.PROGRAM_TYPE_EDGE) + mesh.drawEdge(shader, windowIndex, paddedMatrixes, matrixWidth, matrixHeight, meshDeltas[i]) + shader.Unuse() + } + + if isDrawWire { + shader.Use(mview.PROGRAM_TYPE_WIRE) + mesh.drawWire(shader, windowIndex, paddedMatrixes, matrixWidth, matrixHeight, ((len(invisibleMaterialIndexes) > 0 && len(nextInvisibleMaterialIndexes) == 0 && + slices.Contains(invisibleMaterialIndexes, mesh.material.Index)) || + slices.Contains(nextInvisibleMaterialIndexes, mesh.material.Index))) + shader.Unuse() + } + + mesh.ibo.Unbind() + } + + // if isDrawWire { + // m.drawWire(wireVertexDeltas, shader, paddedMatrixes, matrixWidth, matrixHeight, windowIndex) + // } + + vertexPositions := make([][]float32, 0) + if isDrawSelectedVertex { + vertexPositions = m.drawSelectedVertex(selectedVertexIndexes, selectedVertexDeltas, + shader, paddedMatrixes, matrixWidth, matrixHeight, windowIndex) + } + + if isDrawNormal { + m.drawNormal(shader, paddedMatrixes, matrixWidth, matrixHeight, windowIndex) + } + + isDrawBone := false + for _, drawBone := range isDrawBones { + if drawBone { + isDrawBone = true + break + } + } + + if isDrawBone { + m.drawBone(shader, bones, isDrawBones, paddedMatrixes, matrixWidth, matrixHeight, windowIndex) + } + + paddedMatrixes = nil + boneDeltas = nil + meshDeltas = nil + + return vertexPositions +} + +func (m *Meshes) createBoneMatrixes(matrixes []mgl32.Mat4) ([]float32, int, int) { + // テクスチャのサイズを計算する + numBones := len(matrixes) + texSize := int(math.Ceil(math.Sqrt(float64(numBones)))) + width := int(math.Ceil(float64(texSize)/4) * 4 * 4) + height := int(math.Ceil((float64(numBones) * 4) / float64(width))) + + paddedMatrixes := make([]float32, height*width*4) + for i, matrix := range matrixes { + copy(paddedMatrixes[i*16:], matrix[:]) + } + + return paddedMatrixes, width, height +} + +func (m *Meshes) drawNormal( + shader *mview.MShader, + paddedMatrixes []float32, + width, height int, + windowIndex int, +) { + shader.Use(mview.PROGRAM_TYPE_NORMAL) + + m.normalVao.Bind() + m.normalVbo.BindVertex(nil, nil) + m.normalIbo.Bind() + + // ボーンデフォームテクスチャ設定 + bindBoneMatrixes(paddedMatrixes, width, height, shader, shader.NormalProgram) + + normalColor := mgl32.Vec4{0.3, 0.3, 0.7, 0.5} + specularUniform := gl.GetUniformLocation(shader.NormalProgram, gl.Str(mview.SHADER_COLOR)) + gl.Uniform4fv(specularUniform, 1, &normalColor[0]) + + // ライン描画 + gl.DrawElements( + gl.LINES, + int32(len(m.normals)), + gl.UNSIGNED_INT, + nil, + ) + + m.normalIbo.Unbind() + m.normalVbo.Unbind() + m.normalVao.Unbind() + + shader.Unuse() +} + +func (m *Meshes) drawSelectedVertex( + selectedVertexMorphIndexes []int, + selectedVertexDeltas [][]float32, + shader *mview.MShader, + paddedMatrixes []float32, + width, height int, + windowIndex int, +) [][]float32 { + // モデルメッシュの前面に描画するために深度テストを無効化 + gl.Enable(gl.DEPTH_TEST) + gl.DepthFunc(gl.ALWAYS) + + shader.Use(mview.PROGRAM_TYPE_SELECTED_VERTEX) + + m.selectedVertexVao.Bind() + m.selectedVertexVbo.BindVertex(selectedVertexMorphIndexes, selectedVertexDeltas) + m.selectedVertexIbo.Bind() + + // ボーンデフォームテクスチャ設定 + bindBoneMatrixes(paddedMatrixes, width, height, shader, shader.SelectedVertexProgram) + + vertexColor := mgl32.Vec4{1.0, 0.4, 0.0, 0.7} + specularUniform := gl.GetUniformLocation(shader.SelectedVertexProgram, gl.Str(mview.SHADER_COLOR)) + gl.Uniform4fv(specularUniform, 1, &vertexColor[0]) + gl.PointSize(5.0) // 選択頂点のサイズ + + // 点描画 + gl.DrawElements( + gl.POINTS, + int32(len(m.vertices)), + gl.UNSIGNED_INT, + nil, + ) + + // SSBOからデータを読み込む + gl.BindBuffer(gl.SHADER_STORAGE_BUFFER, m.ssbo) + ptr := gl.MapBuffer(gl.SHADER_STORAGE_BUFFER, gl.READ_ONLY) + results := make([][]float32, m.vertexCount) + + if ptr != nil { + // 頂点数を取得 + for i := range results { + results[i] = make([]float32, 4) + } + + // SSBOから読み取り + for i := 0; i < m.vertexCount; i++ { + for j := 0; j < 4; j++ { + results[i][j] = *(*float32)(unsafe.Pointer(uintptr(ptr) + uintptr((i*4+j)*4))) + } + } + } + + gl.UnmapBuffer(gl.SHADER_STORAGE_BUFFER) + gl.BindBuffer(gl.SHADER_STORAGE_BUFFER, 0) + + m.selectedVertexIbo.Unbind() + m.selectedVertexVbo.Unbind() + m.selectedVertexVao.Unbind() + + shader.Unuse() + + // 深度テストを有効に戻す + gl.Enable(gl.DEPTH_TEST) + gl.DepthFunc(gl.LEQUAL) + + return results +} + +func (m *Meshes) drawBone( + shader *mview.MShader, + bones *Bones, + isDrawBones map[BoneFlag]bool, + paddedMatrixes []float32, + width, height int, + windowIndex int, +) { + // ボーンをモデルメッシュの前面に描画するために深度テストを無効化 + gl.Enable(gl.DEPTH_TEST) + gl.DepthFunc(gl.ALWAYS) + + // ブレンディングを有効にする + gl.Enable(gl.BLEND) + gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) + + shader.Use(mview.PROGRAM_TYPE_BONE) + + m.boneVao.Bind() + m.boneVbo.BindVertex(m.fetchBoneDebugDeltas(bones, isDrawBones)) + m.boneIbo.Bind() + + // ボーンデフォームテクスチャ設定 + bindBoneMatrixes(paddedMatrixes, width, height, shader, shader.BoneProgram) + + // ライン描画 + gl.DrawElements( + gl.LINES, + int32(len(m.bones)), + gl.UNSIGNED_INT, + nil, + ) + + m.boneIbo.Unbind() + m.boneVbo.Unbind() + m.boneVao.Unbind() + + shader.Unuse() + + // 深度テストを有効に戻す + gl.Enable(gl.DEPTH_TEST) + gl.DepthFunc(gl.LEQUAL) + +} + +func (m *Meshes) fetchBoneDebugDeltas(bones *Bones, isDrawBones map[BoneFlag]bool) ([]int, [][]float32) { + indexes := make([]int, 0) + deltas := make([][]float32, 0) + + for _, boneIndex := range m.boneIndexes { + bone := bones.Get(boneIndex) + indexes = append(indexes, boneIndex) + deltas = append(deltas, bone.DeltaGL(isDrawBones)) + } + + return indexes, deltas +} diff --git a/pkg/pmx/morph.go b/pkg/pmx/morph.go new file mode 100644 index 00000000..f916f15e --- /dev/null +++ b/pkg/pmx/morph.go @@ -0,0 +1,225 @@ +package pmx + +import ( + "github.com/jinzhu/copier" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +// MorphPanel 操作パネル +type MorphPanel byte + +const ( + MORPH_PANEL_SYSTEM MorphPanel = 0 // システム予約 + MORPH_PANEL_EYEBROW_LOWER_LEFT MorphPanel = 1 // 眉(左下) + MORPH_PANEL_EYE_UPPER_LEFT MorphPanel = 2 // 目(左上) + MORPH_PANEL_LIP_UPPER_RIGHT MorphPanel = 3 // 口(右上) + MORPH_PANEL_OTHER_LOWER_RIGHT MorphPanel = 4 // その他(右下) +) + +// PanelName returns the name of the operation panel. +func (p MorphPanel) PanelName() string { + switch p { + case MORPH_PANEL_EYEBROW_LOWER_LEFT: + return "眉" + case MORPH_PANEL_EYE_UPPER_LEFT: + return "目" + case MORPH_PANEL_LIP_UPPER_RIGHT: + return "口" + case MORPH_PANEL_OTHER_LOWER_RIGHT: + return "他" + default: + return "システム" + } +} + +// MorphType モーフ種類 +type MorphType int + +const ( + MORPH_TYPE_GROUP MorphType = 0 // グループ + MORPH_TYPE_VERTEX MorphType = 1 // 頂点 + MORPH_TYPE_BONE MorphType = 2 // ボーン + MORPH_TYPE_UV MorphType = 3 // UV + MORPH_TYPE_EXTENDED_UV1 MorphType = 4 // 追加UV1 + MORPH_TYPE_EXTENDED_UV2 MorphType = 5 // 追加UV2 + MORPH_TYPE_EXTENDED_UV3 MorphType = 6 // 追加UV3 + MORPH_TYPE_EXTENDED_UV4 MorphType = 7 // 追加UV4 + MORPH_TYPE_MATERIAL MorphType = 8 // 材質 + MORPH_TYPE_AFTER_VERTEX MorphType = 9 // ボーン変形後頂点(システム独自) +) + +// Morph represents a morph. +type Morph struct { + *mcore.IndexNameModel + Panel MorphPanel // モーフパネル + MorphType MorphType // モーフ種類 + Offsets []TMorphOffset // モーフオフセット + DisplaySlot int // 表示枠 + IsSystem bool // ツール側で追加したモーフ +} + +// TMorphOffset represents a morph offset. +type TMorphOffset interface { + GetType() int +} + +// VertexMorphOffset represents a vertex morph. +type VertexMorphOffset struct { + VertexIndex int // 頂点INDEX + Position *mmath.MVec3 // 座標オフセット量(x,y,z) +} + +func (v *VertexMorphOffset) GetType() int { + return int(MORPH_TYPE_VERTEX) +} + +func NewVertexMorphOffset(vertexIndex int, position *mmath.MVec3) *VertexMorphOffset { + return &VertexMorphOffset{ + VertexIndex: vertexIndex, + Position: position, + } +} + +// UvMorphOffset represents a UV morph. +type UvMorphOffset struct { + VertexIndex int // 頂点INDEX + Uv *mmath.MVec4 // UVオフセット量(x,y,z,w) +} + +func (v *UvMorphOffset) GetType() int { + return int(MORPH_TYPE_UV) +} + +func NewUvMorphOffset(vertexIndex int, uv *mmath.MVec4) *UvMorphOffset { + return &UvMorphOffset{ + VertexIndex: vertexIndex, + Uv: uv, + } +} + +// BoneMorphOffset represents a bone morph. +type BoneMorphOffset struct { + BoneIndex int // ボーンIndex + Position *mmath.MVec3 // グローバル移動量(x,y,z) + Rotation *mmath.MRotation // グローバル回転量-クォータニオン(x,y,z,w) + Scale *mmath.MVec3 // グローバル縮尺量(x,y,z) ※システム独自 + LocalPosition *mmath.MVec3 // ローカル軸に沿った移動量(x,y,z) ※システム独自 + LocalRotation *mmath.MRotation // ローカル軸に沿った回転量-クォータニオン(x,y,z,w) ※システム独自 + LocalScale *mmath.MVec3 // ローカル軸に沿った縮尺量(x,y,z) ※システム独自 +} + +func (v *BoneMorphOffset) GetType() int { + return int(MORPH_TYPE_BONE) +} + +func NewBoneMorphOffset(boneIndex int, position *mmath.MVec3, rotation *mmath.MRotation) *BoneMorphOffset { + return &BoneMorphOffset{ + BoneIndex: boneIndex, + Position: position, + Rotation: rotation, + Scale: mmath.NewMVec3(), + LocalPosition: mmath.NewMVec3(), + LocalRotation: mmath.NewRotation(), + LocalScale: mmath.NewMVec3(), + } +} + +// GroupMorphOffset represents a group morph. +type GroupMorphOffset struct { + MorphIndex int // モーフINDEX + MorphFactor float64 // モーフ変動量 +} + +func NewGroupMorphOffset(morphIndex int, morphFactor float64) *GroupMorphOffset { + return &GroupMorphOffset{ + MorphIndex: morphIndex, + MorphFactor: morphFactor, + } +} + +func (v *GroupMorphOffset) GetType() int { + return int(MORPH_TYPE_GROUP) +} + +// MaterialMorphCalcMode 材質モーフ：計算モード +type MaterialMorphCalcMode int + +const ( + CALC_MODE_MULTIPLICATION MaterialMorphCalcMode = 0 // 乗算 + CALC_MODE_ADDITION MaterialMorphCalcMode = 1 // 加算 +) + +// MaterialMorphOffset represents a material morph. +type MaterialMorphOffset struct { + MaterialIndex int // 材質Index -> -1:全材質対象 + CalcMode MaterialMorphCalcMode // 0:乗算, 1:加算 + Diffuse *mmath.MVec4 // Diffuse (R,G,B,A) + Specular *mmath.MVec4 // SpecularColor (R,G,B, 係数) + Ambient *mmath.MVec3 // AmbientColor (R,G,B) + Edge *mmath.MVec4 // エッジ色 (R,G,B,A) + EdgeSize float64 // エッジサイズ + TextureFactor *mmath.MVec4 // テクスチャ係数 (R,G,B,A) + SphereTextureFactor *mmath.MVec4 // スフィアテクスチャ係数 (R,G,B,A) + ToonTextureFactor *mmath.MVec4 // Toonテクスチャ係数 (R,G,B,A) +} + +func (v *MaterialMorphOffset) GetType() int { + return int(MORPH_TYPE_MATERIAL) +} + +func NewMaterialMorphOffset( + materialIndex int, + calcMode MaterialMorphCalcMode, + diffuse *mmath.MVec4, + specular *mmath.MVec4, + ambient *mmath.MVec3, + edge *mmath.MVec4, + edgeSize float64, + textureFactor *mmath.MVec4, + sphereTextureFactor *mmath.MVec4, + toonTextureFactor *mmath.MVec4, +) *MaterialMorphOffset { + return &MaterialMorphOffset{ + MaterialIndex: materialIndex, + CalcMode: calcMode, + Diffuse: diffuse, + Specular: specular, + Ambient: ambient, + Edge: edge, + EdgeSize: edgeSize, + TextureFactor: textureFactor, + SphereTextureFactor: sphereTextureFactor, + ToonTextureFactor: toonTextureFactor, + } +} + +// NewMorph +func NewMorph() *Morph { + return &Morph{ + IndexNameModel: &mcore.IndexNameModel{Index: -1, Name: "", EnglishName: ""}, + Panel: MORPH_PANEL_SYSTEM, + MorphType: MORPH_TYPE_VERTEX, + Offsets: make([]TMorphOffset, 0), + DisplaySlot: -1, + IsSystem: false, + } +} + +func (m *Morph) Copy() mcore.IIndexNameModel { + copied := NewMorph() + copier.CopyWithOption(copied, m, copier.Option{DeepCopy: true}) + return copied +} + +// モーフリスト +type Morphs struct { + *mcore.IndexNameModels[*Morph] +} + +func NewMorphs(count int) *Morphs { + return &Morphs{ + IndexNameModels: mcore.NewIndexNameModels[*Morph](count, func() *Morph { return nil }), + } +} diff --git a/pkg/pmx/pmx_model.go b/pkg/pmx/pmx_model.go new file mode 100644 index 00000000..5501135e --- /dev/null +++ b/pkg/pmx/pmx_model.go @@ -0,0 +1,119 @@ +package pmx + +import ( + "github.com/jinzhu/copier" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mphysics" +) + +type PmxModel struct { + *mcore.HashModel + physics *mphysics.MPhysics + Signature string + Version float64 + ExtendedUVCount int + VertexCountType int + TextureCountType int + MaterialCountType int + BoneCountType int + MorphCountType int + RigidBodyCountType int + Name string + EnglishName string + Comment string + EnglishComment string + JsonData map[string]interface{} + Vertices *Vertices + Faces *Faces + Textures *Textures + ToonTextures *ToonTextures + Materials *Materials + Bones *Bones + Morphs *Morphs + DisplaySlots *DisplaySlots + RigidBodies *RigidBodies + Joints *Joints + Meshes *Meshes + DrawInitialized bool + Index int // モデルインデックス(複数人モデル対応) +} + +func NewPmxModel(path string) *PmxModel { + model := &PmxModel{} + model.HashModel = mcore.NewHashModel(path) + + model.Vertices = NewVertices(0) + model.Faces = NewFaces(0) + model.Textures = NewTextures(0) + model.ToonTextures = NewToonTextures() + model.Materials = NewMaterials(0) + model.Bones = NewBones(0) + model.Morphs = NewMorphs(0) + model.DisplaySlots = NewDisplaySlots(0) + model.RigidBodies = NewRigidBodies(0) + model.Joints = NewJoints(0) + model.DrawInitialized = false + + return model +} + +func (pm *PmxModel) InitializeDisplaySlots() { + d01 := NewDisplaySlot() + d01.Name = "Root" + d01.EnglishName = "Root" + d01.SpecialFlag = SPECIAL_FLAG_ON + pm.DisplaySlots.Update(d01) + + d02 := NewDisplaySlot() + d02.Name = "表情" + d02.EnglishName = "Exp" + d02.SpecialFlag = SPECIAL_FLAG_ON + pm.DisplaySlots.Update(d02) +} + +func (pm *PmxModel) Setup() { + if !pm.Materials.IsDirty() && !pm.Bones.IsDirty() && !pm.RigidBodies.IsDirty() && !pm.Joints.IsDirty() { + return + } + + // セットアップ + pm.Materials.setup(pm.Vertices, pm.Faces) + pm.Bones.setup() + + // 剛体 + for i, rb := range pm.RigidBodies.Data { + if rb.BoneIndex >= 0 && pm.Bones.Contains(rb.BoneIndex) { + // 剛体に関連付けられたボーンが存在する場合、剛体とボーンを関連付ける + pm.Bones.Data[rb.BoneIndex].RigidBody = rb + pm.RigidBodies.Data[i].Bone = pm.Bones.Get(rb.BoneIndex) + } + } + + // ジョイント + for _, joint := range pm.Joints.Data { + if joint.RigidbodyIndexA >= 0 && pm.RigidBodies.Contains(joint.RigidbodyIndexA) && + joint.RigidbodyIndexB >= 0 && pm.RigidBodies.Contains(joint.RigidbodyIndexB) && + pm.RigidBodies.Get(joint.RigidbodyIndexA).BoneIndex >= 0 && + pm.Bones.Contains(pm.RigidBodies.Get(joint.RigidbodyIndexA).BoneIndex) && + pm.RigidBodies.Get(joint.RigidbodyIndexB).BoneIndex >= 0 && + pm.Bones.Contains(pm.RigidBodies.Get(joint.RigidbodyIndexB).BoneIndex) { + + // 剛体AもBも存在する場合、剛体Aと剛体Bを関連付ける + pm.RigidBodies.Data[joint.RigidbodyIndexA].JointedBone = + pm.Bones.Get(pm.RigidBodies.Get(joint.RigidbodyIndexB).BoneIndex) + pm.RigidBodies.Data[joint.RigidbodyIndexB].JointedBone = + pm.Bones.Get(pm.RigidBodies.Get(joint.RigidbodyIndexA).BoneIndex) + } + } + + pm.Bones.SetDirty(false) + pm.RigidBodies.SetDirty(false) + pm.Joints.SetDirty(false) +} + +func (m *PmxModel) Copy() mcore.IHashModel { + copied := NewPmxModel("") + copier.CopyWithOption(copied, m, copier.Option{DeepCopy: true}) + return copied +} diff --git a/pkg/pmx/pmx_model_gui.go b/pkg/pmx/pmx_model_gui.go new file mode 100644 index 00000000..30ea0716 --- /dev/null +++ b/pkg/pmx/pmx_model_gui.go @@ -0,0 +1,42 @@ +//go:build windows +// +build windows + +package pmx + +import ( + "github.com/miu200521358/mlib_go/pkg/mphysics" +) + +func (pm *PmxModel) DrawInitialize(windowIndex int, physics *mphysics.MPhysics) { + if !pm.DrawInitialized { + // モデルの初期化が終わっていない場合は初期化実行 + pm.InitDraw(windowIndex) + pm.InitPhysics(physics) + pm.DrawInitialized = true + } +} + +func (pm *PmxModel) InitDraw(windowIndex int) { + pm.ToonTextures = NewToonTextures() + pm.ToonTextures.initGl(windowIndex) + pm.Meshes = NewMeshes(pm, windowIndex) +} + +func (pm *PmxModel) InitPhysics(physics *mphysics.MPhysics) { + pm.physics = physics + pm.RigidBodies.initPhysics(pm.Index, physics) + pm.Joints.initPhysics(pm.Index, physics, pm.RigidBodies) +} + +func (pm *PmxModel) Delete() { + pm.Meshes.delete() + pm.DeletePhysics() + pm.DrawInitialized = false +} + +func (pm *PmxModel) DeletePhysics() { + if pm.physics != nil { + pm.physics.DeleteRigidBodies(pm.Index) + pm.physics.DeleteJoints(pm.Index) + } +} diff --git a/pkg/pmx/pmx_reader.go b/pkg/pmx/pmx_reader.go new file mode 100644 index 00000000..46f2187b --- /dev/null +++ b/pkg/pmx/pmx_reader.go @@ -0,0 +1,1403 @@ +package pmx + +import ( + "fmt" + "slices" + + "golang.org/x/text/encoding/unicode" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" +) + +type PmxReader struct { + mcore.BaseReader[*PmxModel] +} + +func (r *PmxReader) createModel(path string) *PmxModel { + model := &PmxModel{ + HashModel: mcore.NewHashModel(path), + } + return model +} + +// 指定されたパスのファイルからデータを読み込む +func (r *PmxReader) ReadByFilepath(path string) (mcore.IHashModel, error) { + // モデルを新規作成 + model := r.createModel(path) + + hash, err := r.ReadHashByFilePath(path) + if err != nil { + mlog.E("ReadByFilepath.ReadHashByFilePath error: %v", err) + return nil, err + } + model.Hash = hash + + // ファイルを開く + err = r.Open(path) + if err != nil { + mlog.E("ReadByFilepath.Open error: %v", err) + return model, err + } + + err = r.readHeader(model) + if err != nil { + mlog.E("ReadByFilepath.readHeader error: %v", err) + return model, err + } + + err = r.readData(model) + if err != nil { + mlog.E("ReadByFilepath.readData error: %v", err) + return model, err + } + + r.Close() + model.Setup() + + return model, nil +} + +func (r *PmxReader) ReadNameByFilepath(path string) (string, error) { + // モデルを新規作成 + model := r.createModel(path) + + // ファイルを開く + err := r.Open(path) + if err != nil { + mlog.E("ReadNameByFilepath.Open error: %v", err) + return "", err + } + + err = r.readHeader(model) + if err != nil { + mlog.E("ReadNameByFilepath.readHeader error: %v", err) + return "", err + } + + r.Close() + + return model.Name, nil +} + +func (r *PmxReader) readHeader(model *PmxModel) error { + fbytes, err := r.UnpackBytes(4) + if err != nil { + mlog.E("readHeader.UnpackBytes error: %v", err) + return err + } + model.Signature = r.DecodeText(unicode.UTF8, fbytes) + model.Version, err = r.UnpackFloat() + + if err != nil { + mlog.E("readHeader.Version error: %v", err) + return err + } + + if model.Signature[:3] != "PMX" || + !slices.Contains([]string{"2.0", "2.1"}, fmt.Sprintf("%.1f", model.Version)) { + // 整合性チェック + return fmt.Errorf("PMX2.0/2.1形式外のデータです。signature: %s, version: %.1f ", model.Signature, model.Version) + } + + // 1 : byte | 後続するデータ列のバイトサイズ PMX2.0は 8 で固定 + _, _ = r.UnpackByte() + + // [0] - エンコード方式 | 0:UTF16 1:UTF8 + encodeType, err := r.UnpackByte() + if err != nil { + mlog.E("UnpackByte encodeType error: %v", err) + return err + } + + switch encodeType { + case 0: + r.DefineEncoding(unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM)) + case 1: + r.DefineEncoding(unicode.UTF8) + default: + return fmt.Errorf("未知のエンコードタイプです。encodeType: %d", encodeType) + } + + // [1] - 追加UV数 | 0～4 詳細は頂点参照 + extendedUVCount, err := r.UnpackByte() + if err != nil { + mlog.E("UnpackByte extendedUVCount error: %v", err) + return err + } + model.ExtendedUVCount = int(extendedUVCount) + // [2] - 頂点Indexサイズ | 1,2,4 のいずれか + vertexCount, err := r.UnpackByte() + if err != nil { + mlog.E("UnpackByte vertexCount error: %v", err) + return err + } + model.VertexCountType = int(vertexCount) + // [3] - テクスチャIndexサイズ | 1,2,4 のいずれか + textureCount, err := r.UnpackByte() + if err != nil { + mlog.E("UnpackByte textureCount error: %v", err) + return err + } + model.TextureCountType = int(textureCount) + // [4] - 材質Indexサイズ | 1,2,4 のいずれか + materialCount, err := r.UnpackByte() + if err != nil { + mlog.E("UnpackByte materialCount error: %v", err) + return err + } + model.MaterialCountType = int(materialCount) + // [5] - ボーンIndexサイズ | 1,2,4 のいずれか + boneCount, err := r.UnpackByte() + if err != nil { + mlog.E("UnpackByte boneCount error: %v", err) + return err + } + model.BoneCountType = int(boneCount) + // [6] - モーフIndexサイズ | 1,2,4 のいずれか + morphCount, err := r.UnpackByte() + if err != nil { + mlog.E("UnpackByte morphCount error: %v", err) + return err + } + model.MorphCountType = int(morphCount) + // [7] - 剛体Indexサイズ | 1,2,4 のいずれか + rigidBodyCount, err := r.UnpackByte() + if err != nil { + mlog.E("UnpackByte rigidBodyCount error: %v", err) + return err + } + model.RigidBodyCountType = int(rigidBodyCount) + + // 4 + n : TextBuf | モデル名 + model.Name = r.ReadText() + // 4 + n : TextBuf | モデル名英 + model.EnglishName = r.ReadText() + // 4 + n : TextBuf | コメント + model.Comment = r.ReadText() + // 4 + n : TextBuf | コメント英 + model.EnglishComment = r.ReadText() + + return nil +} + +func (r *PmxReader) readData(model *PmxModel) error { + err := r.readVertices(model) + if err != nil { + mlog.E("readData.readVertices error: %v", err) + return err + } + + err = r.readFaces(model) + if err != nil { + mlog.E("readData.readFaces error: %v", err) + return err + } + + err = r.readTextures(model) + if err != nil { + mlog.E("readData.readTextures error: %v", err) + return err + } + + err = r.readMaterials(model) + if err != nil { + mlog.E("readData.readMaterials error: %v", err) + return err + } + + err = r.readBones(model) + if err != nil { + mlog.E("readData.readBones error: %v", err) + return err + } + + err = r.readMorphs(model) + if err != nil { + mlog.E("readData.readMorphs error: %v", err) + return err + } + + err = r.readDisplaySlots(model) + if err != nil { + mlog.E("readData.readDisplaySlots error: %v", err) + return err + } + + err = r.readRigidBodies(model) + if err != nil { + mlog.E("readData.readRigidBodies error: %v", err) + return err + } + + err = r.readJoints(model) + if err != nil { + mlog.E("readData.readJoints error: %v", err) + return err + } + + return nil +} + +func (r *PmxReader) readVertices(model *PmxModel) error { + totalVertexCount, err := r.UnpackInt() + if err != nil { + mlog.E("readVertices UnpackInt totalVertexCount error: %v", err) + return err + } + + vertices := NewVertices(totalVertexCount) + + for i := 0; i < totalVertexCount; i++ { + v := &Vertex{IndexModel: &mcore.IndexModel{Index: i}} + + // 12 : float3 | 位置(x,y,z) + pos, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readVertices UnpackFloat Position error: %v", i, err) + return err + } + v.Position = &pos + + // 12 : float3 | 法線(x,y,z) + normal, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readVertices UnpackFloat Normal[0] error: %v", i, err) + return err + } + v.Normal = &normal + + // 8 : float2 | UV(u,v) + uv, err := r.UnpackVec2() + if err != nil { + mlog.E("[%d] readVertices UnpackFloat UV[0] error: %v", i, err) + return err + } + v.Uv = &uv + + // 16 * n : float4[n] | 追加UV(x,y,z,w) PMXヘッダの追加UV数による + v.ExtendedUvs = make([]*mmath.MVec4, 0) + for j := 0; j < model.ExtendedUVCount; j++ { + extendedUV, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d][%d] readVertices UnpackVec4 ExtendedUV error: %v", i, j, err) + return err + } + v.ExtendedUvs = append(v.ExtendedUvs, &extendedUV) + } + + // 1 : byte | ウェイト変形方式 0:BDEF1 1:BDEF2 2:BDEF4 3:SDEF + Type, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readVertices UnpackByte Type error: %v", i, err) + return err + } + v.DeformType = DeformType(Type) + + switch v.DeformType { + case BDEF1: + // n : ボーンIndexサイズ | ウェイト1.0の単一ボーン(参照Index) + boneIndex, err := r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readVertices BDEF1 unpackBoneIndex error: %v", i, err) + return err + } + v.Deform = NewBdef1(boneIndex) + case BDEF2: + // n : ボーンIndexサイズ | ボーン1の参照Index + boneIndex1, err := r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readVertices BDEF2 unpackBoneIndex boneIndex1 error: %v", i, err) + return err + } + // n : ボーンIndexサイズ | ボーン2の参照Index + boneIndex2, err := r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readVertices BDEF2 unpackBoneIndex boneIndex2 error: %v", i, err) + return err + } + // 4 : float | ボーン1のウェイト値(0～1.0), ボーン2のウェイト値は 1.0-ボーン1ウェイト + boneWeight, err := r.UnpackFloat() + if err != nil { + mlog.E("[%d] readVertices BDEF2 UnpackFloat boneWeight error: %v", i, err) + return err + } + v.Deform = NewBdef2(boneIndex1, boneIndex2, boneWeight) + case BDEF4: + // n : ボーンIndexサイズ | ボーン1の参照Index + boneIndex1, err := r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readVertices BDEF4 unpackBoneIndex boneIndex1 error: %v", i, err) + return err + } + // n : ボーンIndexサイズ | ボーン2の参照Index + boneIndex2, err := r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readVertices BDEF4 unpackBoneIndex boneIndex2 error: %v", i, err) + return err + } + // n : ボーンIndexサイズ | ボーン3の参照Index + boneIndex3, err := r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readVertices BDEF4 unpackBoneIndex boneIndex3 error: %v", i, err) + return err + } + // n : ボーンIndexサイズ | ボーン4の参照Index + boneIndex4, err := r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readVertices BDEF4 unpackBoneIndex boneIndex4 error: %v", i, err) + return err + } + // 4 : float | ボーン1のウェイト値 + boneWeight1, err := r.UnpackFloat() + if err != nil { + mlog.E("[%d] readVertices BDEF4 UnpackFloat boneWeight1 error: %v", i, err) + return err + } + // 4 : float | ボーン2のウェイト値 + boneWeight2, err := r.UnpackFloat() + if err != nil { + mlog.E("[%d] readVertices BDEF4 UnpackFloat boneWeight2 error: %v", i, err) + return err + } + // 4 : float | ボーン3のウェイト値 + boneWeight3, err := r.UnpackFloat() + if err != nil { + mlog.E("[%d] readVertices BDEF4 UnpackFloat boneWeight3 error: %v", i, err) + return err + } + // 4 : float | ボーン4のウェイト値 (ウェイト計1.0の保障はない) + boneWeight4, err := r.UnpackFloat() + if err != nil { + mlog.E("[%d] readVertices BDEF4 UnpackFloat boneWeight4 error: %v", i, err) + return err + } + v.Deform = NewBdef4(boneIndex1, boneIndex2, boneIndex3, boneIndex4, + boneWeight1, boneWeight2, boneWeight3, boneWeight4) + case SDEF: + // n : ボーンIndexサイズ | ボーン1の参照Index + boneIndex1, err := r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readVertices SDEF unpackBoneIndex boneIndex1 error: %v", i, err) + return err + } + // n : ボーンIndexサイズ | ボーン2の参照Index + boneIndex2, err := r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readVertices SDEF unpackBoneIndex boneIndex2 error: %v", i, err) + return err + } + // 4 : float | ボーン1のウェイト値(0～1.0), ボーン2のウェイト値は 1.0-ボーン1ウェイト + boneWeight, err := r.UnpackFloat() + if err != nil { + mlog.E("[%d] readVertices SDEF UnpackFloat boneWeight error: %v", i, err) + return err + } + // 12 : float3 | SDEF-C値(x,y,z) + sdefC, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readVertices SDEF UnpackVec3 sdefC error: %v", i, err) + return err + } + // 12 : float3 | SDEF-R0値(x,y,z) + sdefR0, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readVertices SDEF UnpackVec3 sdefR0 error: %v", i, err) + return err + } + // 12 : float3 | SDEF-R1値(x,y,z) ※修正値を要計算 + sdefR1, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readVertices SDEF UnpackVec3 sdefR1 error: %v", i, err) + return err + } + v.Deform = NewSdef(boneIndex1, boneIndex2, boneWeight, &sdefC, &sdefR0, &sdefR1) + } + + v.EdgeFactor, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readVertices UnpackFloat EdgeFactor error: %v", i, err) + return err + } + + vertices.Update(v) + } + + model.Vertices = vertices + + return nil +} + +func (r *PmxReader) readFaces(model *PmxModel) error { + totalFaceCount, err := r.UnpackInt() + if err != nil { + mlog.E("readFaces UnpackInt totalFaceCount error: %v", err) + return err + } + + faces := NewFaces(totalFaceCount / 3) + + for i := 0; i < totalFaceCount; i += 3 { + f := &Face{ + IndexModel: &mcore.IndexModel{Index: int(i / 3)}, + VertexIndexes: [3]int{}, + } + + // n : 頂点Indexサイズ | 頂点の参照Index + f.VertexIndexes[0], err = r.unpackVertexIndex(model) + if err != nil { + mlog.E("[%d] readFaces unpackVertexIndex VertexIndexes[0] error: %v", i, err) + return err + } + + // n : 頂点Indexサイズ | 頂点の参照Index + f.VertexIndexes[1], err = r.unpackVertexIndex(model) + if err != nil { + mlog.E("[%d] readFaces unpackVertexIndex VertexIndexes[1] error: %v", i, err) + return err + } + + // n : 頂点Indexサイズ | 頂点の参照Index + f.VertexIndexes[2], err = r.unpackVertexIndex(model) + if err != nil { + mlog.E("[%d] readFaces unpackVertexIndex VertexIndexes[2] error: %v", i, err) + return err + } + + faces.Update(f) + } + + model.Faces = faces + + return nil +} + +func (r *PmxReader) readTextures(model *PmxModel) error { + totalTextureCount, err := r.UnpackInt() + if err != nil { + mlog.E("readTextures UnpackInt totalTextureCount error: %v", err) + return err + } + + textures := NewTextures(totalTextureCount) + + for i := 0; i < totalTextureCount; i++ { + t := &Texture{IndexModel: &mcore.IndexModel{Index: i}} + + // 4 + n : TextBuf | テクスチャパス + t.Name = r.ReadText() + + textures.Update(t) + } + + model.Textures = textures + + return nil +} + +func (r *PmxReader) readMaterials(model *PmxModel) error { + totalMaterialCount, err := r.UnpackInt() + if err != nil { + mlog.E("readMaterials UnpackInt totalMaterialCount error: %v", err) + return err + } + + materials := NewMaterials(totalMaterialCount) + + for i := 0; i < totalMaterialCount; i++ { + // 4 + n : TextBuf | 材質名 + name := r.ReadText() + // 4 + n : TextBuf | 材質名英 + englishName := r.ReadText() + + m := &Material{ + IndexNameModel: &mcore.IndexNameModel{Index: i, Name: name, EnglishName: englishName}, + } + + // 16 : float4 | Diffuse (R,G,B,A) + diffuse, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d] readMaterials UnpackVec4 Diffuse error: %v", i, err) + return err + } + m.Diffuse = &diffuse + // 12 : float3 | Specular (R,G,B,Specular係数) + specular, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d] readMaterials UnpackVec4 Specular error: %v", i, err) + return err + } + m.Specular = &specular + // 12 : float3 | Ambient (R,G,B) + ambient, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readMaterials UnpackVec3 Ambient error: %v", i, err) + return err + } + m.Ambient = &ambient + // 1 : bitFlag | 描画フラグ(8bit) - 各bit 0:OFF 1:ON + drawFlag, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readMaterials UnpackByte DrawFlag error: %v", i, err) + return err + } + m.DrawFlag = DrawFlag(drawFlag) + // 16 : float4 | エッジ色 (R,G,B,A) + edge, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d] readMaterials UnpackVec4 Edge error: %v", i, err) + return err + } + m.Edge = &edge + // 4 : float | エッジサイズ + m.EdgeSize, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readMaterials UnpackFloat EdgeSize error: %v", i, err) + return err + } + // n : テクスチャIndexサイズ | 通常テクスチャ + m.TextureIndex, err = r.unpackTextureIndex(model) + if err != nil { + mlog.E("[%d] readMaterials unpackTextureIndex TextureIndex error: %v", i, err) + return err + } + // n : テクスチャIndexサイズ | スフィアテクスチャ + m.SphereTextureIndex, err = r.unpackTextureIndex(model) + if err != nil { + mlog.E("[%d] readMaterials unpackTextureIndex SphereTextureIndex error: %v", i, err) + return err + } + // 1 : byte | スフィアモード 0:無効 1:乗算(sph) 2:加算(spa) 3:サブテクスチャ(追加UV1のx,yをUV参照して通常テクスチャ描画を行う) + sphereMode, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readMaterials UnpackByte SphereMode error: %v", i, err) + return err + } + m.SphereMode = SphereMode(sphereMode) + // 1 : byte | 共有Toonフラグ 0:継続値は個別Toon 1:継続値は共有Toon + toonSharingFlag, err := r.UnpackByte() + + if err != nil { + mlog.E("[%d] readMaterials UnpackByte ToonSharingFlag error: %v", i, err) + return err + } + m.ToonSharingFlag = ToonSharing(toonSharingFlag) + + switch m.ToonSharingFlag { + case TOON_SHARING_INDIVIDUAL: + // n : テクスチャIndexサイズ | Toonテクスチャ + m.ToonTextureIndex, err = r.unpackTextureIndex(model) + if err != nil { + mlog.E("[%d] readMaterials unpackTextureIndex ToonTextureIndex error: %v", i, err) + return err + } + case TOON_SHARING_SHARING: + // 1 : byte | 共有ToonテクスチャIndex 0～9 + toonTextureIndex, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readMaterials UnpackByte ToonTextureIndex error: %v", i, err) + return err + } + m.ToonTextureIndex = int(toonTextureIndex) + } + + // 4 + n : TextBuf | メモ + m.Memo = r.ReadText() + + // 4 : int | 材質に対応する面(頂点)数 (必ず3の倍数になる) + m.VerticesCount, err = r.UnpackInt() + if err != nil { + mlog.E("[%d] readMaterials UnpackInt VerticesCount error: %v", i, err) + return err + } + + materials.Update(m) + + } + + model.Materials = materials + + return nil +} + +func (r *PmxReader) readBones(model *PmxModel) error { + totalBoneCount, err := r.UnpackInt() + if err != nil { + mlog.E("readBones UnpackInt totalBoneCount error: %v", err) + return err + } + + bones := NewBones(totalBoneCount) + + for i := 0; i < totalBoneCount; i++ { + + // 4 + n : TextBuf | ボーン名 + name := r.ReadText() + // 4 + n : TextBuf | ボーン名英 + englishName := r.ReadText() + + b := &Bone{ + IndexNameModel: &mcore.IndexNameModel{Index: i, Name: name, EnglishName: englishName}, + IkLinkBoneIndexes: make([]int, 0), + IkTargetBoneIndexes: make([]int, 0), + ParentRelativePosition: mmath.NewMVec3(), + ChildRelativePosition: mmath.NewMVec3(), + NormalizedFixedAxis: mmath.NewMVec3(), + TreeBoneIndexes: make([]int, 0), + RevertOffsetMatrix: mmath.NewMMat4(), + OffsetMatrix: mmath.NewMMat4(), + ParentBoneIndexes: make([]int, 0), + RelativeBoneIndexes: make([]int, 0), + ChildBoneIndexes: make([]int, 0), + EffectiveBoneIndexes: make([]int, 0), + AngleLimit: false, + MinAngleLimit: mmath.NewRotation(), + MaxAngleLimit: mmath.NewRotation(), + LocalAngleLimit: false, + LocalMinAngleLimit: mmath.NewRotation(), + LocalMaxAngleLimit: mmath.NewRotation(), + AxisSign: 1, + } + + // 12 : float3 | 位置 + pos, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readBones UnpackVec3 Position error: %v", i, err) + return err + } + b.Position = &pos + // n : ボーンIndexサイズ | 親ボーン + b.ParentIndex, err = r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readBones unpackBoneIndex ParentIndex error: %v", i, err) + return err + } + // 4 : int | 変形階層 + b.Layer, err = r.UnpackInt() + if err != nil { + mlog.E("[%d] UnpackInt Layer error: %v", i, err) + return err + } + // 2 : bitFlag*2 | ボーンフラグ(16bit) 各bit 0:OFF 1:ON + boneFlag, err := r.UnpackBytes(2) + if err != nil { + mlog.E("[%d] readBones UnpackBytes BoneFlag error: %v", i, err) + return err + } + b.BoneFlag = BoneFlag(uint16(boneFlag[0]) | uint16(boneFlag[1])<<8) + + // 0x0001 : 接続先(PMD子ボーン指定)表示方法 -> 0:座標オフセットで指定 1:ボーンで指定 + if b.IsTailBone() { + // n : ボーンIndexサイズ | 接続先ボーンのボーンIndex + b.TailIndex, err = r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readBones unpackBoneIndex TailIndex error: %v", i, err) + return err + } + b.TailPosition = mmath.NewMVec3() + } else { + // 12 : float3 | 座標オフセット, ボーン位置からの相対分 + b.TailIndex = -1 + tailPos, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readBones UnpackVec3 TailPosition error: %v", i, err) + return err + } + b.TailPosition = &tailPos + } + + // 回転付与:1 または 移動付与:1 の場合 + if b.IsEffectorRotation() || b.IsEffectorTranslation() { + // n : ボーンIndexサイズ | 付与親ボーンのボーンIndex + b.EffectIndex, err = r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readBones unpackBoneIndex EffectIndex error: %v", i, err) + return err + } + // 4 : float | 付与率 + b.EffectFactor, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readBones UnpackFloat EffectFactor error: %v", i, err) + return err + } + } else { + b.EffectIndex = -1 + b.EffectFactor = 0 + } + + // 軸固定:1 の場合 + if b.HasFixedAxis() { + // 12 : float3 | 軸の方向ベクトル + fixedAxis, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readBones UnpackVec3 FixedAxis error: %v", i, err) + return err + } + b.FixedAxis = &fixedAxis + b.NormalizeFixedAxis(b.FixedAxis.Normalize()) + } else { + b.FixedAxis = mmath.NewMVec3() + } + + // ローカル軸:1 の場合 + if b.HasLocalAxis() { + // 12 : float3 | X軸の方向ベクトル + localAxisX, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readBones UnpackVec3 LocalAxisX error: %v", i, err) + return err + } + b.LocalAxisX = &localAxisX + // 12 : float3 | Z軸の方向ベクトル + localAxisZ, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readBones UnpackVec3 LocalAxisZ error: %v", i, err) + return err + } + b.LocalAxisZ = &localAxisZ + b.NormalizeLocalAxis(b.LocalAxisX) + } else { + b.LocalAxisX = mmath.NewMVec3() + b.LocalAxisZ = mmath.NewMVec3() + } + + // 外部親変形:1 の場合 + if b.IsEffectorParentDeform() { + // 4 : int | Key値 + b.EffectorKey, err = r.UnpackInt() + if err != nil { + mlog.E("[%d] readBones UnpackInt EffectorKey error: %v", i, err) + return err + } + } + + // IK:1 の場合 IKデータを格納 + if b.IsIK() { + b.Ik = NewIk() + + // n : ボーンIndexサイズ | IKターゲットボーンのボーンIndex + b.Ik.BoneIndex, err = r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readBones unpackBoneIndex Ik.BoneIndex error: %v", i, err) + return err + } + // 4 : int | IKループ回数 (PMD及びMMD環境では255回が最大になるようです) + b.Ik.LoopCount, err = r.UnpackInt() + if err != nil { + mlog.E("[%d] readBones UnpackInt Ik.LoopCount error: %v", i, err) + return err + } + // 4 : float | IKループ計算時の1回あたりの制限角度 -> ラジアン角 | PMDのIK値とは4倍異なるので注意 + unitRot, err := r.UnpackFloat() + if err != nil { + mlog.E("[%d] readBones UnpackFloat unitRot error: %v", i, err) + return err + } + b.Ik.UnitRotation.SetRadians(&mmath.MVec3{unitRot, unitRot, unitRot}) + // 4 : int | IKリンク数 : 後続の要素数 + ikLinkCount, err := r.UnpackInt() + if err != nil { + mlog.E("[%d] readBones UnpackInt ikLinkCount error: %v", i, err) + return err + } + for j := 0; j < ikLinkCount; j++ { + il := NewIkLink() + // n : ボーンIndexサイズ | リンクボーンのボーンIndex + il.BoneIndex, err = r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d][%d] readBones unpackBoneIndex IkLink.BoneIndex error: %v", i, j, err) + return err + } + // 1 : byte | 角度制限 0:OFF 1:ON + ikLinkAngleLimit, err := r.UnpackByte() + if err != nil { + mlog.E("[%d][%d] readBones UnpackByte IkLink.AngleLimit error: %v", i, j, err) + return err + } + il.AngleLimit = ikLinkAngleLimit == 1 + if il.AngleLimit { + // 12 : float3 | 下限 (x,y,z) -> ラジアン角 + minAngleLimit, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d][%d] readBones UnpackVec3 IkLink.MinAngleLimit error: %v", i, j, err) + return err + } + il.MinAngleLimit.SetRadians(&minAngleLimit) + // 12 : float3 | 上限 (x,y,z) -> ラジアン角 + maxAngleLimit, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d][%d] readBones UnpackVec3 IkLink.MaxAngleLimit error: %v", i, j, err) + return err + } + il.MaxAngleLimit.SetRadians(&maxAngleLimit) + } + b.Ik.Links = append(b.Ik.Links, il) + } + } + + bones.Update(b) + } + + model.Bones = bones + + return nil +} + +func (r *PmxReader) readMorphs(model *PmxModel) error { + totalMorphCount, err := r.UnpackInt() + if err != nil { + mlog.E("readMorphs UnpackInt totalMorphCount error: %v", err) + return err + } + + morphs := NewMorphs(totalMorphCount) + + for i := 0; i < totalMorphCount; i++ { + // 4 + n : TextBuf | モーフ名 + name := r.ReadText() + // 4 + n : TextBuf | モーフ名英 + englishName := r.ReadText() + + m := &Morph{ + IndexNameModel: &mcore.IndexNameModel{Index: i, Name: name, EnglishName: englishName}, + } + + // 1 : byte | 操作パネル (PMD:カテゴリ) 1:眉(左下) 2:目(左上) 3:口(右上) 4:その他(右下) | 0:システム予約 + panel, err := r.UnpackByte() + if err != nil { + return err + } + m.Panel = MorphPanel(panel) + // 1 : byte | モーフ種類 - 0:グループ, 1:頂点, 2:ボーン, 3:UV, 4:追加UV1, 5:追加UV2, 6:追加UV3, 7:追加UV4, 8:材質 + morphType, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readMorphs UnpackByte MorphType error: %v", i, err) + return err + } + m.MorphType = MorphType(morphType) + + offsetCount, err := r.UnpackInt() + if err != nil { + mlog.E("[%d] readMorphs UnpackInt OffsetCount error: %v", i, err) + return err + } + for j := 0; j < offsetCount; j++ { + switch m.MorphType { + case MORPH_TYPE_GROUP: + // n : モーフIndexサイズ | モーフIndex ※仕様上グループモーフのグループ化は非対応とする + morphIndex, err := r.unpackMorphIndex(model) + if err != nil { + mlog.E("[%d][%d] readMorphs unpackMorphIndex MorphIndex error: %v", i, j, err) + return err + } + // 4 : float | モーフ率 : グループモーフのモーフ値 * モーフ率 = 対象モーフのモーフ値 + morphFactor, err := r.UnpackFloat() + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackFloat MorphFactor error: %v", i, j, err) + return err + } + m.Offsets = append(m.Offsets, NewGroupMorphOffset(morphIndex, morphFactor)) + case MORPH_TYPE_VERTEX: + // n : 頂点Indexサイズ | 頂点Index + vertexIndex, err := r.unpackVertexIndex(model) + if err != nil { + mlog.E("[%d][%d] readMorphs unpackVertexIndex VertexIndex error: %v", i, j, err) + return err + } + // 12 : float3 | 座標オフセット量(x,y,z) + offset, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackVec3 Offset error: %v", i, j, err) + return err + } + m.Offsets = append(m.Offsets, NewVertexMorphOffset(vertexIndex, &offset)) + case MORPH_TYPE_BONE: + // n : ボーンIndexサイズ | ボーンIndex + boneIndex, err := r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d][%d] readMorphs unpackBoneIndex BoneIndex error: %v", i, j, err) + return err + } + // 12 : float3 | 移動量(x,y,z) + offset, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackVec3 Offset error: %v", i, j, err) + return err + } + // 16 : float4 | 回転量(x,y,z,w) + qq, err := r.UnpackQuaternion(true) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackQuaternion Quaternion error: %v", i, j, err) + return err + } + m.Offsets = append(m.Offsets, NewBoneMorphOffset(boneIndex, &offset, mmath.NewRotationFromQuaternion(&qq))) + case MORPH_TYPE_UV, MORPH_TYPE_EXTENDED_UV1, MORPH_TYPE_EXTENDED_UV2, MORPH_TYPE_EXTENDED_UV3, MORPH_TYPE_EXTENDED_UV4: + // n : 頂点Indexサイズ | 頂点Index + vertexIndex, err := r.unpackVertexIndex(model) + if err != nil { + mlog.E("[%d][%d] readMorphs unpackVertexIndex VertexIndex error: %v", i, j, err) + return err + } + // 16 : float4 | UVオフセット量(x,y,z,w) ※通常UVはz,wが不要項目になるがモーフとしてのデータ値は記録しておく + offset, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackVec4 Offset error: %v", i, j, err) + return err + } + m.Offsets = append(m.Offsets, NewUvMorphOffset(vertexIndex, &offset)) + case MORPH_TYPE_MATERIAL: + // n : 材質Indexサイズ | 材質Index -> -1:全材質対象 + materialIndex, err := r.unpackMaterialIndex(model) + if err != nil { + mlog.E("[%d][%d] readMorphs unpackMaterialIndex MaterialIndex error: %v", i, j, err) + return err + } + // 1 : オフセット演算形式 | 0:乗算, 1:加算 - 詳細は後述 + calcMode, err := r.UnpackByte() + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackByte CalcMode error: %v", i, j, err) + return err + } + // 16 : float4 | Diffuse (R,G,B,A) - 乗算:1.0／加算:0.0 が初期値となる(同以下) + diffuse, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackVec4 Diffuse error: %v", i, j, err) + return err + } + // 12 : float3 | Specular (R,G,B, Specular係数) + specular, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackVec4 Specular error: %v", i, j, err) + return err + } + // 12 : float3 | Ambient (R,G,B) + ambient, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackVec3 Ambient error: %v", i, j, err) + return err + } + // 16 : float4 | エッジ色 (R,G,B,A) + edge, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackVec4 Edge error: %v", i, j, err) + return err + } + // 4 : float | エッジサイズ + edgeSize, err := r.UnpackFloat() + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackFloat EdgeSize error: %v", i, j, err) + return err + } + // 16 : float4 | テクスチャ係数 (R,G,B,A) + textureFactor, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackVec4 TextureFactor error: %v", i, j, err) + return err + } + // 16 : float4 | スフィアテクスチャ係数 (R,G,B,A) + sphereTextureFactor, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackVec4 SphereTextureFactor error: %v", i, j, err) + return err + } + // 16 : float4 | Toonテクスチャ係数 (R,G,B,A) + toonTextureFactor, err := r.UnpackVec4(false) + if err != nil { + mlog.E("[%d][%d] readMorphs UnpackVec4 ToonTextureFactor error: %v", i, j, err) + return err + } + m.Offsets = append(m.Offsets, NewMaterialMorphOffset( + materialIndex, + MaterialMorphCalcMode(calcMode), + &diffuse, + &specular, + &ambient, + &edge, + edgeSize, + &textureFactor, + &sphereTextureFactor, + &toonTextureFactor, + )) + } + } + + morphs.Update(m) + } + + model.Morphs = morphs + + return nil +} + +func (r *PmxReader) readDisplaySlots(model *PmxModel) error { + totalDisplaySlotCount, err := r.UnpackInt() + if err != nil { + mlog.E("readDisplaySlots UnpackInt totalDisplaySlotCount error: %v", err) + return err + } + + displaySlots := NewDisplaySlots(totalDisplaySlotCount) + + for i := 0; i < totalDisplaySlotCount; i++ { + // 4 + n : TextBuf | 枠名 + name := r.ReadText() + // 4 + n : TextBuf | 枠名英 + englishName := r.ReadText() + + d := &DisplaySlot{ + IndexNameModel: &mcore.IndexNameModel{Index: i, Name: name, EnglishName: englishName}, + References: make([]Reference, 0), + } + + // 1 : byte | 特殊枠フラグ - 0:通常枠 1:特殊枠 + specialFlag, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readDisplaySlots UnpackByte SpecialFlag error: %v", i, err) + return err + } + d.SpecialFlag = SpecialFlag(specialFlag) + + // 4 : int | 枠内要素数 : 後続の要素数 + referenceCount, err := r.UnpackInt() + if err != nil { + mlog.E("[%d] readDisplaySlots UnpackInt ReferenceCount error: %v", i, err) + return err + } + + for j := 0; j < referenceCount; j++ { + reference := NewDisplaySlotReference() + + // 1 : byte | 要素種別 - 0:ボーン 1:モーフ + referenceType, err := r.UnpackByte() + if err != nil { + mlog.E("[%d][%d] readDisplaySlots UnpackByte ReferenceType error: %v", i, j, err) + return err + } + reference.DisplayType = DisplayType(referenceType) + + switch reference.DisplayType { + case DISPLAY_TYPE_BONE: + // n : ボーンIndexサイズ | ボーンIndex + reference.DisplayIndex, err = r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d][%d] readDisplaySlots unpackBoneIndex DisplayIndex error: %v", i, j, err) + return err + } + case DISPLAY_TYPE_MORPH: + // n : モーフIndexサイズ | モーフIndex + reference.DisplayIndex, err = r.unpackMorphIndex(model) + if err != nil { + mlog.E("[%d][%d] readDisplaySlots unpackMorphIndex DisplayIndex error: %v", i, j, err) + return err + } + } + + d.References = append(d.References, *reference) + } + + displaySlots.Update(d) + } + + model.DisplaySlots = displaySlots + + return nil +} + +func (r *PmxReader) readRigidBodies(model *PmxModel) error { + totalRigidBodyCount, err := r.UnpackInt() + if err != nil { + mlog.E("readRigidBodies UnpackInt totalRigidBodyCount error: %v", err) + return err + } + + rigidBodies := NewRigidBodies(totalRigidBodyCount) + + for i := 0; i < totalRigidBodyCount; i++ { + // 4 + n : TextBuf | 剛体名 + name := r.ReadText() + // 4 + n : TextBuf | 剛体名英 + englishName := r.ReadText() + + b := &RigidBody{ + IndexNameModel: &mcore.IndexNameModel{Index: i, Name: name, EnglishName: englishName}, + RigidBodyParam: NewRigidBodyParam(), + } + + // n : ボーンIndexサイズ | 関連ボーンIndex - 関連なしの場合は-1 + b.BoneIndex, err = r.unpackBoneIndex(model) + if err != nil { + mlog.E("[%d] readRigidBodies unpackBoneIndex BoneIndex error: %v", i, err) + return err + } + // 1 : byte | グループ + collisionGroup, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readRigidBodies UnpackByte CollisionGroup error: %v", i, err) + return err + } + b.CollisionGroup = collisionGroup + // 2 : ushort | 非衝突グループフラグ + collisionGroupMask, err := r.UnpackUShort() + if err != nil { + mlog.E("[%d] readRigidBodies UnpackUShort CollisionGroupMask error: %v", i, err) + return err + } + b.CollisionGroupMaskValue = int(collisionGroupMask) + b.CollisionGroupMask.IsCollisions = NewCollisionGroup(collisionGroupMask) + // 1 : byte | 形状 - 0:球 1:箱 2:カプセル + shapeType, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readRigidBodies UnpackByte ShapeType error: %v", i, err) + return err + } + b.ShapeType = Shape(shapeType) + // 12 : float3 | サイズ(x,y,z) + size, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readRigidBodies UnpackVec3 Size error: %v", i, err) + return err + } + b.Size = &size + // 12 : float3 | 位置(x,y,z) + position, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readRigidBodies UnpackVec3 Position error: %v", i, err) + return err + } + b.Position = &position + // 12 : float3 | 回転(x,y,z) -> ラジアン角 + rads, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readRigidBodies UnpackVec3 Rotation error: %v", i, err) + return err + } + b.Rotation = mmath.NewRotationFromRadians(&rads) + // 4 : float | 質量 + b.RigidBodyParam.Mass, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readRigidBodies UnpackFloat Mass error: %v", i, err) + return err + } + // 4 : float | 移動減衰 + b.RigidBodyParam.LinearDamping, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readRigidBodies UnpackFloat LinearDamping error: %v", i, err) + return err + } + // 4 : float | 回転減衰 + b.RigidBodyParam.AngularDamping, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readRigidBodies UnpackFloat AngularDamping error: %v", i, err) + return err + } + // 4 : float | 反発力 + b.RigidBodyParam.Restitution, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readRigidBodies UnpackFloat Restitution error: %v", i, err) + return err + } + // 4 : float | 摩擦力 + b.RigidBodyParam.Friction, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readRigidBodies UnpackFloat Friction error: %v", i, err) + return err + } + // 1 : byte | 剛体の物理演算 - 0:ボーン追従(static) 1:物理演算(dynamic) 2:物理演算 + Bone位置合わせ + physicsType, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readRigidBodies UnpackByte PhysicsType error: %v", i, err) + return err + } + b.PhysicsType = PhysicsType(physicsType) + + rigidBodies.Update(b) + } + + model.RigidBodies = rigidBodies + + return nil +} + +func (r *PmxReader) readJoints(model *PmxModel) error { + totalJointCount, err := r.UnpackInt() + if err != nil { + mlog.E("readJoints UnpackInt totalJointCount error: %v", err) + return err + } + + joints := NewJoints(totalJointCount) + + for i := 0; i < totalJointCount; i++ { + // 4 + n : TextBuf | Joint名 + name := r.ReadText() + // 4 + n : TextBuf | Joint名英 + englishName := r.ReadText() + + j := &Joint{ + IndexNameModel: &mcore.IndexNameModel{Index: i, Name: name, EnglishName: englishName}, + JointParam: NewJointParam(), + } + + // 1 : byte | Joint種類 - 0:スプリング6DOF | PMX2.0では 0 のみ(拡張用) + j.JointType, err = r.UnpackByte() + if err != nil { + mlog.E("[%d] readJoints UnpackByte JointType error: %v", i, err) + return err + } + // n : 剛体Indexサイズ | 関連剛体AのIndex - 関連なしの場合は-1 + j.RigidbodyIndexA, err = r.unpackRigidBodyIndex(model) + if err != nil { + mlog.E("[%d] readJoints unpackRigidBodyIndex RigidbodyIndexA error: %v", i, err) + return err + } + // n : 剛体Indexサイズ | 関連剛体BのIndex - 関連なしの場合は-1 + j.RigidbodyIndexB, err = r.unpackRigidBodyIndex(model) + if err != nil { + mlog.E("[%d] readJoints unpackRigidBodyIndex RigidbodyIndexB error: %v", i, err) + return err + } + // 12 : float3 | 位置(x,y,z) + position, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readJoints UnpackVec3 Position error: %v", i, err) + return err + } + j.Position = &position + // 12 : float3 | 回転(x,y,z) -> ラジアン角 + rads, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readJoints UnpackVec3 Rotation error: %v", i, err) + return err + } + j.Rotation = mmath.NewRotationFromRadians(&rads) + // 12 : float3 | 移動制限-下限(x,y,z) + translationLimitMin, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readJoints UnpackVec3 TranslationLimitMin error: %v", i, err) + return err + } + j.JointParam.TranslationLimitMin = &translationLimitMin + // 12 : float3 | 移動制限-上限(x,y,z) + translationLimitMax, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readJoints UnpackVec3 TranslationLimitMax error: %v", i, err) + return err + } + j.JointParam.TranslationLimitMax = &translationLimitMax + // 12 : float3 | 回転制限-下限(x,y,z) -> ラジアン角 + rotationLimitMin, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readJoints UnpackVec3 RotationLimitMin error: %v", i, err) + return err + } + j.JointParam.RotationLimitMin = mmath.NewRotationFromRadians(&rotationLimitMin) + // 12 : float3 | 回転制限-上限(x,y,z) -> ラジアン角 + rotationLimitMax, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readJoints UnpackVec3 RotationLimitMax error: %v", i, err) + return err + } + j.JointParam.RotationLimitMax = mmath.NewRotationFromRadians(&rotationLimitMax) + // 12 : float3 | バネ定数-移動(x,y,z) + springConstantTranslation, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readJoints UnpackVec3 SpringConstantTranslation error: %v", i, err) + return err + } + j.JointParam.SpringConstantTranslation = &springConstantTranslation + // 12 : float3 | バネ定数-回転(x,y,z) + springConstantRotation, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readJoints UnpackVec3 SpringConstantRotation error: %v", i, err) + return err + } + j.JointParam.SpringConstantRotation = mmath.NewRotationFromRadians(&springConstantRotation) + + joints.Update(j) + } + + model.Joints = joints + + return nil +} + +// テキストデータを読み取る +func (r *PmxReader) unpackVertexIndex(model *PmxModel) (int, error) { + switch model.VertexCountType { + case 1: + v, err := r.UnpackByte() + if err != nil { + mlog.E("unpackVertexIndex.UnpackByte error: %v", err) + return 0, err + } + return int(v), nil + case 2: + v, err := r.UnpackUShort() + if err != nil { + mlog.E("unpackVertexIndex.UnpackUShort error: %v", err) + return 0, err + } + return int(v), nil + case 4: + v, err := r.UnpackInt() + if err != nil { + mlog.E("unpackVertexIndex.UnpackInt error: %v", err) + return 0, err + } + return v, nil + } + return 0, fmt.Errorf("未知のVertexIndexサイズです。vertexCount: %d", model.VertexCountType) +} + +// テクスチャIndexを読み取る +func (r *PmxReader) unpackTextureIndex(model *PmxModel) (int, error) { + return r.unpackIndex(model.TextureCountType) +} + +// 材質Indexを読み取る +func (r *PmxReader) unpackMaterialIndex(model *PmxModel) (int, error) { + return r.unpackIndex(model.MaterialCountType) +} + +// ボーンIndexを読み取る +func (r *PmxReader) unpackBoneIndex(model *PmxModel) (int, error) { + return r.unpackIndex(model.BoneCountType) +} + +// 表情Indexを読み取る +func (r *PmxReader) unpackMorphIndex(model *PmxModel) (int, error) { + return r.unpackIndex(model.MorphCountType) +} + +// 剛体Indexを読み取る +func (r *PmxReader) unpackRigidBodyIndex(model *PmxModel) (int, error) { + return r.unpackIndex(model.RigidBodyCountType) +} + +func (r *PmxReader) unpackIndex(index int) (int, error) { + switch index { + case 1: + v, err := r.UnpackSByte() + if err != nil { + mlog.E("unpackIndex.UnpackSByte error: %v", err) + return 0, err + } + return int(v), nil + case 2: + v, err := r.UnpackShort() + if err != nil { + mlog.E("unpackIndex.UnpackShort error: %v", err) + return 0, err + } + return int(v), nil + case 4: + v, err := r.UnpackInt() + if err != nil { + mlog.E("unpackIndex.UnpackInt error: %v", err) + return 0, err + } + return v, nil + } + return 0, fmt.Errorf("未知のIndexサイズです。index: %d", index) +} diff --git a/pkg/pmx/pmx_reader_test.go b/pkg/pmx/pmx_reader_test.go new file mode 100644 index 00000000..d01cca7d --- /dev/null +++ b/pkg/pmx/pmx_reader_test.go @@ -0,0 +1,854 @@ +package pmx + +import ( + "math" + "testing" + + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +func TestPmxReader_ReadNameByFilepath(t *testing.T) { + r := &PmxReader{} + + modelName, err := r.ReadNameByFilepath("../../test_resources/サンプルモデル_PMX読み取り確認用.pmx") + + expectedName := "v2配布用素体03" + if modelName != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, modelName) + } + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } +} + +func TestPmxReader_ReadNameByFilepath_2_1(t *testing.T) { + r := &PmxReader{} + + modelName, err := r.ReadNameByFilepath("../../test_resources/サンプルモデル_PMX2.1_UTF-8.pmx") + + expectedName := "サンプルモデル迪卢克" + if modelName != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, modelName) + } + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } +} + +func TestPmxReader_ReadNameByFilepath_NotExist(t *testing.T) { + r := &PmxReader{} + + modelName, err := r.ReadNameByFilepath("../../test_resources/サンプルモデル_Nothing.pmx") + + expectedName := "" + if modelName != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, modelName) + } + + if err == nil { + t.Errorf("Expected error to be not nil, got %q", err) + } +} + +func TestPmxReader_ReadByFilepath(t *testing.T) { + r := &PmxReader{} + + data, err := r.ReadByFilepath("../../test_resources/サンプルモデル_PMX読み取り確認用.pmx") + model := data.(*PmxModel) + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + expectedSignature := "PMX " + if model.Signature != expectedSignature { + t.Errorf("Expected Signature to be %q, got %q", expectedSignature, model.Signature) + } + + expectedVersion := 2.0 + if model.Version != expectedVersion { + t.Errorf("Expected Version to be %f, got %f", expectedVersion, model.Version) + } + + expectedName := "v2配布用素体03" + if model.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, model.Name) + } + + { + v := model.Vertices.Get(13) + expectedPosition := &mmath.MVec3{0.1565633, 16.62944, -0.2150156} + if !v.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, v.Position) + } + expectedNormal := &mmath.MVec3{0.2274586, 0.6613649, -0.714744} + if !v.Normal.MMD().NearEquals(expectedNormal, 1e-5) { + t.Errorf("Expected Normal to be %v, got %v", expectedNormal, v.Normal) + } + expectedUV := &mmath.MVec2{0.5112334, 0.1250942} + if !v.Uv.NearEquals(expectedUV, 1e-5) { + t.Errorf("Expected UV to be %v, got %v", expectedUV, v.Uv) + } + expectedDeformType := BDEF4 + if v.DeformType != expectedDeformType { + t.Errorf("Expected DeformType to be %d, got %d", expectedDeformType, v.DeformType) + } + expectedDeform := NewBdef4(7, 8, 25, 9, 0.6375693, 0.2368899, 0.06898639, 0.05655446) + if v.Deform.GetAllIndexes()[0] != expectedDeform.Indexes[0] { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Indexes[0], v.Deform.GetAllIndexes()[0]) + } + if v.Deform.GetAllIndexes()[1] != expectedDeform.Indexes[1] { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Indexes[1], v.Deform.GetAllIndexes()[1]) + } + if v.Deform.GetAllIndexes()[2] != expectedDeform.Indexes[2] { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Indexes[2], v.Deform.GetAllIndexes()[2]) + } + if v.Deform.GetAllIndexes()[3] != expectedDeform.Indexes[3] { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Indexes[3], v.Deform.GetAllIndexes()[3]) + } + if math.Abs(v.Deform.GetAllWeights()[0]-expectedDeform.Weights[0]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[0], v.Deform.GetAllWeights()[0]) + } + if math.Abs(v.Deform.GetAllWeights()[1]-expectedDeform.Weights[1]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[1], v.Deform.GetAllWeights()[1]) + } + if math.Abs(v.Deform.GetAllWeights()[2]-expectedDeform.Weights[2]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[2], v.Deform.GetAllWeights()[2]) + } + if math.Abs(v.Deform.GetAllWeights()[3]-expectedDeform.Weights[3]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[3], v.Deform.GetAllWeights()[3]) + } + expectedEdgeFactor := 1.0 + if math.Abs(v.EdgeFactor-expectedEdgeFactor) > 1e-5 { + t.Errorf("Expected EdgeFactor to be %v, got %v", expectedEdgeFactor, v.EdgeFactor) + } + } + + { + v := model.Vertices.Get(120) + expectedPosition := &mmath.MVec3{1.529492, 5.757646, 0.4527041} + if !v.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, v.Position) + } + expectedNormal := &mmath.MVec3{0.9943396, 0.1054612, -0.0129031} + if !v.Normal.MMD().NearEquals(expectedNormal, 1e-5) { + t.Errorf("Expected Normal to be %v, got %v", expectedNormal, v.Normal) + } + expectedUV := &mmath.MVec2{0.8788766, 0.7697825} + if !v.Uv.NearEquals(expectedUV, 1e-5) { + t.Errorf("Expected UV to be %v, got %v", expectedUV, v.Uv) + } + expectedDeformType := BDEF2 + if v.DeformType != expectedDeformType { + t.Errorf("Expected DeformType to be %d, got %d", expectedDeformType, v.DeformType) + } + expectedDeform := NewBdef2(109, 108, 0.9845969) + if v.Deform.GetAllIndexes()[0] != expectedDeform.Indexes[0] { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Indexes[0], v.Deform.GetAllIndexes()[0]) + } + if v.Deform.GetAllIndexes()[1] != expectedDeform.Indexes[1] { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Indexes[1], v.Deform.GetAllIndexes()[1]) + } + if math.Abs(v.Deform.GetAllWeights()[0]-expectedDeform.Weights[0]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[0], v.Deform.GetAllWeights()[0]) + } + if math.Abs(v.Deform.GetAllWeights()[1]-expectedDeform.Weights[1]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[1], v.Deform.GetAllWeights()[1]) + } + expectedEdgeFactor := 1.0 + if math.Abs(v.EdgeFactor-expectedEdgeFactor) > 1e-5 { + t.Errorf("Expected EdgeFactor to be %v, got %v", expectedEdgeFactor, v.EdgeFactor) + } + } + + { + f := model.Faces.Get(19117) + expectedFaceVertexIndexes := []int{8857, 8893, 8871} + if f.VertexIndexes[0] != expectedFaceVertexIndexes[0] { + t.Errorf("Expected Deform to be %v, got %v", expectedFaceVertexIndexes[0], f.VertexIndexes[0]) + } + if f.VertexIndexes[1] != expectedFaceVertexIndexes[1] { + t.Errorf("Expected Deform to be %v, got %v", expectedFaceVertexIndexes[1], f.VertexIndexes[1]) + } + if f.VertexIndexes[2] != expectedFaceVertexIndexes[2] { + t.Errorf("Expected Deform to be %v, got %v", expectedFaceVertexIndexes[2], f.VertexIndexes[2]) + } + } + + { + tex := model.Textures.Get(10) + expectedName := "tex\\_13_Toon.bmp" + if tex.Name != expectedName { + t.Errorf("Expected Path to be %q, got %q", expectedName, tex.Name) + } + } + + { + m := model.Materials.Get(10) + expectedName := "00_EyeWhite_はぅ" + if m.Name != expectedName { + t.Errorf("Expected Path to be %q, got %q", expectedName, m.Name) + } + expectedEnglishName := "N00_000_00_EyeWhite_00_EYE (Instance)_Hau" + if m.EnglishName != expectedEnglishName { + t.Errorf("Expected Path to be %q, got %q", expectedEnglishName, m.EnglishName) + } + expectedDiffuse := &mmath.MVec4{1.0, 1.0, 1.0, 0.0} + if !m.Diffuse.NearEquals(expectedDiffuse, 1e-5) { + t.Errorf("Expected Diffuse to be %v, got %v", expectedDiffuse, m.Diffuse) + } + expectedSpecular := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !m.Specular.NearEquals(expectedSpecular, 1e-5) { + t.Errorf("Expected Specular to be %v, got %v", expectedSpecular, m.Specular) + } + expectedAmbient := &mmath.MVec3{0.5, 0.5, 0.5} + if !m.Ambient.NearEquals(expectedAmbient, 1e-5) { + t.Errorf("Expected Ambient to be %v, got %v", expectedAmbient, m.Ambient) + } + expectedDrawFlag := DRAW_FLAG_GROUND_SHADOW | DRAW_FLAG_DRAWING_ON_SELF_SHADOW_MAPS | DRAW_FLAG_DRAWING_SELF_SHADOWS + if m.DrawFlag != expectedDrawFlag { + t.Errorf("Expected DrawFlag to be %v, got %v", expectedDrawFlag, m.DrawFlag) + } + expectedEdge := &mmath.MVec4{0.2745098, 0.09019607, 0.1254902, 1.0} + if !m.Edge.NearEquals(expectedEdge, 1e-5) { + t.Errorf("Expected Edge to be %v, got %v", expectedEdge, m.Edge) + } + expectedEdgeSize := 1.0 + if math.Abs(m.EdgeSize-expectedEdgeSize) > 1e-5 { + t.Errorf("Expected EdgeSize to be %v, got %v", expectedEdgeSize, m.EdgeSize) + } + expectedTextureIndex := 22 + if m.TextureIndex != expectedTextureIndex { + t.Errorf("Expected TextureIndex to be %v, got %v", expectedTextureIndex, m.TextureIndex) + } + expectedSphereTextureIndex := 4 + if m.SphereTextureIndex != expectedSphereTextureIndex { + t.Errorf("Expected SphereTextureIndex to be %v, got %v", expectedSphereTextureIndex, m.SphereTextureIndex) + } + expectedSphereMode := SPHERE_MODE_ADDITION + if m.SphereMode != expectedSphereMode { + t.Errorf("Expected SphereMode to be %v, got %v", expectedSphereMode, m.SphereMode) + } + expectedToonSharingFlag := TOON_SHARING_INDIVIDUAL + if m.ToonSharingFlag != expectedToonSharingFlag { + t.Errorf("Expected ToonSharingFlag to be %v, got %v", expectedToonSharingFlag, m.ToonSharingFlag) + } + expectedToonTextureIndex := 21 + if m.ToonTextureIndex != expectedToonTextureIndex { + t.Errorf("Expected ToonTextureIndex to be %v, got %v", expectedToonTextureIndex, m.ToonTextureIndex) + } + expectedMemo := "" + if m.Memo != expectedMemo { + t.Errorf("Expected Memo to be %v, got %v", expectedMemo, m.Memo) + } + expectedVerticesCount := 1584 + if m.VerticesCount != expectedVerticesCount { + t.Errorf("Expected VerticesCount to be %v, got %v", expectedVerticesCount, m.VerticesCount) + } + } + + { + b := model.Bones.Get(5) + expectedName := "上半身" + if b.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, b.Name) + } + expectedEnglishName := "J_Bip_C_Spine2" + if b.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, b.EnglishName) + } + expectedPosition := &mmath.MVec3{0.0, 12.39097, -0.2011687} + if !b.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, b.Position) + } + expectedParentBoneIndex := 3 + if b.ParentIndex != expectedParentBoneIndex { + t.Errorf("Expected ParentBoneIndex to be %v, got %v", expectedParentBoneIndex, b.ParentIndex) + } + expectedLayer := 0 + if b.Layer != expectedLayer { + t.Errorf("Expected Layer to be %v, got %v", expectedLayer, b.Layer) + } + expectedBoneFlag := BONE_FLAG_CAN_ROTATE | BONE_FLAG_IS_VISIBLE | BONE_FLAG_CAN_MANIPULATE | BONE_FLAG_TAIL_IS_BONE + if b.BoneFlag != expectedBoneFlag { + t.Errorf("Expected BoneFlag to be %v, got %v", expectedBoneFlag, b.BoneFlag) + } + expectedTailPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !b.TailPosition.MMD().NearEquals(expectedTailPosition, 1e-5) { + t.Errorf("Expected TailPosition to be %v, got %v", expectedTailPosition, b.TailPosition) + } + expectedTailIndex := 6 + if b.TailIndex != expectedTailIndex { + t.Errorf("Expected TailIndex to be %v, got %v", expectedTailIndex, b.TailIndex) + } + } + + { + b := model.Bones.Get(12) + expectedName := "右目" + if b.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, b.Name) + } + expectedEnglishName := "J_Adj_R_FaceEye" + if b.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, b.EnglishName) + } + expectedPosition := &mmath.MVec3{-0.1984593, 18.47478, 0.04549573} + if !b.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, b.Position) + } + expectedParentBoneIndex := 9 + if b.ParentIndex != expectedParentBoneIndex { + t.Errorf("Expected ParentBoneIndex to be %v, got %v", expectedParentBoneIndex, b.ParentIndex) + } + expectedLayer := 0 + if b.Layer != expectedLayer { + t.Errorf("Expected Layer to be %v, got %v", expectedLayer, b.Layer) + } + expectedBoneFlag := BONE_FLAG_CAN_ROTATE | BONE_FLAG_IS_VISIBLE | BONE_FLAG_CAN_MANIPULATE | BONE_FLAG_TAIL_IS_BONE | BONE_FLAG_IS_EXTERNAL_ROTATION + if b.BoneFlag != expectedBoneFlag { + t.Errorf("Expected BoneFlag to be %v, got %v", expectedBoneFlag, b.BoneFlag) + } + expectedTailPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !b.TailPosition.MMD().NearEquals(expectedTailPosition, 1e-5) { + t.Errorf("Expected TailPosition to be %v, got %v", expectedTailPosition, b.TailPosition) + } + expectedTailIndex := -1 + if b.TailIndex != expectedTailIndex { + t.Errorf("Expected TailIndex to be %v, got %v", expectedTailIndex, b.TailIndex) + } + expectedEffectBoneIndex := 10 + if b.EffectIndex != expectedEffectBoneIndex { + t.Errorf("Expected EffectorBoneIndex to be %v, got %v", expectedEffectBoneIndex, b.EffectIndex) + } + expectedEffectFactor := 0.3 + if math.Abs(b.EffectFactor-expectedEffectFactor) > 1e-5 { + t.Errorf("Expected EffectorBoneIndex to be %v, got %v", expectedEffectFactor, b.EffectFactor) + } + } + + { + b := model.Bones.Get(28) + expectedName := "左腕捩" + if b.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, b.Name) + } + expectedEnglishName := "arm_twist_L" + if b.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, b.EnglishName) + } + expectedPosition := &mmath.MVec3{2.482529, 15.52887, 0.3184027} + if !b.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, b.Position) + } + expectedParentBoneIndex := 27 + if b.ParentIndex != expectedParentBoneIndex { + t.Errorf("Expected ParentBoneIndex to be %v, got %v", expectedParentBoneIndex, b.ParentIndex) + } + expectedLayer := 0 + if b.Layer != expectedLayer { + t.Errorf("Expected Layer to be %v, got %v", expectedLayer, b.Layer) + } + expectedBoneFlag := BONE_FLAG_CAN_ROTATE | BONE_FLAG_IS_VISIBLE | BONE_FLAG_CAN_MANIPULATE | BONE_FLAG_TAIL_IS_BONE | BONE_FLAG_HAS_FIXED_AXIS | BONE_FLAG_HAS_LOCAL_AXIS + if b.BoneFlag != expectedBoneFlag { + t.Errorf("Expected BoneFlag to be %v, got %v", expectedBoneFlag, b.BoneFlag) + } + expectedTailPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !b.TailPosition.MMD().NearEquals(expectedTailPosition, 1e-5) { + t.Errorf("Expected TailPosition to be %v, got %v", expectedTailPosition, b.TailPosition) + } + expectedTailIndex := -1 + if b.TailIndex != expectedTailIndex { + t.Errorf("Expected TailIndex to be %v, got %v", expectedTailIndex, b.TailIndex) + } + expectedFixedAxis := &mmath.MVec3{0.819152, -0.5735764, -4.355049e-15} + if !b.FixedAxis.MMD().NearEquals(expectedFixedAxis, 1e-5) { + t.Errorf("Expected FixedAxis to be %v, got %v", expectedFixedAxis, b.FixedAxis) + } + expectedLocalAxisX := &mmath.MVec3{0.8191521, -0.5735765, -4.35505e-15} + if !b.LocalAxisX.MMD().NearEquals(expectedLocalAxisX, 1e-5) { + t.Errorf("Expected LocalAxisX to be %v, got %v", expectedLocalAxisX, b.LocalAxisX) + } + expectedLocalAxisZ := &mmath.MVec3{-3.567448e-15, 2.497953e-15, -1} + if !b.LocalAxisZ.MMD().NearEquals(expectedLocalAxisZ, 1e-5) { + t.Errorf("Expected LocalAxisZ to be %v, got %v", expectedLocalAxisZ, b.LocalAxisZ) + } + } + + { + b := model.Bones.Get(98) + expectedName := "左足ＩＫ" + if b.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, b.Name) + } + expectedEnglishName := "leg_IK_L" + if b.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, b.EnglishName) + } + expectedPosition := &mmath.MVec3{0.9644502, 1.647273, 0.4050385} + if !b.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, b.Position) + } + expectedParentBoneIndex := 97 + if b.ParentIndex != expectedParentBoneIndex { + t.Errorf("Expected ParentBoneIndex to be %v, got %v", expectedParentBoneIndex, b.ParentIndex) + } + expectedLayer := 0 + if b.Layer != expectedLayer { + t.Errorf("Expected Layer to be %v, got %v", expectedLayer, b.Layer) + } + expectedBoneFlag := BONE_FLAG_CAN_ROTATE | BONE_FLAG_IS_VISIBLE | BONE_FLAG_CAN_MANIPULATE | BONE_FLAG_IS_IK | BONE_FLAG_CAN_TRANSLATE + if b.BoneFlag != expectedBoneFlag { + t.Errorf("Expected BoneFlag to be %v, got %v", expectedBoneFlag, b.BoneFlag) + } + expectedTailPosition := &mmath.MVec3{0.0, 0.0, 1.0} + if !b.TailPosition.MMD().NearEquals(expectedTailPosition, 1e-5) { + t.Errorf("Expected TailPosition to be %v, got %v", expectedTailPosition, b.TailPosition) + } + expectedTailIndex := -1 + if b.TailIndex != expectedTailIndex { + t.Errorf("Expected TailIndex to be %v, got %v", expectedTailIndex, b.TailIndex) + } + expectedIkTargetBoneIndex := 95 + if b.Ik == nil || b.Ik.BoneIndex != expectedIkTargetBoneIndex { + t.Errorf("Expected IkTargetBoneIndex to be %v, got %v", expectedIkTargetBoneIndex, b.Ik.BoneIndex) + } + expectedIkLoopCount := 40 + if b.Ik == nil || b.Ik.LoopCount != expectedIkLoopCount { + t.Errorf("Expected IkLoopCount to be %v, got %v", expectedIkLoopCount, b.Ik.LoopCount) + } + expectedIkLimitedDegree := 57.29578 + if b.Ik == nil || math.Abs(b.Ik.UnitRotation.GetDegrees().GetX()-expectedIkLimitedDegree) > 1e-5 { + t.Errorf("Expected IkLimitedRadian to be %v, got %v", expectedIkLimitedDegree, b.Ik.UnitRotation.GetDegrees().GetX()) + } + if b.Ik != nil { + il := b.Ik.Links[0] + expectedLinkBoneIndex := 94 + if il.BoneIndex != expectedLinkBoneIndex { + t.Errorf("Expected LinkBoneIndex to be %v, got %v", expectedLinkBoneIndex, il.BoneIndex) + } + expectedAngleLimit := true + if il.AngleLimit != expectedAngleLimit { + t.Errorf("Expected AngleLimit to be %v, got %v", expectedAngleLimit, il.AngleLimit) + } + expectedMinAngleLimit := &mmath.MVec3{-180.0, 0.0, 0.0} + if !il.MinAngleLimit.GetDegrees().NearEquals(expectedMinAngleLimit, 1e-5) { + t.Errorf("Expected MinAngleLimit to be %v, got %v", expectedMinAngleLimit, il.MinAngleLimit.GetDegrees()) + } + expectedMaxAngleLimit := &mmath.MVec3{-0.5, 0.0, 0.0} + if !il.MaxAngleLimit.GetDegrees().NearEquals(expectedMaxAngleLimit, 1e-5) { + t.Errorf("Expected MaxAngleLimit to be %v, got %v", expectedMaxAngleLimit, il.MaxAngleLimit.GetDegrees()) + } + } + if b.Ik != nil { + il := b.Ik.Links[1] + expectedLinkBoneIndex := 93 + if il.BoneIndex != expectedLinkBoneIndex { + t.Errorf("Expected LinkBoneIndex to be %v, got %v", expectedLinkBoneIndex, il.BoneIndex) + } + expectedAngleLimit := false + if il.AngleLimit != expectedAngleLimit { + t.Errorf("Expected AngleLimit to be %v, got %v", expectedAngleLimit, il.AngleLimit) + } + } + } + + { + m := model.Morphs.Get(2) + expectedName := "にこり" + if m.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, m.Name) + } + expectedEnglishName := "Fcl_BRW_Fun" + if m.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, m.EnglishName) + } + expectedMorphType := MORPH_TYPE_VERTEX + if m.MorphType != expectedMorphType { + t.Errorf("Expected MorphType to be %v, got %v", expectedMorphType, m.MorphType) + } + expectedOffsetCount := 68 + if len(m.Offsets) != expectedOffsetCount { + t.Errorf("Expected OffsetCount to be %v, got %v", expectedOffsetCount, len(m.Offsets)) + } + { + o := m.Offsets[30].(*VertexMorphOffset) + expectedVertexIndex := 19329 + if o.VertexIndex != expectedVertexIndex { + t.Errorf("Expected VertexIndex to be %v, got %v", expectedVertexIndex, o.VertexIndex) + } + expectedPosition := &mmath.MVec3{-0.01209146, 0.1320038, -0.0121327} + if !o.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, o.Position) + } + } + } + + { + m := model.Morphs.Get(111) + expectedName := "いボーン" + if m.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, m.Name) + } + expectedEnglishName := "Fcl_MTH_I_Bone" + if m.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, m.EnglishName) + } + expectedMorphType := MORPH_TYPE_BONE + if m.MorphType != expectedMorphType { + t.Errorf("Expected MorphType to be %v, got %v", expectedMorphType, m.MorphType) + } + expectedOffsetCount := 3 + if len(m.Offsets) != expectedOffsetCount { + t.Errorf("Expected OffsetCount to be %v, got %v", expectedOffsetCount, len(m.Offsets)) + } + { + o := m.Offsets[1].(*BoneMorphOffset) + expectedBoneIndex := 17 + if o.BoneIndex != expectedBoneIndex { + t.Errorf("Expected BoneIndex to be %v, got %v", expectedBoneIndex, o.BoneIndex) + } + expectedPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !o.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected BoneIndex to be %v, got %v", expectedBoneIndex, o.BoneIndex) + } + expectedRotation := &mmath.MVec3{-6.000048, 3.952523e-14, -3.308919e-14} + if !o.Rotation.GetDegreesMMD().NearEquals(expectedRotation, 1e-5) { + t.Errorf("Expected Rotation to be %v, got %v", expectedRotation, o.Rotation.GetDegrees()) + } + } + } + + { + m := model.Morphs.Get(122) + expectedName := "なごみ材質" + if m.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, m.Name) + } + expectedEnglishName := "eye_Nagomi_Material" + if m.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, m.EnglishName) + } + expectedMorphType := MORPH_TYPE_MATERIAL + if m.MorphType != expectedMorphType { + t.Errorf("Expected MorphType to be %v, got %v", expectedMorphType, m.MorphType) + } + expectedOffsetCount := 4 + if len(m.Offsets) != expectedOffsetCount { + t.Errorf("Expected OffsetCount to be %v, got %v", expectedOffsetCount, len(m.Offsets)) + } + { + o := m.Offsets[3].(*MaterialMorphOffset) + expectedMaterialIndex := 12 + if o.MaterialIndex != expectedMaterialIndex { + t.Errorf("Expected MaterialIndex to be %v, got %v", expectedMaterialIndex, o.MaterialIndex) + } + expectedCalcMode := CALC_MODE_ADDITION + if o.CalcMode != expectedCalcMode { + t.Errorf("Expected CalcMode to be %v, got %v", expectedCalcMode, o.CalcMode) + } + expectedDiffuse := &mmath.MVec4{0.0, 0.0, 0.0, 1.0} + if !o.Diffuse.NearEquals(expectedDiffuse, 1e-5) { + t.Errorf("Expected Diffuse to be %v, got %v", expectedDiffuse, o.Diffuse) + } + expectedSpecular := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !o.Specular.NearEquals(expectedSpecular, 1e-5) { + t.Errorf("Expected Specular to be %v, got %v", expectedSpecular, o.Specular) + } + expectedAmbient := &mmath.MVec3{0.0, 0.0, 0.0} + if !o.Ambient.NearEquals(expectedAmbient, 1e-5) { + t.Errorf("Expected Ambient to be %v, got %v", expectedAmbient, o.Ambient) + } + expectedEdge := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !o.Edge.NearEquals(expectedEdge, 1e-5) { + t.Errorf("Expected Edge to be %v, got %v", expectedEdge, o.Edge) + } + expectedEdgeSize := 0.0 + if math.Abs(o.EdgeSize-expectedEdgeSize) > 1e-5 { + t.Errorf("Expected EdgeSize to be %v, got %v", expectedEdgeSize, o.EdgeSize) + } + expectedTextureFactor := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !o.TextureFactor.NearEquals(expectedTextureFactor, 1e-5) { + t.Errorf("Expected TextureFactor to be %v, got %v", expectedTextureFactor, o.TextureFactor) + } + expectedSphereTextureFactor := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !o.SphereTextureFactor.NearEquals(expectedSphereTextureFactor, 1e-5) { + t.Errorf("Expected SphereTextureFactor to be %v, got %v", expectedSphereTextureFactor, o.SphereTextureFactor) + } + expectedToonTextureFactor := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !o.ToonTextureFactor.NearEquals(expectedToonTextureFactor, 1e-5) { + t.Errorf("Expected ToonTextureFactor to be %v, got %v", expectedToonTextureFactor, o.ToonTextureFactor) + } + } + } + + { + m := model.Morphs.Get(137) + expectedName := "ひそめ" + if m.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, m.Name) + } + expectedEnglishName := "brow_Frown" + if m.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, m.EnglishName) + } + expectedMorphType := MORPH_TYPE_GROUP + if m.MorphType != expectedMorphType { + t.Errorf("Expected MorphType to be %v, got %v", expectedMorphType, m.MorphType) + } + expectedOffsetCount := 6 + if len(m.Offsets) != expectedOffsetCount { + t.Errorf("Expected OffsetCount to be %v, got %v", expectedOffsetCount, len(m.Offsets)) + } + { + o := m.Offsets[2].(*GroupMorphOffset) + expectedMorphIndex := 21 + if o.MorphIndex != expectedMorphIndex { + t.Errorf("Expected MorphIndex to be %v, got %v", expectedMorphIndex, o.MorphIndex) + } + expectedFactor := 0.3 + if math.Abs(o.MorphFactor-expectedFactor) > 1e-5 { + t.Errorf("Expected Factor to be %v, got %v", expectedFactor, o.MorphFactor) + } + } + } + + { + d := model.DisplaySlots.Get(0) + expectedName := "Root" + if d.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, d.Name) + } + expectedEnglishName := "Root" + if d.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, d.EnglishName) + } + expectedSpecialFlag := SPECIAL_FLAG_ON + if d.SpecialFlag != expectedSpecialFlag { + t.Errorf("Expected SpecialFlag to be %v, got %v", expectedSpecialFlag, d.SpecialFlag) + } + expectedReferenceCount := 1 + if len(d.References) != expectedReferenceCount { + t.Errorf("Expected ReferenceCount to be %v, got %v", expectedReferenceCount, len(d.References)) + } + { + r := d.References[0] + expectedDisplayType := DISPLAY_TYPE_BONE + if r.DisplayType != expectedDisplayType { + t.Errorf("Expected DisplayType to be %v, got %v", expectedDisplayType, r.DisplayType) + } + expectedIndex := 0 + if r.DisplayIndex != expectedIndex { + t.Errorf("Expected DisplayIndex to be %v, got %v", expectedIndex, r.DisplayIndex) + } + } + } + + { + d := model.DisplaySlots.Get(1) + expectedName := "表情" + if d.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, d.Name) + } + expectedEnglishName := "Exp" + if d.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, d.EnglishName) + } + expectedSpecialFlag := SPECIAL_FLAG_ON + if d.SpecialFlag != expectedSpecialFlag { + t.Errorf("Expected SpecialFlag to be %v, got %v", expectedSpecialFlag, d.SpecialFlag) + } + expectedReferenceCount := 143 + if len(d.References) != expectedReferenceCount { + t.Errorf("Expected ReferenceCount to be %v, got %v", expectedReferenceCount, len(d.References)) + } + { + r := d.References[50] + expectedDisplayType := DISPLAY_TYPE_MORPH + if r.DisplayType != expectedDisplayType { + t.Errorf("Expected DisplayType to be %v, got %v", expectedDisplayType, r.DisplayType) + } + expectedIndex := 142 + if r.DisplayIndex != expectedIndex { + t.Errorf("Expected DisplayIndex to be %v, got %v", expectedIndex, r.DisplayIndex) + } + } + } + + { + d := model.DisplaySlots.Get(9) + expectedName := "右指" + if d.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, d.Name) + } + expectedEnglishName := "right hand" + if d.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, d.EnglishName) + } + expectedSpecialFlag := SPECIAL_FLAG_OFF + if d.SpecialFlag != expectedSpecialFlag { + t.Errorf("Expected SpecialFlag to be %v, got %v", expectedSpecialFlag, d.SpecialFlag) + } + expectedReferenceCount := 15 + if len(d.References) != expectedReferenceCount { + t.Errorf("Expected ReferenceCount to be %v, got %v", expectedReferenceCount, len(d.References)) + } + { + r := d.References[7] + expectedDisplayType := DISPLAY_TYPE_BONE + if r.DisplayType != expectedDisplayType { + t.Errorf("Expected DisplayType to be %v, got %v", expectedDisplayType, r.DisplayType) + } + expectedIndex := 81 + if r.DisplayIndex != expectedIndex { + t.Errorf("Expected DisplayIndex to be %v, got %v", expectedIndex, r.DisplayIndex) + } + } + } + + { + b := model.RigidBodies.Get(14) + expectedName := "右腕" + if b.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, b.Name) + } + expectedEnglishName := "J_Bip_R_UpperArm" + if b.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, b.EnglishName) + } + expectedBoneIndex := 61 + if b.BoneIndex != expectedBoneIndex { + t.Errorf("Expected BoneIndex to be %v, got %v", expectedBoneIndex, b.BoneIndex) + } + expectedGroupIndex := byte(2) + if b.CollisionGroup != expectedGroupIndex { + t.Errorf("Expected GroupIndex to be %v, got %v", expectedGroupIndex, b.CollisionGroup) + } + expectedCollisionGroupMasks := []uint16{1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} + for i := 0; i < 16; i++ { + if b.CollisionGroupMask.IsCollisions[i] != expectedCollisionGroupMasks[i] { + t.Errorf("Expected CollisionGroupMask to be %v, got %v (%v)", expectedCollisionGroupMasks[i], b.CollisionGroupMask.IsCollisions[i], i) + } + } + expectedShapeType := SHAPE_CAPSULE + if b.ShapeType != expectedShapeType { + t.Errorf("Expected ShapeType to be %v, got %v", expectedShapeType, b.ShapeType) + } + expectedSize := &mmath.MVec3{0.5398922, 2.553789, 0.0} + if !b.Size.NearEquals(expectedSize, 1e-5) { + t.Errorf("Expected Size to be %v, got %v", expectedSize, b.Size) + } + expectedPosition := &mmath.MVec3{-2.52586, 15.45157, 0.241455} + if !b.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, b.Position) + } + expectedRotation := &mmath.MVec3{0.0, 0.0, 125.00} + if !b.Rotation.GetDegrees().NearEquals(expectedRotation, 1e-5) { + t.Errorf("Expected Rotation to be %v, got %v", expectedRotation, b.Rotation.GetDegrees()) + } + expectedMass := 1.0 + if math.Abs(b.RigidBodyParam.Mass-expectedMass) > 1e-5 { + t.Errorf("Expected Mass to be %v, got %v", expectedMass, b.RigidBodyParam.Mass) + } + expectedLinearDamping := 0.5 + if math.Abs(b.RigidBodyParam.LinearDamping-expectedLinearDamping) > 1e-5 { + t.Errorf("Expected LinearDamping to be %v, got %v", expectedLinearDamping, b.RigidBodyParam.LinearDamping) + } + expectedAngularDamping := 0.5 + if math.Abs(b.RigidBodyParam.AngularDamping-expectedAngularDamping) > 1e-5 { + t.Errorf("Expected AngularDamping to be %v, got %v", expectedAngularDamping, b.RigidBodyParam.AngularDamping) + } + expectedRestitution := 0.0 + if math.Abs(b.RigidBodyParam.Restitution-expectedRestitution) > 1e-5 { + t.Errorf("Expected Restitution to be %v, got %v", expectedRestitution, b.RigidBodyParam.Restitution) + } + expectedFriction := 0.0 + if math.Abs(b.RigidBodyParam.Friction-expectedFriction) > 1e-5 { + t.Errorf("Expected Friction to be %v, got %v", expectedFriction, b.RigidBodyParam.Friction) + } + expectedPhysicsType := PHYSICS_TYPE_STATIC + if b.PhysicsType != expectedPhysicsType { + t.Errorf("Expected PhysicsType to be %v, got %v", expectedPhysicsType, b.PhysicsType) + } + } + + { + j := model.Joints.Get(13) + expectedName := "↓|頭|髪_06-01" + if j.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, j.Name) + } + expectedEnglishName := "↓|頭|髪_06-01" + if j.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, j.EnglishName) + } + expectedRigidBodyIndexA := 5 + if j.RigidbodyIndexA != expectedRigidBodyIndexA { + t.Errorf("Expected RigidBodyIndexA to be %v, got %v", expectedRigidBodyIndexA, j.RigidbodyIndexA) + } + expectedRigidBodyIndexB := 45 + if j.RigidbodyIndexB != expectedRigidBodyIndexB { + t.Errorf("Expected RigidBodyIndexB to be %v, got %v", expectedRigidBodyIndexB, j.RigidbodyIndexB) + } + expectedPosition := &mmath.MVec3{-1.189768, 18.56266, 0.07277258} + if !j.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, j.Position) + } + expectedRotation := &mmath.MVec3{-15.10554, 91.26718, -4.187446} + if !j.Rotation.GetDegrees().NearEquals(expectedRotation, 1e-5) { + t.Errorf("Expected Rotation to be %v, got %v", expectedRotation, j.Rotation.GetDegrees()) + } + expectedTranslationLimitMin := &mmath.MVec3{0.0, 0.0, 0.0} + if !j.JointParam.TranslationLimitMin.NearEquals(expectedTranslationLimitMin, 1e-5) { + t.Errorf("Expected TranslationLimitation1 to be %v, got %v", expectedTranslationLimitMin, j.JointParam.TranslationLimitMin) + } + expectedTranslationLimitMax := &mmath.MVec3{0.0, 0.0, 0.0} + if !j.JointParam.TranslationLimitMax.NearEquals(expectedTranslationLimitMax, 1e-5) { + t.Errorf("Expected TranslationLimitation2 to be %v, got %v", expectedTranslationLimitMax, j.JointParam.TranslationLimitMax) + } + expectedRotationLimitMin := &mmath.MVec3{-29.04, -14.3587, -29.04} + if !j.JointParam.RotationLimitMin.GetDegrees().NearEquals(expectedRotationLimitMin, 1e-5) { + t.Errorf("Expected RotationLimitation1 to be %v, got %v", expectedRotationLimitMin, j.JointParam.RotationLimitMin.GetDegrees()) + } + expectedRotationLimitMax := &mmath.MVec3{29.04, 14.3587, 29.04} + if !j.JointParam.RotationLimitMax.GetDegrees().NearEquals(expectedRotationLimitMax, 1e-5) { + t.Errorf("Expected RotationLimitation2 to be %v, got %v", expectedRotationLimitMax, j.JointParam.RotationLimitMax.GetDegrees()) + } + expectedSpringConstantTranslation := &mmath.MVec3{0.0, 0.0, 0.0} + if !j.JointParam.SpringConstantTranslation.NearEquals(expectedSpringConstantTranslation, 1e-5) { + t.Errorf("Expected SpringConstantTranslation to be %v, got %v", expectedSpringConstantTranslation, j.JointParam.SpringConstantTranslation) + } + expectedSpringConstantRotation := &mmath.MVec3{60.0, 29.6667, 60.0} + if !j.JointParam.SpringConstantRotation.GetRadians().NearEquals(expectedSpringConstantRotation, 1e-5) { + t.Errorf("Expected SpringConstantRotation to be %v, got %v", expectedSpringConstantRotation, j.JointParam.SpringConstantRotation) + } + } +} + +func TestPmxReader_ReadByFilepath_2_1(t *testing.T) { + r := &PmxReader{} + + data, err := r.ReadByFilepath("../../test_resources/サンプルモデル_PMX2.1_UTF-8.pmx") + model := data.(*PmxModel) + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + expectedSignature := "PMX " + if model.Signature != expectedSignature { + t.Errorf("Expected Signature to be %q, got %q", expectedSignature, model.Signature) + } + + expectedVersion := 2.1 + if math.Abs(model.Version-expectedVersion) > 1e-5 { + t.Errorf("Expected Version to be %.8f, got %.8f", expectedVersion, model.Version) + } + + expectedName := "サンプルモデル迪卢克" + if model.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, model.Name) + } +} diff --git a/pkg/pmx/pmx_writer.go b/pkg/pmx/pmx_writer.go new file mode 100644 index 00000000..5ba80921 --- /dev/null +++ b/pkg/pmx/pmx_writer.go @@ -0,0 +1,1258 @@ +package pmx + +import ( + "bytes" + "encoding/binary" + "fmt" + "math" + "os" + "unicode/utf16" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" +) + +type pmxBinaryType string + +const ( + pmxBinaryType_float pmxBinaryType = " 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[0], v.Deform.GetAllWeights()[0]) + } + if math.Abs(v.Deform.GetAllWeights()[1]-expectedDeform.Weights[1]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[1], v.Deform.GetAllWeights()[1]) + } + if math.Abs(v.Deform.GetAllWeights()[2]-expectedDeform.Weights[2]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[2], v.Deform.GetAllWeights()[2]) + } + if math.Abs(v.Deform.GetAllWeights()[3]-expectedDeform.Weights[3]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[3], v.Deform.GetAllWeights()[3]) + } + expectedEdgeFactor := 1.0 + if math.Abs(v.EdgeFactor-expectedEdgeFactor) > 1e-5 { + t.Errorf("Expected EdgeFactor to be %v, got %v", expectedEdgeFactor, v.EdgeFactor) + } + } + + { + v := model.Vertices.Get(120) + expectedPosition := &mmath.MVec3{1.529492, 5.757646, 0.4527041} + if !v.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, v.Position) + } + expectedNormal := &mmath.MVec3{0.9943396, 0.1054612, -0.0129031} + if !v.Normal.MMD().NearEquals(expectedNormal, 1e-5) { + t.Errorf("Expected Normal to be %v, got %v", expectedNormal, v.Normal) + } + expectedUV := &mmath.MVec2{0.8788766, 0.7697825} + if !v.Uv.NearEquals(expectedUV, 1e-5) { + t.Errorf("Expected UV to be %v, got %v", expectedUV, v.Uv) + } + expectedDeformType := BDEF2 + if v.DeformType != expectedDeformType { + t.Errorf("Expected DeformType to be %d, got %d", expectedDeformType, v.DeformType) + } + expectedDeform := NewBdef2(109, 108, 0.9845969) + if v.Deform.GetAllIndexes()[0] != expectedDeform.Indexes[0] { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Indexes[0], v.Deform.GetAllIndexes()[0]) + } + if v.Deform.GetAllIndexes()[1] != expectedDeform.Indexes[1] { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Indexes[1], v.Deform.GetAllIndexes()[1]) + } + if math.Abs(v.Deform.GetAllWeights()[0]-expectedDeform.Weights[0]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[0], v.Deform.GetAllWeights()[0]) + } + if math.Abs(v.Deform.GetAllWeights()[1]-expectedDeform.Weights[1]) > 1e-5 { + t.Errorf("Expected Deform to be %v, got %v", expectedDeform.Weights[1], v.Deform.GetAllWeights()[1]) + } + expectedEdgeFactor := 1.0 + if math.Abs(v.EdgeFactor-expectedEdgeFactor) > 1e-5 { + t.Errorf("Expected EdgeFactor to be %v, got %v", expectedEdgeFactor, v.EdgeFactor) + } + } + + { + f := model.Faces.Get(19117) + expectedFaceVertexIndexes := []int{8857, 8893, 8871} + if f.VertexIndexes[0] != expectedFaceVertexIndexes[0] { + t.Errorf("Expected Deform to be %v, got %v", expectedFaceVertexIndexes[0], f.VertexIndexes[0]) + } + if f.VertexIndexes[1] != expectedFaceVertexIndexes[1] { + t.Errorf("Expected Deform to be %v, got %v", expectedFaceVertexIndexes[1], f.VertexIndexes[1]) + } + if f.VertexIndexes[2] != expectedFaceVertexIndexes[2] { + t.Errorf("Expected Deform to be %v, got %v", expectedFaceVertexIndexes[2], f.VertexIndexes[2]) + } + } + + { + tex := model.Textures.Get(10) + expectedName := "tex\\_13_Toon.bmp" + if tex.Name != expectedName { + t.Errorf("Expected Path to be %q, got %q", expectedName, tex.Name) + } + } + + { + m := model.Materials.Get(10) + expectedName := "00_EyeWhite_はぅ" + if m.Name != expectedName { + t.Errorf("Expected Path to be %q, got %q", expectedName, m.Name) + } + expectedEnglishName := "N00_000_00_EyeWhite_00_EYE (Instance)_Hau" + if m.EnglishName != expectedEnglishName { + t.Errorf("Expected Path to be %q, got %q", expectedEnglishName, m.EnglishName) + } + expectedDiffuse := &mmath.MVec4{1.0, 1.0, 1.0, 0.0} + if !m.Diffuse.NearEquals(expectedDiffuse, 1e-5) { + t.Errorf("Expected Diffuse to be %v, got %v", expectedDiffuse, m.Diffuse) + } + expectedSpecular := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !m.Specular.NearEquals(expectedSpecular, 1e-5) { + t.Errorf("Expected Specular to be %v, got %v", expectedSpecular, m.Specular) + } + expectedAmbient := &mmath.MVec3{0.5, 0.5, 0.5} + if !m.Ambient.NearEquals(expectedAmbient, 1e-5) { + t.Errorf("Expected Ambient to be %v, got %v", expectedAmbient, m.Ambient) + } + expectedDrawFlag := DRAW_FLAG_GROUND_SHADOW | DRAW_FLAG_DRAWING_ON_SELF_SHADOW_MAPS | DRAW_FLAG_DRAWING_SELF_SHADOWS + if m.DrawFlag != expectedDrawFlag { + t.Errorf("Expected DrawFlag to be %v, got %v", expectedDrawFlag, m.DrawFlag) + } + expectedEdge := &mmath.MVec4{0.2745098, 0.09019607, 0.1254902, 1.0} + if !m.Edge.NearEquals(expectedEdge, 1e-5) { + t.Errorf("Expected Edge to be %v, got %v", expectedEdge, m.Edge) + } + expectedEdgeSize := 1.0 + if math.Abs(m.EdgeSize-expectedEdgeSize) > 1e-5 { + t.Errorf("Expected EdgeSize to be %v, got %v", expectedEdgeSize, m.EdgeSize) + } + expectedTextureIndex := 22 + if m.TextureIndex != expectedTextureIndex { + t.Errorf("Expected TextureIndex to be %v, got %v", expectedTextureIndex, m.TextureIndex) + } + expectedSphereTextureIndex := 4 + if m.SphereTextureIndex != expectedSphereTextureIndex { + t.Errorf("Expected SphereTextureIndex to be %v, got %v", expectedSphereTextureIndex, m.SphereTextureIndex) + } + expectedSphereMode := SPHERE_MODE_ADDITION + if m.SphereMode != expectedSphereMode { + t.Errorf("Expected SphereMode to be %v, got %v", expectedSphereMode, m.SphereMode) + } + expectedToonSharingFlag := TOON_SHARING_INDIVIDUAL + if m.ToonSharingFlag != expectedToonSharingFlag { + t.Errorf("Expected ToonSharingFlag to be %v, got %v", expectedToonSharingFlag, m.ToonSharingFlag) + } + expectedToonTextureIndex := 21 + if m.ToonTextureIndex != expectedToonTextureIndex { + t.Errorf("Expected ToonTextureIndex to be %v, got %v", expectedToonTextureIndex, m.ToonTextureIndex) + } + expectedMemo := "" + if m.Memo != expectedMemo { + t.Errorf("Expected Memo to be %v, got %v", expectedMemo, m.Memo) + } + expectedVerticesCount := 1584 + if m.VerticesCount != expectedVerticesCount { + t.Errorf("Expected VerticesCount to be %v, got %v", expectedVerticesCount, m.VerticesCount) + } + } + + { + b := model.Bones.Get(5) + expectedName := "上半身" + if b.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, b.Name) + } + expectedEnglishName := "J_Bip_C_Spine2" + if b.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, b.EnglishName) + } + expectedPosition := &mmath.MVec3{0.0, 12.39097, -0.2011687} + if !b.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, b.Position) + } + expectedParentBoneIndex := 3 + if b.ParentIndex != expectedParentBoneIndex { + t.Errorf("Expected ParentBoneIndex to be %v, got %v", expectedParentBoneIndex, b.ParentIndex) + } + expectedLayer := 0 + if b.Layer != expectedLayer { + t.Errorf("Expected Layer to be %v, got %v", expectedLayer, b.Layer) + } + expectedBoneFlag := BONE_FLAG_CAN_ROTATE | BONE_FLAG_IS_VISIBLE | BONE_FLAG_CAN_MANIPULATE | BONE_FLAG_TAIL_IS_BONE + if b.BoneFlag != expectedBoneFlag { + t.Errorf("Expected BoneFlag to be %v, got %v", expectedBoneFlag, b.BoneFlag) + } + expectedTailPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !b.TailPosition.MMD().NearEquals(expectedTailPosition, 1e-5) { + t.Errorf("Expected TailPosition to be %v, got %v", expectedTailPosition, b.TailPosition) + } + expectedTailIndex := 6 + if b.TailIndex != expectedTailIndex { + t.Errorf("Expected TailIndex to be %v, got %v", expectedTailIndex, b.TailIndex) + } + } + + { + b := model.Bones.Get(12) + expectedName := "右目" + if b.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, b.Name) + } + expectedEnglishName := "J_Adj_R_FaceEye" + if b.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, b.EnglishName) + } + expectedPosition := &mmath.MVec3{-0.1984593, 18.47478, 0.04549573} + if !b.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, b.Position) + } + expectedParentBoneIndex := 9 + if b.ParentIndex != expectedParentBoneIndex { + t.Errorf("Expected ParentBoneIndex to be %v, got %v", expectedParentBoneIndex, b.ParentIndex) + } + expectedLayer := 0 + if b.Layer != expectedLayer { + t.Errorf("Expected Layer to be %v, got %v", expectedLayer, b.Layer) + } + expectedBoneFlag := BONE_FLAG_CAN_ROTATE | BONE_FLAG_IS_VISIBLE | BONE_FLAG_CAN_MANIPULATE | BONE_FLAG_TAIL_IS_BONE | BONE_FLAG_IS_EXTERNAL_ROTATION + if b.BoneFlag != expectedBoneFlag { + t.Errorf("Expected BoneFlag to be %v, got %v", expectedBoneFlag, b.BoneFlag) + } + expectedTailPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !b.TailPosition.MMD().NearEquals(expectedTailPosition, 1e-5) { + t.Errorf("Expected TailPosition to be %v, got %v", expectedTailPosition, b.TailPosition) + } + expectedTailIndex := -1 + if b.TailIndex != expectedTailIndex { + t.Errorf("Expected TailIndex to be %v, got %v", expectedTailIndex, b.TailIndex) + } + expectedEffectBoneIndex := 10 + if b.EffectIndex != expectedEffectBoneIndex { + t.Errorf("Expected EffectorBoneIndex to be %v, got %v", expectedEffectBoneIndex, b.EffectIndex) + } + expectedEffectFactor := 0.3 + if math.Abs(b.EffectFactor-expectedEffectFactor) > 1e-5 { + t.Errorf("Expected EffectorBoneIndex to be %v, got %v", expectedEffectFactor, b.EffectFactor) + } + } + + { + b := model.Bones.Get(28) + expectedName := "左腕捩" + if b.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, b.Name) + } + expectedEnglishName := "arm_twist_L" + if b.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, b.EnglishName) + } + expectedPosition := &mmath.MVec3{2.482529, 15.52887, 0.3184027} + if !b.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, b.Position) + } + expectedParentBoneIndex := 27 + if b.ParentIndex != expectedParentBoneIndex { + t.Errorf("Expected ParentBoneIndex to be %v, got %v", expectedParentBoneIndex, b.ParentIndex) + } + expectedLayer := 0 + if b.Layer != expectedLayer { + t.Errorf("Expected Layer to be %v, got %v", expectedLayer, b.Layer) + } + expectedBoneFlag := BONE_FLAG_CAN_ROTATE | BONE_FLAG_IS_VISIBLE | BONE_FLAG_CAN_MANIPULATE | BONE_FLAG_TAIL_IS_BONE | BONE_FLAG_HAS_FIXED_AXIS | BONE_FLAG_HAS_LOCAL_AXIS + if b.BoneFlag != expectedBoneFlag { + t.Errorf("Expected BoneFlag to be %v, got %v", expectedBoneFlag, b.BoneFlag) + } + expectedTailPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !b.TailPosition.MMD().NearEquals(expectedTailPosition, 1e-5) { + t.Errorf("Expected TailPosition to be %v, got %v", expectedTailPosition, b.TailPosition) + } + expectedTailIndex := -1 + if b.TailIndex != expectedTailIndex { + t.Errorf("Expected TailIndex to be %v, got %v", expectedTailIndex, b.TailIndex) + } + expectedFixedAxis := &mmath.MVec3{0.819152, -0.5735764, -4.355049e-15} + if !b.FixedAxis.MMD().NearEquals(expectedFixedAxis, 1e-5) { + t.Errorf("Expected FixedAxis to be %v, got %v", expectedFixedAxis, b.FixedAxis) + } + expectedLocalAxisX := &mmath.MVec3{0.8191521, -0.5735765, -4.35505e-15} + if !b.LocalAxisX.MMD().NearEquals(expectedLocalAxisX, 1e-5) { + t.Errorf("Expected LocalAxisX to be %v, got %v", expectedLocalAxisX, b.LocalAxisX) + } + expectedLocalAxisZ := &mmath.MVec3{-3.567448e-15, 2.497953e-15, -1} + if !b.LocalAxisZ.MMD().NearEquals(expectedLocalAxisZ, 1e-5) { + t.Errorf("Expected LocalAxisZ to be %v, got %v", expectedLocalAxisZ, b.LocalAxisZ) + } + } + + { + b := model.Bones.Get(98) + expectedName := "左足ＩＫ" + if b.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, b.Name) + } + expectedEnglishName := "leg_IK_L" + if b.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, b.EnglishName) + } + expectedPosition := &mmath.MVec3{0.9644502, 1.647273, 0.4050385} + if !b.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, b.Position) + } + expectedParentBoneIndex := 97 + if b.ParentIndex != expectedParentBoneIndex { + t.Errorf("Expected ParentBoneIndex to be %v, got %v", expectedParentBoneIndex, b.ParentIndex) + } + expectedLayer := 0 + if b.Layer != expectedLayer { + t.Errorf("Expected Layer to be %v, got %v", expectedLayer, b.Layer) + } + expectedBoneFlag := BONE_FLAG_CAN_ROTATE | BONE_FLAG_IS_VISIBLE | BONE_FLAG_CAN_MANIPULATE | BONE_FLAG_IS_IK | BONE_FLAG_CAN_TRANSLATE + if b.BoneFlag != expectedBoneFlag { + t.Errorf("Expected BoneFlag to be %v, got %v", expectedBoneFlag, b.BoneFlag) + } + expectedTailPosition := &mmath.MVec3{0.0, 0.0, 1.0} + if !b.TailPosition.MMD().NearEquals(expectedTailPosition, 1e-5) { + t.Errorf("Expected TailPosition to be %v, got %v", expectedTailPosition, b.TailPosition) + } + expectedTailIndex := -1 + if b.TailIndex != expectedTailIndex { + t.Errorf("Expected TailIndex to be %v, got %v", expectedTailIndex, b.TailIndex) + } + expectedIkTargetBoneIndex := 95 + if b.Ik == nil || b.Ik.BoneIndex != expectedIkTargetBoneIndex { + t.Errorf("Expected IkTargetBoneIndex to be %v, got %v", expectedIkTargetBoneIndex, b.Ik.BoneIndex) + } + expectedIkLoopCount := 40 + if b.Ik == nil || b.Ik.LoopCount != expectedIkLoopCount { + t.Errorf("Expected IkLoopCount to be %v, got %v", expectedIkLoopCount, b.Ik.LoopCount) + } + expectedIkLimitedDegree := 57.29578 + if b.Ik == nil || math.Abs(b.Ik.UnitRotation.GetDegrees().GetX()-expectedIkLimitedDegree) > 1e-5 { + t.Errorf("Expected IkLimitedRadian to be %v, got %v", expectedIkLimitedDegree, b.Ik.UnitRotation.GetDegrees().GetX()) + } + if b.Ik != nil { + il := b.Ik.Links[0] + expectedLinkBoneIndex := 94 + if il.BoneIndex != expectedLinkBoneIndex { + t.Errorf("Expected LinkBoneIndex to be %v, got %v", expectedLinkBoneIndex, il.BoneIndex) + } + expectedAngleLimit := true + if il.AngleLimit != expectedAngleLimit { + t.Errorf("Expected AngleLimit to be %v, got %v", expectedAngleLimit, il.AngleLimit) + } + expectedMinAngleLimit := &mmath.MVec3{-180.0, 0.0, 0.0} + if !il.MinAngleLimit.GetDegrees().NearEquals(expectedMinAngleLimit, 1e-5) { + t.Errorf("Expected MinAngleLimit to be %v, got %v", expectedMinAngleLimit, il.MinAngleLimit.GetDegrees()) + } + expectedMaxAngleLimit := &mmath.MVec3{-0.5, 0.0, 0.0} + if !il.MaxAngleLimit.GetDegrees().NearEquals(expectedMaxAngleLimit, 1e-5) { + t.Errorf("Expected MaxAngleLimit to be %v, got %v", expectedMaxAngleLimit, il.MaxAngleLimit.GetDegrees()) + } + } + if b.Ik != nil { + il := b.Ik.Links[1] + expectedLinkBoneIndex := 93 + if il.BoneIndex != expectedLinkBoneIndex { + t.Errorf("Expected LinkBoneIndex to be %v, got %v", expectedLinkBoneIndex, il.BoneIndex) + } + expectedAngleLimit := false + if il.AngleLimit != expectedAngleLimit { + t.Errorf("Expected AngleLimit to be %v, got %v", expectedAngleLimit, il.AngleLimit) + } + } + } + + { + m := model.Morphs.Get(2) + expectedName := "にこり" + if m.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, m.Name) + } + expectedEnglishName := "Fcl_BRW_Fun" + if m.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, m.EnglishName) + } + expectedMorphType := MORPH_TYPE_VERTEX + if m.MorphType != expectedMorphType { + t.Errorf("Expected MorphType to be %v, got %v", expectedMorphType, m.MorphType) + } + expectedOffsetCount := 68 + if len(m.Offsets) != expectedOffsetCount { + t.Errorf("Expected OffsetCount to be %v, got %v", expectedOffsetCount, len(m.Offsets)) + } + { + o := m.Offsets[30].(*VertexMorphOffset) + expectedVertexIndex := 19329 + if o.VertexIndex != expectedVertexIndex { + t.Errorf("Expected VertexIndex to be %v, got %v", expectedVertexIndex, o.VertexIndex) + } + expectedPosition := &mmath.MVec3{-0.01209146, 0.1320038, -0.0121327} + if !o.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, o.Position) + } + } + } + + { + m := model.Morphs.Get(111) + expectedName := "いボーン" + if m.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, m.Name) + } + expectedEnglishName := "Fcl_MTH_I_Bone" + if m.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, m.EnglishName) + } + expectedMorphType := MORPH_TYPE_BONE + if m.MorphType != expectedMorphType { + t.Errorf("Expected MorphType to be %v, got %v", expectedMorphType, m.MorphType) + } + expectedOffsetCount := 3 + if len(m.Offsets) != expectedOffsetCount { + t.Errorf("Expected OffsetCount to be %v, got %v", expectedOffsetCount, len(m.Offsets)) + } + { + o := m.Offsets[1].(*BoneMorphOffset) + expectedBoneIndex := 17 + if o.BoneIndex != expectedBoneIndex { + t.Errorf("Expected BoneIndex to be %v, got %v", expectedBoneIndex, o.BoneIndex) + } + expectedPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !o.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected BoneIndex to be %v, got %v", expectedBoneIndex, o.BoneIndex) + } + expectedRotation := &mmath.MVec3{-6.000048, 3.952523e-14, -3.308919e-14} + if !o.Rotation.GetDegreesMMD().NearEquals(expectedRotation, 1e-5) { + t.Errorf("Expected Rotation to be %v, got %v", expectedRotation, o.Rotation.GetDegrees()) + } + } + } + + { + m := model.Morphs.Get(122) + expectedName := "なごみ材質" + if m.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, m.Name) + } + expectedEnglishName := "eye_Nagomi_Material" + if m.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, m.EnglishName) + } + expectedMorphType := MORPH_TYPE_MATERIAL + if m.MorphType != expectedMorphType { + t.Errorf("Expected MorphType to be %v, got %v", expectedMorphType, m.MorphType) + } + expectedOffsetCount := 4 + if len(m.Offsets) != expectedOffsetCount { + t.Errorf("Expected OffsetCount to be %v, got %v", expectedOffsetCount, len(m.Offsets)) + } + { + o := m.Offsets[3].(*MaterialMorphOffset) + expectedMaterialIndex := 12 + if o.MaterialIndex != expectedMaterialIndex { + t.Errorf("Expected MaterialIndex to be %v, got %v", expectedMaterialIndex, o.MaterialIndex) + } + expectedCalcMode := CALC_MODE_ADDITION + if o.CalcMode != expectedCalcMode { + t.Errorf("Expected CalcMode to be %v, got %v", expectedCalcMode, o.CalcMode) + } + expectedDiffuse := &mmath.MVec4{0.0, 0.0, 0.0, 1.0} + if !o.Diffuse.NearEquals(expectedDiffuse, 1e-5) { + t.Errorf("Expected Diffuse to be %v, got %v", expectedDiffuse, o.Diffuse) + } + expectedSpecular := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !o.Specular.NearEquals(expectedSpecular, 1e-5) { + t.Errorf("Expected Specular to be %v, got %v", expectedSpecular, o.Specular) + } + expectedAmbient := &mmath.MVec3{0.0, 0.0, 0.0} + if !o.Ambient.NearEquals(expectedAmbient, 1e-5) { + t.Errorf("Expected Ambient to be %v, got %v", expectedAmbient, o.Ambient) + } + expectedEdge := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !o.Edge.NearEquals(expectedEdge, 1e-5) { + t.Errorf("Expected Edge to be %v, got %v", expectedEdge, o.Edge) + } + expectedEdgeSize := 0.0 + if math.Abs(o.EdgeSize-expectedEdgeSize) > 1e-5 { + t.Errorf("Expected EdgeSize to be %v, got %v", expectedEdgeSize, o.EdgeSize) + } + expectedTextureFactor := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !o.TextureFactor.NearEquals(expectedTextureFactor, 1e-5) { + t.Errorf("Expected TextureFactor to be %v, got %v", expectedTextureFactor, o.TextureFactor) + } + expectedSphereTextureFactor := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !o.SphereTextureFactor.NearEquals(expectedSphereTextureFactor, 1e-5) { + t.Errorf("Expected SphereTextureFactor to be %v, got %v", expectedSphereTextureFactor, o.SphereTextureFactor) + } + expectedToonTextureFactor := &mmath.MVec4{0.0, 0.0, 0.0, 0.0} + if !o.ToonTextureFactor.NearEquals(expectedToonTextureFactor, 1e-5) { + t.Errorf("Expected ToonTextureFactor to be %v, got %v", expectedToonTextureFactor, o.ToonTextureFactor) + } + } + } + + { + m := model.Morphs.Get(137) + expectedName := "ひそめ" + if m.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, m.Name) + } + expectedEnglishName := "brow_Frown" + if m.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, m.EnglishName) + } + expectedMorphType := MORPH_TYPE_GROUP + if m.MorphType != expectedMorphType { + t.Errorf("Expected MorphType to be %v, got %v", expectedMorphType, m.MorphType) + } + expectedOffsetCount := 6 + if len(m.Offsets) != expectedOffsetCount { + t.Errorf("Expected OffsetCount to be %v, got %v", expectedOffsetCount, len(m.Offsets)) + } + { + o := m.Offsets[2].(*GroupMorphOffset) + expectedMorphIndex := 21 + if o.MorphIndex != expectedMorphIndex { + t.Errorf("Expected MorphIndex to be %v, got %v", expectedMorphIndex, o.MorphIndex) + } + expectedFactor := 0.3 + if math.Abs(o.MorphFactor-expectedFactor) > 1e-5 { + t.Errorf("Expected Factor to be %v, got %v", expectedFactor, o.MorphFactor) + } + } + } + + { + d := model.DisplaySlots.Get(0) + expectedName := "Root" + if d.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, d.Name) + } + expectedEnglishName := "Root" + if d.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, d.EnglishName) + } + expectedSpecialFlag := SPECIAL_FLAG_ON + if d.SpecialFlag != expectedSpecialFlag { + t.Errorf("Expected SpecialFlag to be %v, got %v", expectedSpecialFlag, d.SpecialFlag) + } + expectedReferenceCount := 1 + if len(d.References) != expectedReferenceCount { + t.Errorf("Expected ReferenceCount to be %v, got %v", expectedReferenceCount, len(d.References)) + } + { + r := d.References[0] + expectedDisplayType := DISPLAY_TYPE_BONE + if r.DisplayType != expectedDisplayType { + t.Errorf("Expected DisplayType to be %v, got %v", expectedDisplayType, r.DisplayType) + } + expectedIndex := 0 + if r.DisplayIndex != expectedIndex { + t.Errorf("Expected DisplayIndex to be %v, got %v", expectedIndex, r.DisplayIndex) + } + } + } + + { + d := model.DisplaySlots.Get(1) + expectedName := "表情" + if d.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, d.Name) + } + expectedEnglishName := "Exp" + if d.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, d.EnglishName) + } + expectedSpecialFlag := SPECIAL_FLAG_ON + if d.SpecialFlag != expectedSpecialFlag { + t.Errorf("Expected SpecialFlag to be %v, got %v", expectedSpecialFlag, d.SpecialFlag) + } + expectedReferenceCount := 143 + if len(d.References) != expectedReferenceCount { + t.Errorf("Expected ReferenceCount to be %v, got %v", expectedReferenceCount, len(d.References)) + } + { + r := d.References[50] + expectedDisplayType := DISPLAY_TYPE_MORPH + if r.DisplayType != expectedDisplayType { + t.Errorf("Expected DisplayType to be %v, got %v", expectedDisplayType, r.DisplayType) + } + expectedIndex := 142 + if r.DisplayIndex != expectedIndex { + t.Errorf("Expected DisplayIndex to be %v, got %v", expectedIndex, r.DisplayIndex) + } + } + } + + { + d := model.DisplaySlots.Get(9) + expectedName := "右指" + if d.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, d.Name) + } + expectedEnglishName := "right hand" + if d.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, d.EnglishName) + } + expectedSpecialFlag := SPECIAL_FLAG_OFF + if d.SpecialFlag != expectedSpecialFlag { + t.Errorf("Expected SpecialFlag to be %v, got %v", expectedSpecialFlag, d.SpecialFlag) + } + expectedReferenceCount := 15 + if len(d.References) != expectedReferenceCount { + t.Errorf("Expected ReferenceCount to be %v, got %v", expectedReferenceCount, len(d.References)) + } + { + r := d.References[7] + expectedDisplayType := DISPLAY_TYPE_BONE + if r.DisplayType != expectedDisplayType { + t.Errorf("Expected DisplayType to be %v, got %v", expectedDisplayType, r.DisplayType) + } + expectedIndex := 81 + if r.DisplayIndex != expectedIndex { + t.Errorf("Expected DisplayIndex to be %v, got %v", expectedIndex, r.DisplayIndex) + } + } + } + + { + b := model.RigidBodies.Get(14) + expectedName := "右腕" + if b.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, b.Name) + } + expectedEnglishName := "J_Bip_R_UpperArm" + if b.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, b.EnglishName) + } + expectedBoneIndex := 61 + if b.BoneIndex != expectedBoneIndex { + t.Errorf("Expected BoneIndex to be %v, got %v", expectedBoneIndex, b.BoneIndex) + } + expectedGroupIndex := byte(2) + if b.CollisionGroup != expectedGroupIndex { + t.Errorf("Expected GroupIndex to be %v, got %v", expectedGroupIndex, b.CollisionGroup) + } + expectedCollisionGroupMasks := []uint16{1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} + for i := 0; i < 16; i++ { + if b.CollisionGroupMask.IsCollisions[i] != expectedCollisionGroupMasks[i] { + t.Errorf("Expected CollisionGroupMask to be %v, got %v (%v)", expectedCollisionGroupMasks[i], b.CollisionGroupMask.IsCollisions[i], i) + } + } + expectedShapeType := SHAPE_CAPSULE + if b.ShapeType != expectedShapeType { + t.Errorf("Expected ShapeType to be %v, got %v", expectedShapeType, b.ShapeType) + } + expectedSize := &mmath.MVec3{0.5398922, 2.553789, 0.0} + if !b.Size.NearEquals(expectedSize, 1e-5) { + t.Errorf("Expected Size to be %v, got %v", expectedSize, b.Size) + } + expectedPosition := &mmath.MVec3{-2.52586, 15.45157, 0.241455} + if !b.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, b.Position) + } + expectedRotation := &mmath.MVec3{0.0, 0.0, 125.00} + if !b.Rotation.GetDegrees().NearEquals(expectedRotation, 1e-5) { + t.Errorf("Expected Rotation to be %v, got %v", expectedRotation, b.Rotation.GetDegrees()) + } + expectedMass := 1.0 + if math.Abs(b.RigidBodyParam.Mass-expectedMass) > 1e-5 { + t.Errorf("Expected Mass to be %v, got %v", expectedMass, b.RigidBodyParam.Mass) + } + expectedLinearDamping := 0.5 + if math.Abs(b.RigidBodyParam.LinearDamping-expectedLinearDamping) > 1e-5 { + t.Errorf("Expected LinearDamping to be %v, got %v", expectedLinearDamping, b.RigidBodyParam.LinearDamping) + } + expectedAngularDamping := 0.5 + if math.Abs(b.RigidBodyParam.AngularDamping-expectedAngularDamping) > 1e-5 { + t.Errorf("Expected AngularDamping to be %v, got %v", expectedAngularDamping, b.RigidBodyParam.AngularDamping) + } + expectedRestitution := 0.0 + if math.Abs(b.RigidBodyParam.Restitution-expectedRestitution) > 1e-5 { + t.Errorf("Expected Restitution to be %v, got %v", expectedRestitution, b.RigidBodyParam.Restitution) + } + expectedFriction := 0.0 + if math.Abs(b.RigidBodyParam.Friction-expectedFriction) > 1e-5 { + t.Errorf("Expected Friction to be %v, got %v", expectedFriction, b.RigidBodyParam.Friction) + } + expectedPhysicsType := PHYSICS_TYPE_STATIC + if b.PhysicsType != expectedPhysicsType { + t.Errorf("Expected PhysicsType to be %v, got %v", expectedPhysicsType, b.PhysicsType) + } + } + + { + j := model.Joints.Get(13) + expectedName := "↓|頭|髪_06-01" + if j.Name != expectedName { + t.Errorf("Expected Name to be %q, got %q", expectedName, j.Name) + } + expectedEnglishName := "↓|頭|髪_06-01" + if j.EnglishName != expectedEnglishName { + t.Errorf("Expected EnglishName to be %q, got %q", expectedEnglishName, j.EnglishName) + } + expectedRigidBodyIndexA := 5 + if j.RigidbodyIndexA != expectedRigidBodyIndexA { + t.Errorf("Expected RigidBodyIndexA to be %v, got %v", expectedRigidBodyIndexA, j.RigidbodyIndexA) + } + expectedRigidBodyIndexB := 45 + if j.RigidbodyIndexB != expectedRigidBodyIndexB { + t.Errorf("Expected RigidBodyIndexB to be %v, got %v", expectedRigidBodyIndexB, j.RigidbodyIndexB) + } + expectedPosition := &mmath.MVec3{-1.189768, 18.56266, 0.07277258} + if !j.Position.MMD().NearEquals(expectedPosition, 1e-5) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, j.Position) + } + expectedRotation := &mmath.MVec3{-15.10554, 91.26718, -4.187446} + if !j.Rotation.GetDegrees().NearEquals(expectedRotation, 1e-5) { + t.Errorf("Expected Rotation to be %v, got %v", expectedRotation, j.Rotation.GetDegrees()) + } + expectedTranslationLimitMin := &mmath.MVec3{0.0, 0.0, 0.0} + if !j.JointParam.TranslationLimitMin.NearEquals(expectedTranslationLimitMin, 1e-5) { + t.Errorf("Expected TranslationLimitation1 to be %v, got %v", expectedTranslationLimitMin, j.JointParam.TranslationLimitMin) + } + expectedTranslationLimitMax := &mmath.MVec3{0.0, 0.0, 0.0} + if !j.JointParam.TranslationLimitMax.NearEquals(expectedTranslationLimitMax, 1e-5) { + t.Errorf("Expected TranslationLimitation2 to be %v, got %v", expectedTranslationLimitMax, j.JointParam.TranslationLimitMax) + } + expectedRotationLimitMin := &mmath.MVec3{-29.04, -14.3587, -29.04} + if !j.JointParam.RotationLimitMin.GetDegrees().NearEquals(expectedRotationLimitMin, 1e-5) { + t.Errorf("Expected RotationLimitation1 to be %v, got %v", expectedRotationLimitMin, j.JointParam.RotationLimitMin.GetDegrees()) + } + expectedRotationLimitMax := &mmath.MVec3{29.04, 14.3587, 29.04} + if !j.JointParam.RotationLimitMax.GetDegrees().NearEquals(expectedRotationLimitMax, 1e-5) { + t.Errorf("Expected RotationLimitation2 to be %v, got %v", expectedRotationLimitMax, j.JointParam.RotationLimitMax.GetDegrees()) + } + expectedSpringConstantTranslation := &mmath.MVec3{0.0, 0.0, 0.0} + if !j.JointParam.SpringConstantTranslation.NearEquals(expectedSpringConstantTranslation, 1e-5) { + t.Errorf("Expected SpringConstantTranslation to be %v, got %v", expectedSpringConstantTranslation, j.JointParam.SpringConstantTranslation) + } + expectedSpringConstantRotation := &mmath.MVec3{60.0, 29.6667, 60.0} + if !j.JointParam.SpringConstantRotation.GetRadians().NearEquals(expectedSpringConstantRotation, 1e-5) { + t.Errorf("Expected SpringConstantRotation to be %v, got %v", expectedSpringConstantRotation, j.JointParam.SpringConstantRotation) + } + } +} diff --git a/pkg/pmx/rigid_body.go b/pkg/pmx/rigid_body.go new file mode 100644 index 00000000..0c9e3705 --- /dev/null +++ b/pkg/pmx/rigid_body.go @@ -0,0 +1,155 @@ +package pmx + +import ( + "github.com/jinzhu/copier" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +type RigidBodyParam struct { + Mass float64 // 質量 + LinearDamping float64 // 移動減衰 + AngularDamping float64 // 回転減衰 + Restitution float64 // 反発力 + Friction float64 // 摩擦力 +} + +func NewRigidBodyParam() *RigidBodyParam { + return &RigidBodyParam{ + Mass: 0, + LinearDamping: 0, + AngularDamping: 0, + Restitution: 0, + Friction: 0, + } +} + +// 剛体の形状 +type Shape int + +const ( + SHAPE_SPHERE Shape = 0 // 球 + SHAPE_BOX Shape = 1 // 箱 + SHAPE_CAPSULE Shape = 2 // カプセル +) + +// 剛体物理の計算モード +type PhysicsType int + +const ( + PHYSICS_TYPE_STATIC PhysicsType = 0 // ボーン追従(static) + PHYSICS_TYPE_DYNAMIC PhysicsType = 1 // 物理演算(dynamic) + PHYSICS_TYPE_DYNAMIC_BONE PhysicsType = 2 // 物理演算 + Bone位置合わせ +) + +type CollisionGroup struct { + IsCollisions []uint16 +} + +var CollisionGroupFlags = []uint16{ + 0x0001, // 0:グループ1 + 0x0002, // 1:グループ2 + 0x0004, // 2:グループ3 + 0x0008, // 3:グループ4 + 0x0010, // 4:グループ5 + 0x0020, // 5:グループ6 + 0x0040, // 6:グループ7 + 0x0080, // 7:グループ8 + 0x0100, // 8:グループ9 + 0x0200, // 9:グループ10 + 0x0400, // 10:グループ11 + 0x0800, // 11:グループ12 + 0x1000, // 12:グループ13 + 0x2000, // 13:グループ14 + 0x4000, // 14:グループ15 + 0x8000, // 15:グループ16 +} + +func NewCollisionGroupFromSlice(collisionGroup []uint16) CollisionGroup { + groups := CollisionGroup{} + collisionGroupMask := uint16(0) + for i, v := range collisionGroup { + if v == 1 { + collisionGroupMask |= CollisionGroupFlags[i] + } + } + groups.IsCollisions = NewCollisionGroup(collisionGroupMask) + + return groups +} + +func NewCollisionGroup(collisionGroupMask uint16) []uint16 { + collisionGroup := []uint16{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} + for i, v := range CollisionGroupFlags { + if collisionGroupMask&v == v { + collisionGroup[i] = 0 + } else { + collisionGroup[i] = 1 + } + } + return collisionGroup +} + +type RigidBody struct { + *mcore.IndexNameModel + BoneIndex int // 関連ボーンIndex + CollisionGroup byte // グループ + CollisionGroupMask CollisionGroup // 非衝突グループフラグ + CollisionGroupMaskValue int // 非衝突グループフラグ値 + ShapeType Shape // 形状 + Size *mmath.MVec3 // サイズ(x,y,z) + Position *mmath.MVec3 // 位置(x,y,z) + Rotation *mmath.MRotation // 回転(x,y,z) -> ラジアン角 + RigidBodyParam *RigidBodyParam // 剛体パラ + PhysicsType PhysicsType // 剛体の物理演算 + // CorrectPhysicsType PhysicsType // 剛体の物理演算(補正後) + XDirection *mmath.MVec3 // X軸方向 + YDirection *mmath.MVec3 // Y軸方向 + ZDirection *mmath.MVec3 // Z軸方向 + IsSystem bool // システムで追加した剛体か + Matrix *mmath.MMat4 // 剛体の行列 + Bone *Bone // 繋がっているボーン + JointedBone *Bone // ジョイントで繋がってるボーン +} + +// NewRigidBody creates a new rigid body. +func NewRigidBody() *RigidBody { + return &RigidBody{ + IndexNameModel: &mcore.IndexNameModel{Index: -1, Name: "", EnglishName: ""}, + BoneIndex: -1, + CollisionGroup: 0, + CollisionGroupMask: NewCollisionGroupFromSlice([]uint16{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}), + CollisionGroupMaskValue: 0, + ShapeType: SHAPE_BOX, + Size: mmath.NewMVec3(), + Position: mmath.NewMVec3(), + Rotation: mmath.NewRotation(), + RigidBodyParam: NewRigidBodyParam(), + PhysicsType: PHYSICS_TYPE_STATIC, + XDirection: mmath.NewMVec3(), + YDirection: mmath.NewMVec3(), + ZDirection: mmath.NewMVec3(), + IsSystem: false, + Matrix: mmath.NewMMat4(), + Bone: nil, + JointedBone: nil, + } +} + +func (r *RigidBody) Copy() mcore.IIndexNameModel { + copied := NewMorph() + copier.CopyWithOption(copied, r, copier.Option{DeepCopy: true}) + return copied +} + +// 剛体リスト +type RigidBodies struct { + *mcore.IndexNameModels[*RigidBody] +} + +func NewRigidBodies(count int) *RigidBodies { + return &RigidBodies{ + IndexNameModels: mcore.NewIndexNameModels[*RigidBody](count, func() *RigidBody { return nil }), + } +} diff --git a/pkg/pmx/rigid_body_gui.go b/pkg/pmx/rigid_body_gui.go new file mode 100644 index 00000000..d5e5b68f --- /dev/null +++ b/pkg/pmx/rigid_body_gui.go @@ -0,0 +1,283 @@ +//go:build windows +// +build windows + +package pmx + +import ( + "github.com/go-gl/mathgl/mgl32" + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mphysics" + "github.com/miu200521358/mlib_go/pkg/mphysics/mbt" +) + +func (r *RigidBody) UpdateFlags( + modelIndex int, modelPhysics *mphysics.MPhysics, enablePhysics, resetPhysics bool, +) bool { + btRigidBody, _ := modelPhysics.GetRigidBody(modelIndex, r.Index) + if btRigidBody == nil { + return false + } + + if r.PhysicsType == PHYSICS_TYPE_STATIC || resetPhysics { + // 剛体の位置更新に物理演算を使わない。もしくは物理演算OFF時 + // MotionState::getWorldTransformが毎ステップコールされるようになるのでここで剛体位置を更新する。 + btRigidBody.SetCollisionFlags( + btRigidBody.GetCollisionFlags() | int(mbt.BtCollisionObjectCF_KINEMATIC_OBJECT)) + // 毎ステップの剛体位置通知を無効にする + // MotionState::setWorldTransformの毎ステップ呼び出しが無効になる(剛体位置は判っているので不要) + btRigidBody.SetActivationState(mbt.DISABLE_SIMULATION) + + if resetPhysics { + return true + } + } else { + prevActivationState := btRigidBody.GetActivationState() + + if enablePhysics { + // 物理演算・物理+ボーン位置合わせの場合 + if prevActivationState != mbt.ACTIVE_TAG { + btRigidBody.SetCollisionFlags(0 & ^int(mbt.BtCollisionObjectCF_NO_CONTACT_RESPONSE)) + btRigidBody.ForceActivationState(mbt.ACTIVE_TAG) + + return true + } else { + // 剛体の位置更新に物理演算を使う。 + // MotionState::getWorldTransformが毎ステップコールされるようになるのでここで剛体位置を更新する。 + btRigidBody.SetCollisionFlags( + btRigidBody.GetCollisionFlags() & ^int(mbt.BtCollisionObjectCF_NO_CONTACT_RESPONSE)) + // 毎ステップの剛体位置通知を有効にする + // MotionState::setWorldTransformの毎ステップ呼び出しが有効になる(剛体位置が変わるので必要) + btRigidBody.SetActivationState(mbt.ACTIVE_TAG) + } + } else { + // 物理OFF時 + btRigidBody.SetCollisionFlags( + btRigidBody.GetCollisionFlags() | int(mbt.BtCollisionObjectCF_KINEMATIC_OBJECT)) + btRigidBody.SetActivationState(mbt.ISLAND_SLEEPING) + + if prevActivationState != mbt.ISLAND_SLEEPING { + return true + } + } + } + + return false +} + +func (r *RigidBody) initPhysics(modelIndex int, modelPhysics *mphysics.MPhysics) { + var btCollisionShape mbt.BtCollisionShape + + // マイナスサイズは許容しない + size := r.Size.Absed() + + switch r.ShapeType { + case SHAPE_SPHERE: + // 球剛体 + btCollisionShape = mbt.NewBtSphereShape(float32(size.GetX())) + case SHAPE_BOX: + // 箱剛体 + btCollisionShape = mbt.NewBtBoxShape( + mbt.NewBtVector3(float32(size.GetX()), float32(size.GetY()), float32(size.GetZ()))) + case SHAPE_CAPSULE: + // カプセル剛体 + btCollisionShape = mbt.NewBtCapsuleShape(float32(size.GetX()), float32(size.GetY())) + } + // btCollisionShape.SetMargin(0.0001) + + // r.CorrectPhysicsType = r.PhysicsType + // if r.PhysicsType == PHYSICS_TYPE_DYNAMIC_BONE && r.BoneIndex < 0 { + // // ボーン追従 + 物理剛体の場合、ボーンIndexが設定されていない場合は物理剛体に変更 + // r.CorrectPhysicsType = PHYSICS_TYPE_DYNAMIC + // } + + // 質量 + mass := float32(0.0) + localInertia := mbt.NewBtVector3(float32(0.0), float32(0.0), float32(0.0)) + if r.PhysicsType != PHYSICS_TYPE_STATIC { + // ボーン追従ではない場合そのまま設定 + mass = float32(r.RigidBodyParam.Mass) + } + if mass != 0 { + // 質量が設定されている場合、慣性を計算 + btCollisionShape.CalculateLocalInertia(mass, localInertia) + } + + // // ボーンのローカル位置 + // boneTransform := mbt.NewBtTransform() + // boneTransform.SetIdentity() + // boneTransform.SetOrigin(boneLocalPosition.Bullet()) + + // 剛体の初期位置と回転 + btRigidBodyTransform := mbt.NewBtTransform(r.Rotation.Bullet(), r.Position.Bullet()) + + // ボーンから見た剛体の初期位置 + var bPos *mmath.MVec3 + if r.Bone != nil { + bPos = r.Bone.Position + } else if r.JointedBone != nil { + bPos = r.JointedBone.Position + } else { + bPos = mmath.NewMVec3() + } + rbLocalPos := r.Position.Subed(bPos) + btRigidBodyLocalTransform := mbt.NewBtTransform(r.Rotation.Bullet(), rbLocalPos.Bullet()) + + // { + // mlog.V("---------------------------------") + // } + // { + // mat := mgl32.Mat4{} + // r.BtRigidBodyTransform.GetOpenGLMatrix(&mat[0]) + // mlog.V("1. [%s] BtRigidBodyTransform: \n%v\n", r.Name, mat) + // } + + // 剛体のグローバル位置と回転 + motionState := mbt.NewBtDefaultMotionState(btRigidBodyTransform) + + btRigidBody := mbt.NewBtRigidBody(mass, motionState, btCollisionShape, localInertia) + btRigidBody.SetDamping(float32(r.RigidBodyParam.LinearDamping), float32(r.RigidBodyParam.AngularDamping)) + btRigidBody.SetRestitution(float32(r.RigidBodyParam.Restitution)) + btRigidBody.SetFriction(float32(r.RigidBodyParam.Friction)) + btRigidBody.SetUserIndex(r.Index) + // btRigidBody.SetSleepingThresholds(0.1, (180.0 * 0.1 / math.Pi)) + + // mlog.V("name: %s, group: %d, mask: %d\n", r.Name, r.CollisionGroup, r.CollisionGroupMaskValue) + + // modelPhysics.AddNonFilterProxy(btRigidBody.GetBroadphaseProxy()) + // 剛体・剛体グループ・非衝突グループを追加 + modelPhysics.AddRigidBody(btRigidBody, btRigidBodyLocalTransform, modelIndex, r.Index, + 1<= 0 && r.BoneIndex < len(boneTransforms) { + // mat := mgl32.Mat4{} + // (*boneTransforms[r.BoneIndex]).GetOpenGLMatrix(&mat[0]) + // mlog.V("2. [%d] boneTransform: \n%v\n", r.BoneIndex, mat) + // } + // { + // mat := mgl32.Mat4{} + // rigidBodyTransform.GetOpenGLMatrix(&mat[0]) + // mlog.V("2. [%s] rigidBodyTransform: \n%v\n", r.Name, mat) + // } + +} + +func (r *RigidBody) GetRigidBodyBoneMatrix( + modelIndex int, + modelPhysics *mphysics.MPhysics, +) *mmath.MMat4 { + btRigidBody, btRigidBodyLocalTransform := modelPhysics.GetRigidBody(modelIndex, r.Index) + + if btRigidBody == nil || btRigidBody.GetMotionState() == nil { + return nil + } + + // if r.Name == "前髪" { + // state := btRigidBody.GetActivationState() + // isStatic := btRigidBody.IsStaticOrKinematicObject() + // flags := btRigidBody.GetCollisionFlags() + // mlog.V("name: %s, state: %v, static: %v, flags: %v, isKinematic: %v, isStatic: %v\n", r.Name, state, isStatic, flags, flags&int(mbt.BtCollisionObjectCF_KINEMATIC_OBJECT) != 0, flags&int(mbt.BtCollisionObjectCF_STATIC_OBJECT) != 0) + // } + + // { + // mlog.V("----------") + // } + + motionState := btRigidBody.GetMotionState().(mbt.BtMotionState) + + rigidBodyGlobalTransform := mbt.NewBtTransform() + defer mbt.DeleteBtTransform(rigidBodyGlobalTransform) + + motionState.GetWorldTransform(rigidBodyGlobalTransform) + + // if r.CorrectPhysicsType == PHYSICS_TYPE_DYNAMIC_BONE { + // { + // mat := mgl32.Mat4{} + // rigidBodyTransform.GetOpenGLMatrix(&mat[0]) + // mlog.V("3. [%s] rigidBodyTransform Before: \n%v\n", r.Name, mat) + // } + + // if r.BoneIndex >= 0 && r.BoneIndex < len(boneTransforms) { + // // 物理+ボーン追従はボーン移動成分を現在のボーン位置にする + // boneGlobalTransform := mbt.NewBtTransform() + // boneGlobalTransform.Mult(*boneTransforms[r.BoneIndex], r.BtRigidBodyTransform) + + // rigidBodyTransform.SetOrigin(boneGlobalTransform.GetOrigin().(mbt.BtVector3)) + // } else if r.JointedBoneIndex >= 0 && r.JointedBoneIndex < len(boneTransforms) { + // // ジョイントで繋がっているボーンがある場合はそのボーン位置にする + // boneGlobalTransform := mbt.NewBtTransform() + // boneGlobalTransform.Mult(*boneTransforms[r.JointedBoneIndex], r.BtRigidBodyTransform) + + // rigidBodyTransform.SetOrigin(boneGlobalTransform.GetOrigin().(mbt.BtVector3)) + // } + + // { + // mat := mgl32.Mat4{} + // rigidBodyTransform.GetOpenGLMatrix(&mat[0]) + // mlog.V("3. [%s] rigidBodyTransform After: \n%v\n", r.Name, mat) + // } + // } + + // ボーンのグローバル位置を剛体の現在グローバル行列に初期位置ローカル行列を掛けて求める + boneGlobalTransform := mbt.NewBtTransform() + defer mbt.DeleteBtTransform(boneGlobalTransform) + + invRigidBodyLocalTransform := btRigidBodyLocalTransform.Inverse() + defer mbt.DeleteBtTransform(invRigidBodyLocalTransform) + + boneGlobalTransform.Mult(rigidBodyGlobalTransform, invRigidBodyLocalTransform) + + boneGlobalMatrixGL := mgl32.Mat4{} + boneGlobalTransform.GetOpenGLMatrix(&boneGlobalMatrixGL[0]) + + // if r.BoneIndex >= 0 && r.BoneIndex < len(boneTransforms) { + // mat := mgl32.Mat4{} + // (*boneTransforms[r.BoneIndex]).GetOpenGLMatrix(&mat[0]) + // mlog.V("3. [%d] boneTransform: \n%v\n", r.BoneIndex, mat) + // } + // { + // mat := mgl32.Mat4{} + // rigidBodyTransform.GetOpenGLMatrix(&mat[0]) + // mlog.V("3. [%s] rigidBodyTransform: \n%v\n", r.Name, mat) + // } + // { + // mlog.V("3. [%s] physicsBoneMatrix: \n%v\n", r.Name, physicsBoneMatrix) + // } + + return mmath.NewMMat4ByMgl(&boneGlobalMatrixGL) +} + +func (r *RigidBodies) initPhysics(modelIndex int, physics *mphysics.MPhysics) { + // 剛体を順番にボーンと紐付けていく + for _, rigidBody := range r.Data { + // 物理設定の初期化 + rigidBody.initPhysics(modelIndex, physics) + } +} diff --git a/pkg/pmx/texture.go b/pkg/pmx/texture.go new file mode 100644 index 00000000..b72ab3be --- /dev/null +++ b/pkg/pmx/texture.go @@ -0,0 +1,69 @@ +package pmx + +import ( + "image" + + "github.com/jinzhu/copier" + "github.com/miu200521358/mlib_go/pkg/mcore" +) + +// テクスチャ種別 +type TextureType int + +const ( + TEXTURE_TYPE_TEXTURE TextureType = 0 // テクスチャ + TEXTURE_TYPE_TOON TextureType = 1 // Toonテクスチャ + TEXTURE_TYPE_SPHERE TextureType = 2 // スフィアテクスチャ +) + +type Texture struct { + *mcore.IndexModel + Name string // テクスチャ名 + TextureType TextureType // テクスチャ種別 + Path string // テクスチャフルパス + Valid bool // テクスチャフルパスが有効であるか否か + glId uint32 // OpenGLテクスチャID + Initialized bool // 描画初期化済みフラグ + Image *image.NRGBA // テクスチャイメージ + textureUnitId uint32 // テクスチャ種類別描画先ユニットID + textureUnitNo uint32 // テクスチャ種類別描画先ユニット番号 + IsGeneratedMipmap bool // ミップマップが生成されているか否か +} + +func NewTexture() *Texture { + return &Texture{ + IndexModel: &mcore.IndexModel{Index: -1}, + Name: "", + TextureType: TEXTURE_TYPE_TEXTURE, + Path: "", + Valid: false, + } +} + +func (t *Texture) Copy() mcore.IIndexModel { + copied := NewTexture() + copier.CopyWithOption(copied, t, copier.Option{DeepCopy: true}) + return copied +} + +// テクスチャリスト +type Textures struct { + *mcore.IndexModels[*Texture] +} + +func NewTextures(count int) *Textures { + return &Textures{ + IndexModels: mcore.NewIndexModels[*Texture](count, func() *Texture { return nil }), + } +} + +// 共有テクスチャ辞書 +type ToonTextures struct { + *mcore.IndexModels[*Texture] +} + +func NewToonTextures() *ToonTextures { + return &ToonTextures{ + IndexModels: mcore.NewIndexModels[*Texture](10, func() *Texture { return nil }), + } +} diff --git a/pkg/pmx/texture_gui.go b/pkg/pmx/texture_gui.go new file mode 100644 index 00000000..f9d913f2 --- /dev/null +++ b/pkg/pmx/texture_gui.go @@ -0,0 +1,257 @@ +//go:build windows +// +build windows + +package pmx + +import ( + "embed" + "fmt" + "path/filepath" + + "github.com/go-gl/gl/v4.4-core/gl" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils" + "github.com/miu200521358/mlib_go/pkg/mutils/mi18n" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" +) + +//go:embed toon/* +var toonFiles embed.FS + +type TextureGL struct { + Id uint32 // OpenGLテクスチャID + Valid bool // テクスチャフルパスが有効であるか否か + TextureType TextureType // テクスチャ種別 + TextureUnitId uint32 // テクスチャ種類別描画先ユニットID + TextureUnitNo uint32 // テクスチャ種類別描画先ユニット番号 + IsGeneratedMipmap bool // ミップマップが生成されているか否か +} + +func (t *TextureGL) Bind() { + if !t.Valid { + return + } + + gl.ActiveTexture(t.TextureUnitId) + gl.BindTexture(gl.TEXTURE_2D, t.Id) + + if t.TextureType == TEXTURE_TYPE_TOON { + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT) + } + + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR) + + if t.IsGeneratedMipmap { + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR) + } else { + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAX_LEVEL, 0) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR) + } +} + +func (t *TextureGL) Unbind() { + if !t.Valid { + return + } + + gl.BindTexture(gl.TEXTURE_2D, 0) +} + +func (t *TextureGL) delete() { + if t.Valid { + gl.DeleteTextures(1, &t.Id) + } +} + +func (t *Texture) GL( + modelPath string, + textureType TextureType, + windowIndex int, +) *TextureGL { + tGl := &TextureGL{} + + if t.Initialized && t.Valid { + // 既にフラグが立ってたら描画初期化済み + // 共有Toonテクスチャの場合、既に初期化済み + tGl.Id = t.glId + tGl.Valid = t.Valid + tGl.TextureType = t.TextureType + tGl.TextureUnitId = t.textureUnitId + tGl.TextureUnitNo = t.textureUnitNo + tGl.IsGeneratedMipmap = t.IsGeneratedMipmap + return tGl + } + + // 通常テクスチャ + texPath := filepath.Join(filepath.Dir(modelPath), t.Name) + + // テクスチャがちゃんとある場合のみ初期化処理実施 + valid, err := mutils.ExistsFile(texPath) + t.Valid = (valid && err == nil) + if !t.Valid { + t.Initialized = true + return nil + } + + t.Path = texPath + img, err := mutils.LoadImage(texPath) + if err != nil { + t.Valid = false + } else { + t.Image = mutils.ConvertToNRGBA(*img) + *img = nil + } + + if !t.Valid { + t.Initialized = true + return nil + } + + t.IsGeneratedMipmap = + mmath.IsPowerOfTwo(t.Image.Rect.Size().X) && mmath.IsPowerOfTwo(t.Image.Rect.Size().Y) + + t.TextureType = textureType + + // テクスチャオブジェクト生成 + gl.GenTextures(1, &tGl.Id) + t.glId = tGl.Id + + // テクスチャ種別によってテクスチャユニットを変更 + if windowIndex == 0 { + switch textureType { + case TEXTURE_TYPE_TEXTURE: + t.textureUnitId = gl.TEXTURE0 + t.textureUnitNo = 0 + case TEXTURE_TYPE_TOON: + t.textureUnitId = gl.TEXTURE1 + t.textureUnitNo = 1 + case TEXTURE_TYPE_SPHERE: + t.textureUnitId = gl.TEXTURE2 + t.textureUnitNo = 2 + } + } else if windowIndex == 1 { + switch textureType { + case TEXTURE_TYPE_TEXTURE: + t.textureUnitId = gl.TEXTURE3 + t.textureUnitNo = 3 + case TEXTURE_TYPE_TOON: + t.textureUnitId = gl.TEXTURE4 + t.textureUnitNo = 4 + case TEXTURE_TYPE_SPHERE: + t.textureUnitId = gl.TEXTURE5 + t.textureUnitNo = 5 + } + } else if windowIndex == 2 { + switch textureType { + case TEXTURE_TYPE_TEXTURE: + t.textureUnitId = gl.TEXTURE6 + t.textureUnitNo = 6 + case TEXTURE_TYPE_TOON: + t.textureUnitId = gl.TEXTURE7 + t.textureUnitNo = 7 + case TEXTURE_TYPE_SPHERE: + t.textureUnitId = gl.TEXTURE8 + t.textureUnitNo = 8 + } + } + + tGl.Valid = t.Valid + tGl.TextureType = t.TextureType + tGl.TextureUnitId = t.textureUnitId + tGl.TextureUnitNo = t.textureUnitNo + tGl.IsGeneratedMipmap = t.IsGeneratedMipmap + + tGl.Bind() + + gl.TexImage2D( + gl.TEXTURE_2D, + 0, + gl.RGBA, + int32(t.Image.Rect.Size().X), + int32(t.Image.Rect.Size().Y), + 0, + gl.RGBA, + gl.UNSIGNED_BYTE, + gl.Ptr(t.Image.Pix), + ) + + if t.IsGeneratedMipmap { + gl.GenerateMipmap(gl.TEXTURE_2D) + } else { + mlog.D(mi18n.T("ミップマップ生成エラー", map[string]interface{}{"Name": t.Name})) + } + + tGl.Unbind() + + // 描画初期化 + t.Initialized = true + return tGl +} + +func (t *ToonTextures) initGl( + windowIndex int, +) error { + for i := 0; i < 10; i++ { + filePath := fmt.Sprintf("toon/toon%02d.bmp", i+1) + + toon := NewTexture() + toon.Index = i + toon.Name = filePath + toon.TextureType = TEXTURE_TYPE_TOON + toon.Path = filePath + + img, err := mutils.LoadImageFromResources(toonFiles, filePath) + if err != nil { + return err + } + toon.Image = mutils.ConvertToNRGBA(*img) + toon.Valid = true + *img = nil + + tGl := &TextureGL{} + + // テクスチャオブジェクト生成 + gl.GenTextures(1, &tGl.Id) + toon.glId = tGl.Id + + // Toon用テクスチャユニットを設定 + if windowIndex == 0 { + toon.textureUnitId = gl.TEXTURE10 + toon.textureUnitNo = 10 + } else if windowIndex == 1 { + toon.textureUnitId = gl.TEXTURE11 + toon.textureUnitNo = 11 + } else if windowIndex == 2 { + toon.textureUnitId = gl.TEXTURE12 + toon.textureUnitNo = 12 + } + + tGl.Valid = toon.Valid + tGl.TextureType = toon.TextureType + tGl.TextureUnitId = toon.textureUnitId + // tGl.IsGeneratedMipmap = toon.IsGeneratedMipmap // Toonテクスチャはミップマップを生成しない + + tGl.Bind() + + gl.TexImage2D( + gl.TEXTURE_2D, + 0, + gl.RGBA, + int32(toon.Image.Rect.Size().X), + int32(toon.Image.Rect.Size().Y), + 0, + gl.RGBA, + gl.UNSIGNED_BYTE, + gl.Ptr(toon.Image.Pix), + ) + + tGl.Unbind() + toon.Initialized = true + + t.Update(toon) + } + + return nil +} diff --git a/pkg/pmx/toon/toon01.bmp b/pkg/pmx/toon/toon01.bmp new file mode 100644 index 00000000..08950ab8 Binary files /dev/null and b/pkg/pmx/toon/toon01.bmp differ diff --git a/pkg/pmx/toon/toon02.bmp b/pkg/pmx/toon/toon02.bmp new file mode 100644 index 00000000..9c39cd58 Binary files /dev/null and b/pkg/pmx/toon/toon02.bmp differ diff --git a/pkg/pmx/toon/toon03.bmp b/pkg/pmx/toon/toon03.bmp new file mode 100644 index 00000000..093094e7 Binary files /dev/null and b/pkg/pmx/toon/toon03.bmp differ diff --git a/pkg/pmx/toon/toon04.bmp b/pkg/pmx/toon/toon04.bmp new file mode 100644 index 00000000..2fbb80dc Binary files /dev/null and b/pkg/pmx/toon/toon04.bmp differ diff --git a/pkg/pmx/toon/toon05.bmp b/pkg/pmx/toon/toon05.bmp new file mode 100644 index 00000000..136a7098 Binary files /dev/null and b/pkg/pmx/toon/toon05.bmp differ diff --git a/pkg/pmx/toon/toon06.bmp b/pkg/pmx/toon/toon06.bmp new file mode 100644 index 00000000..9c500c01 Binary files /dev/null and b/pkg/pmx/toon/toon06.bmp differ diff --git a/pkg/pmx/toon/toon07.bmp b/pkg/pmx/toon/toon07.bmp new file mode 100644 index 00000000..1b982fe3 Binary files /dev/null and b/pkg/pmx/toon/toon07.bmp differ diff --git a/pkg/pmx/toon/toon08.bmp b/pkg/pmx/toon/toon08.bmp new file mode 100644 index 00000000..1b982fe3 Binary files /dev/null and b/pkg/pmx/toon/toon08.bmp differ diff --git a/pkg/pmx/toon/toon09.bmp b/pkg/pmx/toon/toon09.bmp new file mode 100644 index 00000000..1b982fe3 Binary files /dev/null and b/pkg/pmx/toon/toon09.bmp differ diff --git a/pkg/pmx/toon/toon10.bmp b/pkg/pmx/toon/toon10.bmp new file mode 100644 index 00000000..1b982fe3 Binary files /dev/null and b/pkg/pmx/toon/toon10.bmp differ diff --git a/pkg/pmx/vertex.go b/pkg/pmx/vertex.go new file mode 100644 index 00000000..bc259fcb --- /dev/null +++ b/pkg/pmx/vertex.go @@ -0,0 +1,52 @@ +package pmx + +import ( + "github.com/jinzhu/copier" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +type Vertex struct { + *mcore.IndexModel + Position *mmath.MVec3 // 頂点位置 + Normal *mmath.MVec3 // 頂点法線 + Uv *mmath.MVec2 // UV + ExtendedUvs []*mmath.MVec4 // 追加UV + DeformType DeformType // ウェイト変形方式 + Deform IDeform // デフォーム + EdgeFactor float64 // エッジ倍率 + MaterialIndexes []int // 割り当て材質インデックス +} + +func NewVertex() *Vertex { + v := &Vertex{ + IndexModel: &mcore.IndexModel{Index: -1}, + Position: mmath.NewMVec3(), + Normal: mmath.NewMVec3(), + Uv: mmath.NewMVec2(), + ExtendedUvs: make([]*mmath.MVec4, 0), + DeformType: BDEF1, + Deform: nil, + EdgeFactor: 0.0, + MaterialIndexes: make([]int, 0), + } + return v +} + +func (v *Vertex) Copy() mcore.IIndexModel { + copied := NewVertex() + copier.CopyWithOption(copied, v, copier.Option{DeepCopy: true}) + return copied +} + +// 頂点リスト +type Vertices struct { + *mcore.IndexModels[*Vertex] +} + +func NewVertices(count int) *Vertices { + return &Vertices{ + IndexModels: mcore.NewIndexModels[*Vertex](count, func() *Vertex { return nil }), + } +} diff --git a/pkg/pmx/vertex_gui.go b/pkg/pmx/vertex_gui.go new file mode 100644 index 00000000..3d008669 --- /dev/null +++ b/pkg/pmx/vertex_gui.go @@ -0,0 +1,113 @@ +//go:build windows +// +build windows + +package pmx + +import ( + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +func (v *Vertex) GL() []float32 { + p := v.Position.GL() + n := v.Normal.GL() + eu := [2]float32{0.0, 0.0} + if len(v.ExtendedUvs) > 0 { + eu[0] = float32(v.ExtendedUvs[0].GetX()) + eu[1] = float32(v.ExtendedUvs[0].GetY()) + } + d := v.Deform.NormalizedDeform() + s := float32(mmath.BoolToInt(v.DeformType == SDEF)) + sdefC, sdefR0, sdefR1 := v.Deform.GetSdefParams() + return []float32{ + p[0], p[1], p[2], // 位置 + n[0], n[1], n[2], // 法線 + float32(v.Uv.GetX()), float32(v.Uv.GetY()), // UV + eu[0], eu[1], // 追加UV + float32(v.EdgeFactor), // エッジ倍率 + d[0], d[1], d[2], d[3], // デフォームボーンINDEX + d[4], d[5], d[6], d[7], // デフォームボーンウェイト + s, // SDEFであるか否か + sdefC[0], sdefC[1], sdefC[2], // SDEF-C + sdefR0[0], sdefR0[1], sdefR0[2], // SDEF-R0 + sdefR1[0], sdefR1[1], sdefR1[2], // SDEF-R1 + 0.0, 0.0, 0.0, // 頂点モーフ + 0.0, 0.0, 0.0, 0.0, // UVモーフ + 0.0, 0.0, 0.0, 0.0, // 追加UV1モーフ + 0.0, 0.0, 0.0, // 変形後頂点モーフ + } +} + +func (v *Vertex) NormalGL() []float32 { + p := v.Position.GL() + n := v.Normal.MuledScalar(0.5).GL() + d := v.Deform.NormalizedDeform() + s := float32(mmath.BoolToInt(v.DeformType == SDEF)) + sdefC, sdefR0, sdefR1 := v.Deform.GetSdefParams() + return []float32{ + p[0] + n[0], p[1] + n[1], p[2] + n[2], // 位置 + n[0], n[1], n[2], // 法線 + float32(0), float32(0), // UV + float32(0), float32(0), // 追加UV + float32(0), // エッジ倍率 + d[0], d[1], d[2], d[3], // デフォームボーンINDEX + d[4], d[5], d[6], d[7], // デフォームボーンウェイト + s, // SDEFであるか否か + sdefC[0], sdefC[1], sdefC[2], // SDEF-C + sdefR0[0], sdefR0[1], sdefR0[2], // SDEF-R0 + sdefR1[0], sdefR1[1], sdefR1[2], // SDEF-R1 + 0.0, 0.0, 0.0, // 頂点モーフ + 0.0, 0.0, 0.0, 0.0, // UVモーフ + 0.0, 0.0, 0.0, 0.0, // 追加UV1モーフ + 0.0, 0.0, 0.0, // 変形後頂点モーフ + } +} + +func (v *Vertex) WireGL() []float32 { + p := v.Position.GL() + n := v.Normal.GL() + d := v.Deform.NormalizedDeform() + s := float32(mmath.BoolToInt(v.DeformType == SDEF)) + sdefC, sdefR0, sdefR1 := v.Deform.GetSdefParams() + return []float32{ + p[0], p[1], p[2], // 位置 + n[0], n[1], n[2], // 法線 + float32(1), float32(0), // UV(Xは明示的に1) + float32(0), float32(0), // 追加UV + float32(0), // エッジ倍率 + d[0], d[1], d[2], d[3], // デフォームボーンINDEX + d[4], d[5], d[6], d[7], // デフォームボーンウェイト + s, // SDEFであるか否か + sdefC[0], sdefC[1], sdefC[2], // SDEF-C + sdefR0[0], sdefR0[1], sdefR0[2], // SDEF-R0 + sdefR1[0], sdefR1[1], sdefR1[2], // SDEF-R1 + 0.0, 0.0, 0.0, // 頂点モーフ + 1.0, 0.0, 0.0, 0.0, // UVモーフ(Xは明示的に1にしてフラグを立てる（表示状態）) + 0.0, 0.0, 0.0, 0.0, // 追加UV1モーフ + 0.0, 0.0, 0.0, // 変形後頂点モーフ + } +} + +func (v *Vertex) SelectedGL() []float32 { + p := v.Position.GL() + n := v.Normal.GL() + d := v.Deform.NormalizedDeform() + s := float32(mmath.BoolToInt(v.DeformType == SDEF)) + sdefC, sdefR0, sdefR1 := v.Deform.GetSdefParams() + return []float32{ + p[0], p[1], p[2], // 位置 + n[0], n[1], n[2], // 法線 + float32(-1), float32(0), // UV(Xは明示的に-1) + float32(0), float32(0), // 追加UV + float32(0), // エッジ倍率 + d[0], d[1], d[2], d[3], // デフォームボーンINDEX + d[4], d[5], d[6], d[7], // デフォームボーンウェイト + s, // SDEFであるか否か + sdefC[0], sdefC[1], sdefC[2], // SDEF-C + sdefR0[0], sdefR0[1], sdefR0[2], // SDEF-R0 + sdefR1[0], sdefR1[1], sdefR1[2], // SDEF-R1 + 0.0, 0.0, 0.0, // 頂点モーフ + 1.0, 0.0, 0.0, 0.0, // UVモーフ(Xは明示的に1にしてフラグを立てる（選択状態）) + 0.0, 0.0, 0.0, 0.0, // 追加UV1モーフ + 0.0, 0.0, 0.0, // 変形後頂点モーフ + } +} diff --git a/pkg/vmd/base_frame.go b/pkg/vmd/base_frame.go new file mode 100644 index 00000000..81275077 --- /dev/null +++ b/pkg/vmd/base_frame.go @@ -0,0 +1,260 @@ +package vmd + +import ( + "sync" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/petar/GoLLRB/llrb" +) + +type IBaseFrame interface { + GetIndex() int + getIntIndex() mcore.Int + SetIndex(index int) + IsRegistered() bool + IsRead() bool + Less(than llrb.Item) bool + lerpFrame(prevFrame IBaseFrame, index int) IBaseFrame + splitCurve(prevFrame IBaseFrame, nextFrame IBaseFrame, index int) + Copy() IBaseFrame + New(index int) IBaseFrame +} + +type BaseFrame struct { + Index mcore.Int + Registered bool // 登録対象のキーフレであるか + Read bool // VMDファイルから読み込んだキーフレであるか +} + +func (b *BaseFrame) Less(than llrb.Item) bool { + return b.GetIndex() < int(than.(mcore.Int)) +} + +func (b *BaseFrame) Copy() IBaseFrame { + return &BaseFrame{ + Index: b.Index, + Registered: b.Registered, + Read: b.Read, + } +} + +func (b *BaseFrame) New(index int) IBaseFrame { + return &BaseFrame{ + Index: mcore.Int(index), + } +} + +func NewFrame(index int) IBaseFrame { + return &BaseFrame{ + Index: mcore.NewInt(index), + Registered: false, + Read: false, + } +} + +func (b *BaseFrame) lerpFrame(prevFrame IBaseFrame, index int) IBaseFrame { + return b.Copy() +} + +func (b *BaseFrame) splitCurve(prevFrame IBaseFrame, nextFrame IBaseFrame, index int) { +} + +func (bf *BaseFrame) getIntIndex() mcore.Int { + return bf.Index +} + +func (bf *BaseFrame) GetIndex() int { + return int(bf.Index) +} + +func (bf *BaseFrame) SetIndex(index int) { + bf.Index = mcore.NewInt(index) +} + +func (bf *BaseFrame) IsRegistered() bool { + return bf.Registered +} + +func (bf *BaseFrame) IsRead() bool { + return bf.Read +} + +type BaseFrames[T IBaseFrame] struct { + data map[int]T // キーフレリスト + Indexes *mcore.IntIndexes // 全キーフレリスト + RegisteredIndexes *mcore.IntIndexes // 登録対象キーフレリスト + newFunc func(index int) T // キーフレ生成関数 + nullFunc func() T // 空キーフレ生成関数 + lock sync.RWMutex // マップアクセス制御用 +} + +func NewBaseFrames[T IBaseFrame](newFunc func(index int) T, nullFunc func() T) *BaseFrames[T] { + return &BaseFrames[T]{ + data: make(map[int]T), + Indexes: mcore.NewIntIndexes(), + RegisteredIndexes: mcore.NewIntIndexes(), + newFunc: newFunc, + nullFunc: nullFunc, + lock: sync.RWMutex{}, + } +} + +func (fs *BaseFrames[T]) NewFrame(index int) T { + return NewFrame(index).(T) +} + +func (fs *BaseFrames[T]) Get(index int) T { + fs.lock.RLock() + defer fs.lock.RUnlock() + + if _, ok := fs.data[index]; ok { + return fs.data[index] + } + + if len(fs.data) == 0 { + return fs.newFunc(index) + } + + prevFrame := fs.prevFrame(index) + nextFrame := fs.nextFrame(index) + if nextFrame == prevFrame { + // 次のキーフレが無い場合、最大キーフレのコピーを返す + if fs.Indexes.Len() == 0 { + // 存在しない場合nullを返す + return fs.nullFunc() + } + copied := fs.data[fs.Indexes.Max()].Copy() + copied.SetIndex(index) + return copied.(T) + } + + prevF := fs.Get(prevFrame) + nextF := fs.Get(nextFrame) + + // 該当キーフレが無い場合、補間結果を返す + return nextF.lerpFrame(prevF, index).(T) +} + +func (fs *BaseFrames[T]) prevFrame(index int) int { + prevFrame := fs.GetMinFrame() + + fs.RegisteredIndexes.DescendLessOrEqual(mcore.Int(index), func(i llrb.Item) bool { + prevFrame = int(i.(mcore.Int)) + return false + }) + + return prevFrame +} + +func (fs *BaseFrames[T]) nextFrame(index int) int { + nextFrame := fs.GetMaxFrame() + + fs.RegisteredIndexes.AscendGreaterOrEqual(mcore.Int(index), func(i llrb.Item) bool { + nextFrame = int(i.(mcore.Int)) + return false + }) + + return nextFrame +} + +func (fs *BaseFrames[T]) List() []T { + list := make([]T, 0, fs.RegisteredIndexes.Len()) + + fs.RegisteredIndexes.AscendRange(mcore.Int(0), mcore.Int(fs.RegisteredIndexes.Max()), func(i llrb.Item) bool { + if _, ok := fs.data[int(i.(mcore.Int))]; !ok { + list = append(list, fs.data[int(i.(mcore.Int))]) + } + return true + }) + + return list +} + +func (fs *BaseFrames[T]) appendFrame(v T) { + fs.lock.Lock() + defer fs.lock.Unlock() + + if v.IsRegistered() { + fs.RegisteredIndexes.ReplaceOrInsert(mcore.Int(v.GetIndex())) + } + + fs.data[v.GetIndex()] = v + fs.Indexes.ReplaceOrInsert(mcore.Int(v.GetIndex())) +} + +func (fs *BaseFrames[T]) GetMaxFrame() int { + if fs.RegisteredIndexes.Len() == 0 { + return 0 + } + return fs.RegisteredIndexes.Max() +} + +func (fs *BaseFrames[T]) GetMinFrame() int { + if fs.RegisteredIndexes.Len() == 0 { + return 0 + } + return fs.RegisteredIndexes.Min() +} + +func (fs *BaseFrames[T]) ContainsRegistered(index int) bool { + return fs.RegisteredIndexes.Has(index) +} + +func (fs *BaseFrames[T]) Contains(index int) bool { + if _, ok := fs.data[index]; ok { + return true + } + return false +} + +func (fs *BaseFrames[T]) Delete(index int) { + fs.lock.Lock() + defer fs.lock.Unlock() + + if _, ok := fs.data[index]; ok { + delete(fs.data, index) + fs.Indexes.Delete(mcore.Int(index)) + } + + if fs.RegisteredIndexes.Has(index) { + fs.RegisteredIndexes.Delete(mcore.Int(index)) + } +} + +// Append 補間曲線は分割しない +func (fs *BaseFrames[T]) Append(f T) { + fs.appendOrInsert(f, false) +} + +// Insert Registered が true の場合、補間曲線を分割して登録する +func (fs *BaseFrames[T]) Insert(f T) { + fs.appendOrInsert(f, true) +} + +func (fs *BaseFrames[T]) appendOrInsert(f T, isSplitCurve bool) { + if f.IsRegistered() { + if fs.RegisteredIndexes.Len() == 0 { + // フレームがない場合、何もしない + fs.appendFrame(f) + return + } + + if isSplitCurve { + // 補間曲線を分割する + prevF := fs.Get(fs.prevFrame(f.GetIndex())) + nextF := fs.Get(fs.nextFrame(f.GetIndex())) + + // 補間曲線を分割する + if nextF.GetIndex() > f.GetIndex() && prevF.GetIndex() < f.GetIndex() { + index := f.GetIndex() + f.splitCurve(prevF, nextF, index) + } + } + } + + fs.appendFrame(f) +} + +func (fs *BaseFrames[T]) Len() int { + return fs.RegisteredIndexes.Len() +} diff --git a/pkg/vmd/bone_curves.go b/pkg/vmd/bone_curves.go new file mode 100644 index 00000000..c2f05331 --- /dev/null +++ b/pkg/vmd/bone_curves.go @@ -0,0 +1,255 @@ +package vmd + +import "github.com/miu200521358/mlib_go/pkg/mmath" + +var InitialBoneCurves = []byte{ + 20, + 20, + 0, + 0, + 20, + 20, + 20, + 20, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 0, + 20, + 20, + 20, + 20, + 20, + 20, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 0, + 0, + 20, + 20, + 20, + 20, + 20, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 0, + 0, + 0, +} + +type BoneCurves struct { + TranslateX *mmath.Curve // 移動X + TranslateY *mmath.Curve // 移動Y + TranslateZ *mmath.Curve // 移動Z + Rotate *mmath.Curve // 回転 + Values []byte // 補間曲線の値 +} + +func NewBoneCurves() *BoneCurves { + return &BoneCurves{ + TranslateX: mmath.NewCurve(), + TranslateY: mmath.NewCurve(), + TranslateZ: mmath.NewCurve(), + Rotate: mmath.NewCurve(), + Values: []byte{ + 20, + 20, + 0, + 0, + 20, + 20, + 20, + 20, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 0, + 20, + 20, + 20, + 20, + 20, + 20, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 0, + 0, + 20, + 20, + 20, + 20, + 20, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 0, + 0, + 0, + }, + } +} + +func NewBoneCurvesByValues(values []byte) *BoneCurves { + curves := &BoneCurves{ + TranslateX: mmath.NewCurveByValues(values[0], values[4], values[8], values[12]), + TranslateY: mmath.NewCurveByValues(values[16], values[20], values[24], values[28]), + TranslateZ: mmath.NewCurveByValues(values[32], values[36], values[40], values[44]), + Rotate: mmath.NewCurveByValues(values[48], values[52], values[56], values[60]), + Values: values, + } + + return curves +} + +// 補間曲線の計算 (xy, yy, zy, ry) +func (v *BoneCurves) Evaluate(prevIndex, nowIndex, nextIndex int) (float64, float64, float64, float64) { + var xy, yy, zy, ry float64 + _, xy, _ = mmath.Evaluate(v.TranslateX, prevIndex, nowIndex, nextIndex) + _, yy, _ = mmath.Evaluate(v.TranslateY, prevIndex, nowIndex, nextIndex) + _, zy, _ = mmath.Evaluate(v.TranslateZ, prevIndex, nowIndex, nextIndex) + _, ry, _ = mmath.Evaluate(v.Rotate, prevIndex, nowIndex, nextIndex) + + return xy, yy, zy, ry +} + +func (c *BoneCurves) Merge() []byte { + return []byte{ + byte(c.TranslateX.Start.GetX()), + c.Values[1], + c.Values[2], + c.Values[3], + byte(c.TranslateX.Start.GetY()), + c.Values[5], + c.Values[6], + c.Values[7], + byte(c.TranslateX.End.GetX()), + c.Values[9], + c.Values[10], + c.Values[11], + byte(c.TranslateX.End.GetY()), + c.Values[13], + c.Values[14], + c.Values[15], + byte(c.TranslateY.Start.GetX()), + c.Values[17], + c.Values[18], + c.Values[19], + byte(c.TranslateY.Start.GetY()), + c.Values[21], + c.Values[22], + c.Values[23], + byte(c.TranslateY.End.GetX()), + c.Values[25], + c.Values[26], + c.Values[27], + byte(c.TranslateY.End.GetY()), + c.Values[29], + c.Values[30], + c.Values[31], + byte(c.TranslateZ.Start.GetX()), + c.Values[33], + c.Values[34], + c.Values[35], + byte(c.TranslateZ.Start.GetY()), + c.Values[37], + c.Values[38], + c.Values[39], + byte(c.TranslateZ.End.GetX()), + c.Values[41], + c.Values[42], + c.Values[43], + byte(c.TranslateZ.End.GetY()), + c.Values[45], + c.Values[46], + c.Values[47], + byte(c.Rotate.Start.GetX()), + c.Values[49], + c.Values[50], + c.Values[51], + byte(c.Rotate.Start.GetY()), + c.Values[53], + c.Values[54], + c.Values[55], + byte(c.Rotate.End.GetX()), + c.Values[57], + c.Values[58], + c.Values[59], + byte(c.Rotate.End.GetY()), + c.Values[61], + c.Values[62], + c.Values[63], + } +} + +func (c *BoneCurves) Copy() *BoneCurves { + return &BoneCurves{ + TranslateX: c.TranslateX.Copy(), + TranslateY: c.TranslateY.Copy(), + TranslateZ: c.TranslateZ.Copy(), + Rotate: c.Rotate.Copy(), + Values: c.Values, + } +} diff --git a/pkg/vmd/bone_delta.go b/pkg/vmd/bone_delta.go new file mode 100644 index 00000000..44933130 --- /dev/null +++ b/pkg/vmd/bone_delta.go @@ -0,0 +1,311 @@ +package vmd + +import ( + "slices" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +type BoneDelta struct { + Bone *pmx.Bone // ボーン + Frame int // キーフレーム + globalMatrix *mmath.MMat4 // グローバル行列 + localMatrix *mmath.MMat4 // ローカル行列 + globalPosition *mmath.MVec3 // グローバル位置 + framePosition *mmath.MVec3 // キーフレ位置の変動量 + frameMorphPosition *mmath.MVec3 // モーフ位置の変動量 + frameRotation *mmath.MQuaternion // キーフレ回転の変動量 + frameMorphRotation *mmath.MQuaternion // モーフ回転の変動量 + frameScale *mmath.MVec3 // キーフレスケールの変動量 + frameMorphScale *mmath.MVec3 // モーフスケールの変動量 + unitMatrix *mmath.MMat4 + *MorphFrameDelta +} + +func NewBoneDeltaByGlobalMatrix( + bone *pmx.Bone, frame int, globalMatrix *mmath.MMat4, parentDelta *BoneDelta, +) *BoneDelta { + var parentGlobalMatrix *mmath.MMat4 + if parentDelta != nil { + parentGlobalMatrix = parentDelta.GlobalMatrix() + } else { + parentGlobalMatrix = mmath.NewMMat4() + } + unitMatrix := parentGlobalMatrix.Muled(globalMatrix.Inverted()) + + return &BoneDelta{ + Bone: bone, + Frame: frame, + MorphFrameDelta: NewMorphFrameDelta(), + globalMatrix: globalMatrix, + localMatrix: bone.OffsetMatrix.Muled(globalMatrix), + unitMatrix: unitMatrix, + // 物理演算後の移動を受け取ると逆オフセットかけても一部モデルで破綻するので一旦コメントアウト + // framePosition: unitMatrix.Translation(), + frameRotation: unitMatrix.Quaternion(), + } +} + +func (bd *BoneDelta) GlobalMatrix() *mmath.MMat4 { + if bd.globalMatrix == nil { + bd.globalMatrix = mmath.NewMMat4() + } + return bd.globalMatrix +} + +func (bd *BoneDelta) LocalMatrix() *mmath.MMat4 { + if bd.localMatrix == nil { + // BOf行列: 自身のボーンのボーンオフセット行列をかけてローカル行列 + bd.localMatrix = bd.Bone.OffsetMatrix.Muled(bd.globalMatrix) + } + return bd.localMatrix +} + +func (bd *BoneDelta) GlobalPosition() *mmath.MVec3 { + if bd.globalPosition == nil { + if bd.globalMatrix != nil { + bd.globalPosition = bd.globalMatrix.Translation() + } else { + bd.globalPosition = mmath.NewMVec3() + } + } + return bd.globalPosition +} + +func (bd *BoneDelta) GlobalRotation() *mmath.MQuaternion { + return bd.GlobalMatrix().Quaternion() +} + +func (bd *BoneDelta) LocalPosition() *mmath.MVec3 { + pos := bd.FramePosition().Copy() + + if bd.frameMorphPosition != nil && !bd.frameMorphPosition.IsZero() { + pos.Add(bd.frameMorphPosition) + } + + // if bd.frameEffectPosition != nil && !bd.frameEffectPosition.IsZero() { + // pos.Add(bd.frameEffectPosition) + // } + + return pos +} + +func (bd *BoneDelta) LocalEffectorPosition(effectorFactor float64) *mmath.MVec3 { + pos := bd.FramePosition().Copy() + + if bd.frameMorphPosition != nil && !bd.frameMorphPosition.IsZero() { + pos.Add(bd.frameMorphPosition) + } + + // if bd.frameEffectPosition != nil && !bd.frameEffectPosition.IsZero() { + // pos.Add(bd.frameEffectPosition) + // } + + return pos.MuledScalar(effectorFactor) +} + +func (bd *BoneDelta) FramePosition() *mmath.MVec3 { + if bd.framePosition == nil { + bd.framePosition = mmath.NewMVec3() + } + return bd.framePosition +} + +func (bd *BoneDelta) FrameMorphPosition() *mmath.MVec3 { + if bd.frameMorphPosition == nil { + bd.frameMorphPosition = mmath.NewMVec3() + } + return bd.frameMorphPosition +} + +func (bd *BoneDelta) LocalRotation() *mmath.MQuaternion { + rot := bd.FrameRotation().Copy() + + if bd.frameMorphRotation != nil && !bd.frameMorphRotation.IsIdent() { + // rot = bd.frameMorphRotation.Muled(rot) + rot.Mul(bd.frameMorphRotation) + } + + if bd.Bone.HasFixedAxis() { + rot = rot.ToFixedAxisRotation(bd.Bone.NormalizedFixedAxis) + } + + return rot +} + +func (bd *BoneDelta) LocalEffectorRotation(effectorFactor float64) *mmath.MQuaternion { + return bd.LocalRotation().MuledScalar(effectorFactor) +} + +func (bd *BoneDelta) FrameRotation() *mmath.MQuaternion { + if bd.frameRotation == nil { + bd.frameRotation = mmath.NewMQuaternion() + } + return bd.frameRotation +} + +func (bd *BoneDelta) FrameMorphRotation() *mmath.MQuaternion { + if bd.frameMorphRotation == nil { + bd.frameMorphRotation = mmath.NewMQuaternion() + } + return bd.frameMorphRotation +} + +func (bd *BoneDelta) LocalScale() *mmath.MVec3 { + pos := bd.FrameScale().Copy() + + if bd.frameMorphScale != nil && !bd.frameMorphScale.IsZero() { + pos.Add(bd.frameMorphScale) + } + + return pos +} + +func (bd *BoneDelta) FrameScale() *mmath.MVec3 { + if bd.frameScale == nil { + bd.frameScale = &mmath.MVec3{1, 1, 1} + } + return bd.frameScale +} + +func (bd *BoneDelta) FrameMorphScale() *mmath.MVec3 { + if bd.frameMorphScale == nil { + bd.frameMorphScale = mmath.NewMVec3() + } + return bd.frameMorphScale +} + +func (bd *BoneDelta) Copy() *BoneDelta { + return &BoneDelta{ + Bone: bd.Bone, + Frame: bd.Frame, + globalMatrix: bd.GlobalMatrix().Copy(), + localMatrix: bd.LocalMatrix().Copy(), + globalPosition: bd.GlobalPosition().Copy(), + framePosition: bd.FramePosition().Copy(), + frameMorphPosition: bd.FrameMorphPosition().Copy(), + frameRotation: bd.FrameRotation().Copy(), + frameMorphRotation: bd.FrameMorphRotation().Copy(), + frameScale: bd.FrameScale().Copy(), + frameMorphScale: bd.FrameMorphScale().Copy(), + unitMatrix: bd.unitMatrix.Copy(), + MorphFrameDelta: bd.MorphFrameDelta.Copy(), + } +} + +func NewBoneDelta(bone *pmx.Bone, frame int) *BoneDelta { + return &BoneDelta{ + Bone: bone, + Frame: frame, + MorphFrameDelta: NewMorphFrameDelta(), + } +} + +type BoneDeltas struct { + Data []*BoneDelta + Bones *pmx.Bones +} + +func NewBoneDeltas(bones *pmx.Bones) *BoneDeltas { + return &BoneDeltas{ + Data: make([]*BoneDelta, bones.Len()), + Bones: bones, + } +} + +func (bds *BoneDeltas) Get(boneIndex int) *BoneDelta { + if boneIndex < 0 || boneIndex >= len(bds.Data) { + return nil + } + + return bds.Data[boneIndex] +} + +func (bds *BoneDeltas) GetByName(boneName string) *BoneDelta { + if _, ok := bds.Bones.NameIndexes[boneName]; ok { + return bds.Data[bds.Bones.NameIndexes[boneName]] + } + return nil +} + +func (bds *BoneDeltas) Update(boneDelta *BoneDelta) { + bds.Data[boneDelta.Bone.Index] = boneDelta +} + +func (bds *BoneDeltas) GetBoneIndexes() []int { + boneIndexes := make([]int, 0) + for key := range bds.Data { + if !slices.Contains(boneIndexes, key) { + boneIndexes = append(boneIndexes, key) + } + } + return boneIndexes +} + +func (bds *BoneDeltas) Contains(boneIndex int) bool { + return bds.Data[boneIndex] != nil +} + +func (bds *BoneDeltas) GetNearestBoneIndexes(worldPos *mmath.MVec3) []int { + boneIndexes := make([]int, 0) + distances := make([]float64, len(bds.Data)) + for i := range len(bds.Data) { + bd := bds.Get(i) + if bd == nil { + continue + } + distances[i] = worldPos.Distance(bd.GlobalPosition()) + } + if len(distances) == 0 { + return boneIndexes + } + sortedDistances := mmath.Float64Slice(distances) + sortedIndexes := mmath.ArgSort(sortedDistances) + nearestBone := bds.Get(sortedIndexes[0]) + for i := range sortedIndexes { + bd := bds.Get(sortedIndexes[i]) + if bd == nil { + continue + } + if len(boneIndexes) > 0 { + if !bd.GlobalPosition().NearEquals(nearestBone.GlobalPosition(), 0.01) { + break + } + } + boneIndexes = append(boneIndexes, sortedIndexes[i]) + } + return boneIndexes +} + +func (bds *BoneDeltas) LocalRotation(boneIndex int, loop int) *mmath.MQuaternion { + bd := bds.Get(boneIndex) + if bd == nil || loop > 10 { + return mmath.NewMQuaternion() + } + rot := bd.LocalRotation() + + if bd.Bone.IsEffectorRotation() { + // 付与親回転がある場合、再帰で回転を取得する + effectorRot := bds.LocalRotation(bd.Bone.EffectIndex, loop+1) + rot.Mul(effectorRot.MuledScalar(bd.Bone.EffectFactor)) + } + + return rot +} + +func (bds *BoneDeltas) LocalPosition(boneIndex int, loop int) *mmath.MVec3 { + bd := bds.Get(boneIndex) + if bd == nil || loop > 10 { + return mmath.NewMVec3() + } + pos := bd.LocalPosition() + + if bd.Bone.IsEffectorTranslation() { + // 付与親回転がある場合、再帰で回転を取得する + effectorPos := bds.LocalPosition(bd.Bone.EffectIndex, loop+1) + pos.Mul(effectorPos.MuledScalar(bd.Bone.EffectFactor)) + } + + return pos +} diff --git a/pkg/vmd/bone_frame.go b/pkg/vmd/bone_frame.go new file mode 100644 index 00000000..7ad38df5 --- /dev/null +++ b/pkg/vmd/bone_frame.go @@ -0,0 +1,222 @@ +package vmd + +import ( + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +type BoneFrame struct { + *BaseFrame // キーフレ + Position *mmath.MVec3 // 位置 + LocalPosition *mmath.MVec3 // ローカル位置 + Rotation *mmath.MQuaternion // 回転 + LocalRotation *mmath.MQuaternion // ローカル回転 + Scale *mmath.MVec3 // スケール + LocalScale *mmath.MVec3 // ローカルスケール + Curves *BoneCurves // 補間曲線 +} + +func NewBoneFrame(index int) *BoneFrame { + return &BoneFrame{ + BaseFrame: NewFrame(index).(*BaseFrame), + } +} + +func NullBoneFrame() *BoneFrame { + return nil +} + +func (bf *BoneFrame) Add(v *BoneFrame) *BoneFrame { + if bf.Position != nil || v.Position != nil { + if bf.Position == nil { + bf.Position = v.Position.Copy() + } else if v.Position != nil { + bf.Position.Add(v.Position) + } + } + if bf.LocalPosition != nil || v.LocalPosition != nil { + if bf.LocalPosition == nil { + bf.LocalPosition = v.LocalPosition.Copy() + } else if v.LocalPosition != nil { + bf.LocalPosition.Add(v.LocalPosition) + } + } + + if bf.Rotation != nil || v.Rotation != nil { + if bf.Rotation == nil { + bf.Rotation = v.Rotation.Copy() + } else if v.Rotation != nil { + bf.Rotation.Mul(v.Rotation) + } + } + + if bf.LocalRotation != nil || v.LocalRotation != nil { + if bf.LocalRotation == nil { + bf.LocalRotation = v.LocalRotation.Copy() + } else if v.LocalRotation != nil { + bf.LocalRotation.Mul(v.LocalRotation) + } + } + + if bf.Scale != nil || v.Scale != nil { + if bf.Scale == nil { + bf.Scale = v.Scale.Copy() + } else if v.Scale != nil { + bf.Scale.Add(v.Scale) + } + } + + if bf.LocalScale != nil || v.LocalScale != nil { + if bf.LocalScale == nil { + bf.LocalScale = v.LocalScale.Copy() + } else if v.LocalScale != nil { + bf.LocalScale.Add(v.LocalScale) + } + } + + return bf +} + +func (bf *BoneFrame) Added(v *BoneFrame) *BoneFrame { + copied := bf.Copy().(*BoneFrame) + return copied.Add(v) +} + +func (v *BoneFrame) Copy() IBaseFrame { + copied := &BoneFrame{ + BaseFrame: NewFrame(v.GetIndex()).(*BaseFrame), + } + if v.Position != nil { + copied.Position = v.Position.Copy() + } + if v.Rotation != nil { + copied.Rotation = v.Rotation.Copy() + } + if v.LocalPosition != nil { + copied.LocalPosition = v.LocalPosition.Copy() + } + if v.LocalRotation != nil { + copied.LocalRotation = v.LocalRotation.Copy() + } + if v.Scale != nil { + copied.Scale = v.Scale.Copy() + } + if v.LocalScale != nil { + copied.LocalScale = v.LocalScale.Copy() + } + if v.Curves != nil { + copied.Curves = v.Curves.Copy() + } + + return copied +} + +func (nextBf *BoneFrame) lerpFrame(prevFrame IBaseFrame, index int) IBaseFrame { + prevBf := prevFrame.(*BoneFrame) + + if prevBf == nil || nextBf.GetIndex() <= index { + // 前がないか、最後より後の場合、次のキーフレをコピーして返す + return nextBf.Copy().(*BoneFrame) + } + + bf := NewBoneFrame(index) + var xy, yy, zy, ry float64 + if nextBf.Curves == nil { + t := float64(index-prevBf.GetIndex()) / float64(nextBf.GetIndex()-prevBf.GetIndex()) + xy = t + yy = t + zy = t + ry = t + } else { + xy, yy, zy, ry = nextBf.Curves.Evaluate(prevBf.GetIndex(), index, nextBf.GetIndex()) + } + + bf.Rotation = prevBf.Rotation.Slerp(nextBf.Rotation, ry) + + plpx := 0.0 + plpy := 0.0 + plpz := 0.0 + if prevBf.LocalPosition != nil { + plpx = prevBf.LocalPosition.GetX() + plpy = prevBf.LocalPosition.GetY() + plpz = prevBf.LocalPosition.GetZ() + } + psx := 0.0 + psy := 0.0 + psz := 0.0 + if prevBf.Scale != nil { + psx = prevBf.Scale.GetX() + psy = prevBf.Scale.GetY() + psz = prevBf.Scale.GetZ() + } + plsx := 0.0 + plsy := 0.0 + plsz := 0.0 + if prevBf.LocalScale != nil { + plsx = prevBf.LocalScale.GetX() + plsy = prevBf.LocalScale.GetY() + plsz = prevBf.LocalScale.GetZ() + } + nlpx := 0.0 + nlpy := 0.0 + nlpz := 0.0 + if nextBf.LocalPosition != nil { + nlpx = nextBf.LocalPosition.GetX() + nlpy = nextBf.LocalPosition.GetY() + nlpz = nextBf.LocalPosition.GetZ() + } + nsx := 0.0 + nsy := 0.0 + nsz := 0.0 + if nextBf.Scale != nil { + nsx = nextBf.Scale.GetX() + nsy = nextBf.Scale.GetY() + nsz = nextBf.Scale.GetZ() + } + nlsx := 0.0 + nlsy := 0.0 + nlsz := 0.0 + if nextBf.LocalScale != nil { + nlsx = nextBf.LocalScale.GetX() + nlsy = nextBf.LocalScale.GetY() + nlsz = nextBf.LocalScale.GetZ() + } + + prevX := &mmath.MVec4{ + prevBf.Position.GetX(), plpx, psx, plsx} + nextX := &mmath.MVec4{ + nextBf.Position.GetX(), nlpx, nsx, nlsx} + nowX := prevX.Lerp(nextX, xy) + + prevY := &mmath.MVec4{ + prevBf.Position.GetY(), plpy, psy, plsy} + nextY := &mmath.MVec4{ + nextBf.Position.GetY(), nlpy, nsy, nlsy} + nowY := prevY.Lerp(nextY, yy) + + prevZ := &mmath.MVec4{ + prevBf.Position.GetZ(), plpz, psz, plsz} + nextZ := &mmath.MVec4{ + nextBf.Position.GetZ(), nlpz, nsz, nlsz} + nowZ := prevZ.Lerp(nextZ, zy) + + bf.Position = &mmath.MVec3{nowX[0], nowY[0], nowZ[0]} + bf.LocalPosition = &mmath.MVec3{nowX[1], nowY[1], nowZ[1]} + bf.Scale = &mmath.MVec3{nowX[2], nowY[2], nowZ[2]} + bf.LocalScale = &mmath.MVec3{nowX[3], nowY[3], nowZ[3]} + + return bf +} + +func (bf *BoneFrame) splitCurve(prevFrame IBaseFrame, nextFrame IBaseFrame, index int) { + nextBf := nextFrame.(*BoneFrame) + prevBf := prevFrame.(*BoneFrame) + + bf.Curves.TranslateX, nextBf.Curves.TranslateX = + mmath.SplitCurve(nextBf.Curves.TranslateX, prevBf.GetIndex(), bf.GetIndex(), nextBf.GetIndex()) + bf.Curves.TranslateY, nextBf.Curves.TranslateY = + mmath.SplitCurve(nextBf.Curves.TranslateY, prevBf.GetIndex(), bf.GetIndex(), nextBf.GetIndex()) + bf.Curves.TranslateZ, nextBf.Curves.TranslateZ = + mmath.SplitCurve(nextBf.Curves.TranslateZ, prevBf.GetIndex(), bf.GetIndex(), nextBf.GetIndex()) + bf.Curves.Rotate, nextBf.Curves.Rotate = + mmath.SplitCurve(nextBf.Curves.Rotate, prevBf.GetIndex(), bf.GetIndex(), nextBf.GetIndex()) +} diff --git a/pkg/vmd/bone_frames.go b/pkg/vmd/bone_frames.go new file mode 100644 index 00000000..4616032e --- /dev/null +++ b/pkg/vmd/bone_frames.go @@ -0,0 +1,1345 @@ +package vmd + +import ( + "fmt" + "log" + "math" + "os" + "path/filepath" + "strings" + "sync" + "time" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +type BoneFrames struct { + Data map[string]*BoneNameFrames + lock sync.RWMutex // マップアクセス制御用 +} + +func NewBoneFrames() *BoneFrames { + return &BoneFrames{ + Data: make(map[string]*BoneNameFrames, 0), + lock: sync.RWMutex{}, + } +} + +func (fs *BoneFrames) Contains(boneName string) bool { + fs.lock.RLock() + defer fs.lock.RUnlock() + + _, ok := fs.Data[boneName] + return ok +} + +func (fs *BoneFrames) Append(nfs *BoneNameFrames) { + fs.lock.Lock() + defer fs.lock.Unlock() + + fs.Data[nfs.Name] = nfs +} + +func (fs *BoneFrames) Delete(boneName string) { + fs.lock.Lock() + defer fs.lock.Unlock() + + delete(fs.Data, boneName) +} + +func (fs *BoneFrames) Get(boneName string) *BoneNameFrames { + if !fs.Contains(boneName) { + fs.Append(NewBoneNameFrames(boneName)) + } + + fs.lock.RLock() + defer fs.lock.RUnlock() + + return fs.Data[boneName] +} + +func (fs *BoneFrames) GetNames() []string { + names := make([]string, 0, len(fs.Data)) + for name := range fs.Data { + names = append(names, name) + } + return names +} + +func (fs *BoneFrames) GetIndexes() []int { + indexes := mcore.NewIntIndexes() + for _, fs := range fs.Data { + for _, f := range fs.List() { + indexes.ReplaceOrInsert(f.Index) + } + } + return indexes.List() +} + +func (fs *BoneFrames) GetRegisteredIndexes() []int { + indexes := mcore.NewIntIndexes() + for _, fs := range fs.Data { + for _, index := range fs.RegisteredIndexes.List() { + indexes.ReplaceOrInsert(mcore.NewInt(index)) + } + } + return indexes.List() +} + +func (fs *BoneFrames) Len() int { + count := 0 + for _, fs := range fs.Data { + count += fs.RegisteredIndexes.Len() + } + return count +} + +func (fs *BoneFrames) GetMaxFrame() int { + maxFno := int(0) + for _, fs := range fs.Data { + fno := fs.GetMaxFrame() + if fno > maxFno { + maxFno = fno + } + } + return maxFno +} + +func (fs *BoneFrames) GetMinFrame() int { + minFno := math.MaxInt + for _, fs := range fs.Data { + fno := fs.GetMinFrame() + if fno < minFno { + minFno = fno + } + } + return minFno +} + +func (fs *BoneFrames) Deform( + frame int, + model *pmx.PmxModel, + boneNames []string, + isCalcIk bool, + beforeBoneDeltas *BoneDeltas, + ikFrame *IkFrame, +) *BoneDeltas { + return fs.DeformByPhysicsFlag(frame, model, boneNames, isCalcIk, beforeBoneDeltas, nil, ikFrame, false) +} + +func (fs *BoneFrames) DeformByPhysicsFlag( + frame int, + model *pmx.PmxModel, + boneNames []string, + isCalcIk bool, + beforeBoneDeltas *BoneDeltas, + morphDeltas *MorphDeltas, + ikFrame *IkFrame, + isAfterPhysics bool, +) *BoneDeltas { + // mlog.Memory(fmt.Sprintf("Deform 1)frame: %d", frame)) + deformBoneIndexes, boneDeltas := fs.prepareDeltas(frame, model, boneNames, isCalcIk, + beforeBoneDeltas, morphDeltas, ikFrame, isAfterPhysics) + // mlog.Memory(fmt.Sprintf("Deform 2)frame: %d", frame)) + boneDeltas = fs.calcBoneDeltas(frame, model, deformBoneIndexes, boneDeltas) + // mlog.Memory(fmt.Sprintf("Deform 3)frame: %d", frame)) + return boneDeltas +} + +func (fs *BoneFrames) prepareDeltas( + frame int, + model *pmx.PmxModel, + boneNames []string, + isCalcIk bool, + beforeBoneDeltas *BoneDeltas, + morphDeltas *MorphDeltas, + ikFrame *IkFrame, + isAfterPhysics bool, +) ([]int, *BoneDeltas) { + // mlog.Memory(fmt.Sprintf("prepareDeltas 1)frame: %d", frame)) + + deformBoneIndexes, boneDeltas := fs.createBoneDeltas(frame, model, boneNames, beforeBoneDeltas, isAfterPhysics) + + // mlog.Memory(fmt.Sprintf("prepareDeltas 2)frame: %d", frame)) + + // IK事前計算 + if isCalcIk { + // ボーン変形行列操作 + boneDeltas = fs.prepareIk(frame, model, deformBoneIndexes, boneDeltas, morphDeltas, ikFrame, isAfterPhysics) + } + + // mlog.Memory(fmt.Sprintf("prepareDeltas 3)frame: %d", frame)) + + // ボーンデフォーム情報を埋める + boneDeltas = fs.fillBoneDeform(frame, model, deformBoneIndexes, boneDeltas, morphDeltas) + + // mlog.Memory(fmt.Sprintf("prepareDeltas 4)frame: %d", frame)) + + return deformBoneIndexes, boneDeltas +} + +// IK事前計算処理 +func (fs *BoneFrames) prepareIk( + frame int, + model *pmx.PmxModel, + deformBoneIndexes []int, + boneDeltas *BoneDeltas, + morphDeltas *MorphDeltas, + ikFrame *IkFrame, + isAfterPhysics bool, +) *BoneDeltas { + for i, boneIndex := range deformBoneIndexes { + // ボーンIndexがIkTreeIndexesに含まれていない場合、スルー + if _, ok := model.Bones.IkTreeIndexes[boneIndex]; !ok { + continue + } + + for m := range len(model.Bones.IkTreeIndexes[boneIndex]) { + ikBone := model.Bones.Get(model.Bones.IkTreeIndexes[boneIndex][m]) + + if ikFrame == nil || ikFrame.IsEnable(ikBone.Name) { + var prefixPath string + if mlog.IsIkVerbose() { + // IK計算デバッグ用モーション + dirPath := fmt.Sprintf("%s/IK_step", filepath.Dir(model.Path)) + err := os.MkdirAll(dirPath, 0755) + if err != nil { + log.Fatal(err) + } + + date := time.Now().Format("20060102_150405") + prefixPath = fmt.Sprintf("%s/%04d_%s_%03d_%03d", dirPath, frame, date, i, m) + } + + boneDeltas = fs.calcIk(frame, ikBone, model, boneDeltas, morphDeltas, isAfterPhysics, ikFrame, prefixPath) + } + } + } + + return boneDeltas +} + +// IK計算 +func (fs *BoneFrames) calcIk( + frame int, + ikBone *pmx.Bone, + model *pmx.PmxModel, + boneDeltas *BoneDeltas, + morphDeltas *MorphDeltas, + isAfterPhysics bool, + ikFrame *IkFrame, + prefixPath string, +) *BoneDeltas { + if len(ikBone.Ik.Links) < 1 { + // IKリンクが無ければスルー + return boneDeltas + } + + var err error + var ikFile *os.File + var ikMotion *VmdMotion + count := 1 + + if mlog.IsIkVerbose() { + // IK計算デバッグ用モーション + ikMotionPath := fmt.Sprintf("%s_%s.vmd", prefixPath, ikBone.Name) + ikMotion = NewVmdMotion(ikMotionPath) + + ikLogPath := fmt.Sprintf("%s_%s.log", prefixPath, ikBone.Name) + ikFile, err = os.OpenFile(ikLogPath, os.O_WRONLY|os.O_CREATE, 0666) + if err != nil { + fmt.Println(err) + os.Exit(1) + } + + fmt.Println(ikFile, "----------------------------------------") + fmt.Println(ikFile, "[IK計算出力先][%04d][%s] %s", frame, ikMotionPath) + } + defer func() { + mlog.IV("[IK計算終了][%04d][%s]", frame, ikBone.Name) + + if ikMotion != nil { + ikMotion.Save("", "") + } + if ikFile != nil { + ikFile.Close() + } + }() + + // つま先ＩＫであるか + isToeIk := strings.Contains(ikBone.Name, "つま先ＩＫ") + // 一段IKであるか + isSingleIk := len(ikBone.Ik.Links) == 1 + + // ループ回数 + loopCount := max(ikBone.Ik.LoopCount, 1) + if isToeIk { + // つま先IKの場合、初回に足首位置に向けるのでループ1回分余分に回す + loopCount += 1 + } + + // IKターゲットボーン + effectorBone := model.Bones.Get(ikBone.Ik.BoneIndex) + // IK関連の行列を一括計算 + ikDeltas := fs.DeformByPhysicsFlag(frame, model, []string{ikBone.Name}, false, + boneDeltas, nil, ikFrame, false) + if isAfterPhysics { + // 物理後の場合は物理後のも取得する + ikDeltas = fs.DeformByPhysicsFlag(frame, model, []string{ikBone.Name}, false, + ikDeltas, nil, ikFrame, true) + } + if !ikDeltas.Contains(ikBone.Index) { + // IKボーンが存在しない場合、スルー + return boneDeltas + } + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + ikOffMotion := NewVmdMotion(fmt.Sprintf("%s_0_%s.vmd", prefixPath, ikBone.Name)) + + bif := NewIkFrame(0) + bif.Registered = true + + for _, bone := range model.Bones.Data { + if bone.IsIK() { + ef := NewIkEnableFrame(0) + ef.Registered = true + ef.BoneName = bone.Name + ef.Enabled = false + + bif.IkList = append(bif.IkList, ef) + } + } + + ikOffMotion.AppendIkFrame(bif) + + for _, ikDelta := range ikDeltas.Data { + if ikDelta == nil { + continue + } + bf := NewBoneFrame(0) + bf.Position = ikDelta.framePosition + bf.Rotation = ikDelta.frameRotation + ikOffMotion.AppendRegisteredBoneFrame(ikDelta.Bone.Name, bf) + } + + ikOffMotion.Save("IK OFF", "") + } + + var ikOffDeltas *BoneDeltas + if isToeIk { + ikOffDeltas = fs.DeformByPhysicsFlag(frame, model, []string{effectorBone.Name}, false, + nil, nil, ikFrame, isAfterPhysics) + if !ikOffDeltas.Contains(effectorBone.Index) { + // IK OFFボーンが存在しない場合、スルー + return boneDeltas + } + } + + // エフェクタ関連情報取得 + effectorDeformBoneIndexes, boneDeltas := + fs.prepareDeltas(frame, model, []string{effectorBone.Name}, false, boneDeltas, nil, ikFrame, false) + if isAfterPhysics { + // 物理後の場合は物理後のも取得する + effectorDeformBoneIndexes, boneDeltas = + fs.prepareDeltas(frame, model, []string{effectorBone.Name}, false, boneDeltas, nil, ikFrame, true) + } + if !boneDeltas.Contains(effectorBone.Index) || !boneDeltas.Contains(ikBone.Index) || + !boneDeltas.Contains(ikBone.Ik.BoneIndex) { + // エフェクタボーンが存在しない場合、スルー + return boneDeltas + } + + // IK計算 +ikLoop: + for loop := 0; loop < loopCount; loop++ { + for lidx, ikLink := range ikBone.Ik.Links { + // ikLink は末端から並んでる + if !model.Bones.Contains(ikLink.BoneIndex) { + continue + } + + // 処理対象IKリンクボーン + linkBone := model.Bones.Get(ikLink.BoneIndex) + + // 角度制限があってまったく動かさない場合、IK計算しないで次に行く + if (linkBone.AngleLimit && + linkBone.MinAngleLimit.GetRadians().IsZero() && + linkBone.MaxAngleLimit.GetRadians().IsZero()) || + (linkBone.LocalAngleLimit && + linkBone.LocalMinAngleLimit.GetRadians().IsZero() && + linkBone.LocalMaxAngleLimit.GetRadians().IsZero()) { + continue + } + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d] -------------------------------------------- \n", + frame, loop, linkBone.Name, count-1) + } + + for _, l := range ikBone.Ik.Links { + if boneDeltas.Get(l.BoneIndex) != nil { + boneDeltas.Get(l.BoneIndex).unitMatrix = nil + } + } + if boneDeltas.Get(ikBone.Ik.BoneIndex) != nil { + boneDeltas.Get(ikBone.Ik.BoneIndex).unitMatrix = nil + } + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + bf := NewBoneFrame(count) + bf.Position = ikDeltas.Get(ikBone.Index).FramePosition() + bf.Rotation = ikDeltas.Get(ikBone.Index).LocalRotation() + ikMotion.AppendRegisteredBoneFrame(ikBone.Name, bf) + count++ + + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Local] ikGlobalPosition: %s\n", + frame, loop, linkBone.Name, count-1, bf.Position.MMD().String()) + } + + // IK関連の行列を取得 + boneDeltas = fs.calcBoneDeltas(frame, model, effectorDeformBoneIndexes, boneDeltas) + + // リンクボーンの変形情報を取得 + linkDelta := boneDeltas.Get(linkBone.Index) + if linkDelta == nil { + linkDelta = &BoneDelta{Bone: linkBone, Frame: frame} + } + linkQuat := linkDelta.LocalRotation() + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + bf := NewBoneFrame(count) + bf.Rotation = linkQuat.Copy() + ikMotion.AppendRegisteredBoneFrame(linkBone.Name, bf) + count++ + + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][linkQuat] %s(%s)\n", + frame, loop, linkBone.Name, count-1, bf.Rotation.String(), bf.Rotation.ToMMDDegrees().String(), + ) + } + + // IKボーンのグローバル位置 + ikGlobalPosition := ikDeltas.Get(ikBone.Index).GlobalPosition() + + // 現在のIKターゲットボーンのグローバル位置を取得 + effectorGlobalPosition := boneDeltas.Get(effectorBone.Index).GlobalPosition() + + // 初回にIK事前計算 + if loop == 0 && isToeIk && ikOffDeltas != nil { + // IK OFF 時の IKターゲットボーンのグローバル位置を取得 + ikGlobalPosition = ikOffDeltas.Get(effectorBone.Index).GlobalPosition() + // 現在のIKターゲットボーンのグローバル位置を取得 + effectorGlobalPosition = ikDeltas.Get(effectorBone.Index).GlobalPosition() + } + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][Global] [%s]ikGlobalPosition: %s, "+ + "[%s]effectorGlobalPosition: %s, [%s]linkGlobalPosition: %s\n", + frame, loop, linkBone.Name, count-1, + ikBone.Name, ikGlobalPosition.MMD().String(), + effectorBone.Name, effectorGlobalPosition.MMD().String(), + linkBone.Name, boneDeltas.Get(linkBone.Index).GlobalPosition().MMD().String()) + } + + // 注目ノード（実際に動かすボーン=リンクボーン） + // ワールド座標系から注目ノードの局所座標系への変換 + linkInvMatrix := boneDeltas.Get(linkBone.Index).GlobalMatrix().Inverted() + // 注目ノードを起点とした、エフェクタのローカル位置 + effectorLocalPosition := linkInvMatrix.MulVec3(effectorGlobalPosition) + // 注目ノードを起点とした、IK目標のローカル位置 + ikLocalPosition := linkInvMatrix.MulVec3(ikGlobalPosition) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][Local] effectorLocalPosition: %s, ikLocalPosition: %s (%f)\n", + frame, loop, linkBone.Name, count-1, + effectorLocalPosition.MMD().String(), ikLocalPosition.MMD().String(), + effectorLocalPosition.Distance(ikLocalPosition)) + } + + distanceThreshold := effectorLocalPosition.Distance(ikLocalPosition) + if distanceThreshold < 1e-5 { + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][Local] ***BREAK*** distanceThreshold: %f\n", + frame, loop, linkBone.Name, count-1, distanceThreshold) + } + + break ikLoop + } + + effectorLocalPosition.Normalize() + ikLocalPosition.Normalize() + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][Local] effectorLocalPositionNorm: %s, ikLocalPositionNorm: %s\n", + frame, loop, linkBone.Name, count-1, + effectorLocalPosition.MMD().String(), ikLocalPosition.MMD().String()) + } + + // 単位角 + unitRad := ikBone.Ik.UnitRotation.GetRadians().GetX() * float64(lidx+1) + linkDot := ikLocalPosition.Dot(effectorLocalPosition) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][回転角度] unitRad: %.8f (%.5f), linkDot: %.8f\n", + frame, loop, linkBone.Name, count-1, unitRad, mmath.ToDegree(unitRad), linkDot, + ) + } + + // 回転角(ラジアン) + // 単位角を超えないようにする + originalLinkAngle := math.Acos(mmath.ClampedFloat(linkDot, -1, 1)) + linkAngle := mmath.ClampedFloat(originalLinkAngle, -unitRad, unitRad) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][単位角制限] linkAngle: %.8f(%.5f), originalLinkAngle: %.8f(%.5f)\n", + frame, loop, linkBone.Name, count-1, linkAngle, mmath.ToDegree(linkAngle), + originalLinkAngle, mmath.ToDegree(originalLinkAngle), + ) + } + + // 角度がほとんどない場合 + angleThreshold := math.Abs(linkAngle) + if angleThreshold < 1e-5 { + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][Local] ***BREAK*** angleThreshold: %f\n", + frame, loop, linkBone.Name, count-1, angleThreshold) + } + + break ikLoop + } + + // 回転軸 + var originalLinkAxis, linkAxis *mmath.MVec3 + // 一段IKでない場合、または一段IKでかつ回転角が88度以上の場合 + if !isSingleIk || (isSingleIk && linkAngle > mmath.GIMBAL1_RAD) && ikLink.AngleLimit { + // グローバル軸制限 + linkAxis, originalLinkAxis = fs.getLinkAxis( + ikLink.MinAngleLimit.GetRadians(), + ikLink.MaxAngleLimit.GetRadians(), + effectorLocalPosition, ikLocalPosition, + frame, count, loop, linkBone.Name, ikMotion, ikFile, + ) + } else if !isSingleIk || (isSingleIk && linkAngle > mmath.GIMBAL1_RAD) && ikLink.LocalAngleLimit { + // ローカル軸制限 + linkAxis, originalLinkAxis = fs.getLinkAxis( + ikLink.LocalMinAngleLimit.GetRadians(), + ikLink.LocalMaxAngleLimit.GetRadians(), + effectorLocalPosition, ikLocalPosition, + frame, count, loop, linkBone.Name, ikMotion, ikFile, + ) + } else { + // 軸制限なし or 一段IKでかつ回転角が88度未満の場合 + linkAxis, originalLinkAxis = fs.getLinkAxis( + mmath.MVec3MinVal, + mmath.MVec3MaxVal, + effectorLocalPosition, ikLocalPosition, + frame, count, loop, linkBone.Name, ikMotion, ikFile, + ) + } + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][回転軸] linkAxis: %s, originalLinkAxis: %s\n", + frame, loop, linkBone.Name, count-1, linkAxis.String(), originalLinkAxis.String(), + ) + } + + originalIkQuat := mmath.NewMQuaternionFromAxisAnglesRotate(originalLinkAxis, originalLinkAngle) + ikQuat := mmath.NewMQuaternionFromAxisAnglesRotate(linkAxis, linkAngle) + + originalTotalIkQuat := linkQuat.Muled(originalIkQuat) + totalIkQuat := linkQuat.Muled(ikQuat) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + { + bf := NewBoneFrame(count) + bf.Rotation = originalTotalIkQuat.Copy() + ikMotion.AppendRegisteredBoneFrame(linkBone.Name, bf) + count++ + + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][originalTotalIkQuat] %s(%s)\n", + frame, loop, linkBone.Name, count-1, originalTotalIkQuat.String(), originalTotalIkQuat.ToMMDDegrees().String()) + + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][originalIkQuat] %s(%s)\n", + frame, loop, linkBone.Name, count-1, originalIkQuat.String(), originalIkQuat.ToMMDDegrees().String()) + } + { + bf := NewBoneFrame(count) + bf.Rotation = totalIkQuat.Copy() + ikMotion.AppendRegisteredBoneFrame(linkBone.Name, bf) + count++ + + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][totalIkQuat] %s(%s)\n", + frame, loop, linkBone.Name, count-1, totalIkQuat.String(), totalIkQuat.ToMMDDegrees().String()) + + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][ikQuat] %s(%s)\n", + frame, loop, linkBone.Name, count-1, ikQuat.String(), ikQuat.ToMMDDegrees().String()) + } + } + + var resultIkQuat *mmath.MQuaternion + if ikLink.AngleLimit { + // 角度制限が入ってる場合 + resultIkQuat, count = fs.calcIkLimitQuaternion( + totalIkQuat, + ikLink.MinAngleLimit.GetRadians(), + ikLink.MaxAngleLimit.GetRadians(), + mmath.MVec3UnitX, mmath.MVec3UnitY, mmath.MVec3UnitZ, + loop, loopCount, + frame, count, linkBone.Name, ikMotion, ikFile, + ) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + bf := NewBoneFrame(count) + bf.Rotation = resultIkQuat.Copy() + ikMotion.AppendRegisteredBoneFrame(linkBone.Name, bf) + count++ + + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][角度制限後] resultIkQuat: %s(%s), totalIkQuat: %s(%s), ikQuat: %s(%s)\n", + frame, loop, linkBone.Name, count-1, resultIkQuat.String(), resultIkQuat.ToMMDDegrees().String(), + totalIkQuat.String(), totalIkQuat.ToMMDDegrees().String(), + ikQuat.String(), ikQuat.ToMMDDegrees().String()) + } + } else if ikLink.LocalAngleLimit { + // ローカル角度制限が入ってる場合 + resultIkQuat, count = fs.calcIkLimitQuaternion( + totalIkQuat, + ikLink.LocalMinAngleLimit.GetRadians(), + ikLink.LocalMaxAngleLimit.GetRadians(), + linkBone.NormalizedLocalAxisX, linkBone.NormalizedLocalAxisY, linkBone.NormalizedLocalAxisZ, + loop, loopCount, + frame, count, linkBone.Name, ikMotion, ikFile, + ) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + bf := NewBoneFrame(count) + bf.Rotation = resultIkQuat.Copy() + ikMotion.AppendRegisteredBoneFrame(linkBone.Name, bf) + count++ + + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][ローカル角度制限後] resultIkQuat: %s(%s), totalIkQuat: %s(%s), ikQuat: %s(%s)\n", + frame, loop, linkBone.Name, count-1, resultIkQuat.String(), resultIkQuat.ToMMDDegrees().String(), + totalIkQuat.String(), totalIkQuat.ToMMDDegrees().String(), + ikQuat.String(), ikQuat.ToMMDDegrees().String()) + } + } else { + // 角度制限なしの場合 + resultIkQuat = totalIkQuat + } + + if loop == 0 && morphDeltas != nil && morphDeltas.Bones != nil && + morphDeltas.Bones.Get(linkBone.Index) != nil && + morphDeltas.Bones.Get(linkBone.Index).frameRotation != nil { + // モーフ変形がある場合、モーフ変形を追加適用 + resultIkQuat = resultIkQuat.Muled(morphDeltas.Bones.Get(linkBone.Index).frameRotation) + } + + if linkBone.HasFixedAxis() { + // 軸制限ありの場合、軸にそった理想回転量とする + resultIkQuat = resultIkQuat.ToFixedAxisRotation(linkBone.FixedAxis) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + bf := NewBoneFrame(count) + bf.Rotation = resultIkQuat.Copy() + ikMotion.AppendRegisteredBoneFrame(linkBone.Name, bf) + count++ + + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][軸制限後] resultIkQuat: %s(%s)\n", + frame, loop, linkBone.Name, count-1, resultIkQuat.String(), resultIkQuat.ToMMDDegrees().String()) + } + } + + // IKの結果を更新 + linkDelta.frameRotation = resultIkQuat + boneDeltas.Update(linkDelta) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + bf := NewBoneFrame(count) + bf.Rotation = linkDelta.LocalRotation().Copy() + ikMotion.AppendRegisteredBoneFrame(linkBone.Name, bf) + count++ + + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][結果] bf.Rotation: %s(%s)\n", + frame, loop, linkBone.Name, count-1, bf.Rotation.String(), bf.Rotation.ToMMDDegrees().String()) + } + } + } + + return boneDeltas +} + +func (fs *BoneFrames) getLinkAxis( + minAngleLimitRadians *mmath.MVec3, + maxAngleLimitRadians *mmath.MVec3, + effectorLocalPosition, ikLocalPosition *mmath.MVec3, + frame int, + count int, + loop int, + linkBoneName string, + ikMotion *VmdMotion, + ikFile *os.File, +) (*mmath.MVec3, *mmath.MVec3) { + // 回転軸 + linkAxis := effectorLocalPosition.Cross(ikLocalPosition).Normalize() + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][linkAxis] %s\n", + frame, loop, linkBoneName, count-1, linkAxis.MMD().String(), + ) + } + + // linkMat := linkQuat.ToMat4() + // if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + // fmt.Fprintf(ikFile, + // "[%04d][%03d][%s][%05d][linkMat] %s (x: %s, y: %s, z: %s)\n", + // frame, loop, linkBoneName, count-1, linkMat.String(), linkMat.AxisX().String(), linkMat.AxisY().String(), linkMat.AxisZ().String()) + // } + + if minAngleLimitRadians.IsOnlyX() || maxAngleLimitRadians.IsOnlyX() { + // X軸のみの制限の場合 + vv := linkAxis.GetX() + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][linkAxis(X軸制限)] vv: %.8f\n", + frame, loop, linkBoneName, count-1, vv) + } + + if vv < 0 { + return mmath.MVec3UnitXInv, linkAxis + } + return mmath.MVec3UnitX, linkAxis + } else if minAngleLimitRadians.IsOnlyY() || maxAngleLimitRadians.IsOnlyY() { + // Y軸のみの制限の場合 + vv := linkAxis.GetY() + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][linkAxis(Y軸制限)] vv: %.8f\n", + frame, loop, linkBoneName, count-1, vv) + } + + if vv < 0 { + return mmath.MVec3UnitYInv, linkAxis + } + return mmath.MVec3UnitY, linkAxis + } else if minAngleLimitRadians.IsOnlyZ() || maxAngleLimitRadians.IsOnlyZ() { + // Z軸のみの制限の場合 + vv := linkAxis.GetZ() + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][linkAxis(Z軸制限)] vv: %.8f\n", + frame, loop, linkBoneName, count-1, vv) + } + + if vv < 0 { + return mmath.MVec3UnitZInv, linkAxis + } + return mmath.MVec3UnitZ, linkAxis + } + + return linkAxis, linkAxis +} + +func (fs *BoneFrames) calcIkLimitQuaternion( + totalIkQuat *mmath.MQuaternion, // リンクボーンの全体回転量 + minAngleLimitRadians *mmath.MVec3, // 最小軸制限（ラジアン） + maxAngleLimitRadians *mmath.MVec3, // 最大軸制限（ラジアン） + xAxisVector *mmath.MVec3, // X軸ベクトル + yAxisVector *mmath.MVec3, // Y軸ベクトル + zAxisVector *mmath.MVec3, // Z軸ベクトル + loop int, // ループ回数 + loopCount int, // ループ総回数 + frame int, // キーフレーム + count int, // デバッグ用: キーフレ位置 + linkBoneName string, // デバッグ用: リンクボーン名 + ikMotion *VmdMotion, // デバッグ用: IKモーション + ikFile *os.File, // デバッグ用: IKファイル +) (*mmath.MQuaternion, int) { + ikMat := totalIkQuat.ToMat4() + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, + "[%04d][%03d][%s][%05d][ikMat] %s (x: %s, y: %s, z: %s)\n", + frame, loop, linkBoneName, count-1, ikMat.String(), ikMat.AxisX().String(), ikMat.AxisY().String(), ikMat.AxisZ().String()) + } + + // 軸回転角度を算出 + if minAngleLimitRadians.GetX() > -mmath.HALF_RAD && maxAngleLimitRadians.GetX() < mmath.HALF_RAD { + // Z*X*Y順 + // X軸回り + fSX := -ikMat.AxisZ().GetY() // sin(θx) = -m32 + fX := math.Asin(fSX) // X軸回り決定 + fCX := math.Cos(fX) // cos(θx) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][X軸制限] fSX: %f, fX: %f, fCX: %f\n", + frame, loop, linkBoneName, count-1, fSX, fX, fCX) + } + + // ジンバルロック回避 + if math.Abs(fX) > mmath.GIMBAL1_RAD { + if fX < 0 { + fX = -mmath.GIMBAL1_RAD + } else { + fX = mmath.GIMBAL1_RAD + } + fCX = math.Cos(fX) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][X軸制限-ジンバル] fSX: %f, fX: %f, fCX: %f\n", + frame, loop, linkBoneName, count-1, fSX, fX, fCX) + } + } + + // Y軸回り + fSY := ikMat.AxisZ().GetX() / fCX // sin(θy) = m31 / cos(θx) + fCY := ikMat.AxisZ().GetZ() / fCX // cos(θy) = m33 / cos(θx) + fY := math.Atan2(fSY, fCY) // Y軸回り決定 + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][X軸制限-Y軸回り] fSY: %f, fCY: %f, fY: %f\n", + frame, loop, linkBoneName, count-1, fSY, fCY, fY) + } + + // Z軸周り + fSZ := ikMat.AxisX().GetY() / fCX // sin(θz) = m12 / cos(θx) + fCZ := ikMat.AxisY().GetY() / fCX // cos(θz) = m22 / cos(θx) + fZ := math.Atan2(fSZ, fCZ) // Z軸回り決定 + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][X軸制限-Z軸回り] fSZ: %f, fCZ: %f, fZ: %f\n", + frame, loop, linkBoneName, count-1, fSZ, fCZ, fZ) + } + + // 角度の制限 + fX = fs.getIkAxisValue(fX, minAngleLimitRadians.GetX(), maxAngleLimitRadians.GetX(), loop, loopCount, + frame, count, "X軸制限-X", linkBoneName, ikMotion, ikFile) + fY = fs.getIkAxisValue(fY, minAngleLimitRadians.GetY(), maxAngleLimitRadians.GetY(), loop, loopCount, + frame, count, "X軸制限-Y", linkBoneName, ikMotion, ikFile) + fZ = fs.getIkAxisValue(fZ, minAngleLimitRadians.GetZ(), maxAngleLimitRadians.GetZ(), loop, loopCount, + frame, count, "X軸制限-Z", linkBoneName, ikMotion, ikFile) + + // 決定した角度でベクトルを回転 + xQuat := mmath.NewMQuaternionFromAxisAnglesRotate(xAxisVector, fX) + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][X軸制限-xQuat] xAxisVector: %s, fX: %f, xQuat: %s(%s)\n", + frame, loop, linkBoneName, count-1, xAxisVector.String(), fX, xQuat.String(), xQuat.ToMMDDegrees().String()) + } + + yQuat := mmath.NewMQuaternionFromAxisAnglesRotate(yAxisVector, fY) + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][X軸制限-yQuat] yAxisVector: %s, fY: %f, yQuat: %s(%s)\n", + frame, loop, linkBoneName, count-1, yAxisVector.String(), fY, yQuat.String(), yQuat.ToMMDDegrees().String()) + } + + zQuat := mmath.NewMQuaternionFromAxisAnglesRotate(zAxisVector, fZ) + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][X軸制限-zQuat] zAxisVector: %s, fZ: %f, zQuat: %s(%s)\n", + frame, loop, linkBoneName, count-1, zAxisVector.String(), fZ, zQuat.String(), zQuat.ToMMDDegrees().String()) + } + + return yQuat.Muled(xQuat).Muled(zQuat), count + } else if minAngleLimitRadians.GetY() > -mmath.HALF_RAD && maxAngleLimitRadians.GetY() < mmath.HALF_RAD { + // X*Y*Z順 + // Y軸回り + fSY := -ikMat.AxisX().GetZ() // sin(θy) = m13 + fY := math.Asin(fSY) // Y軸回り決定 + fCY := math.Cos(fY) // cos(θy) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Y軸制限] fSY: %f, fY: %f, fCY: %f\n", + frame, loop, linkBoneName, count-1, fSY, fY, fCY) + } + + // ジンバルロック回避 + if math.Abs(fY) > mmath.GIMBAL1_RAD { + if fY < 0 { + fY = -mmath.GIMBAL1_RAD + } else { + fY = mmath.GIMBAL1_RAD + } + fCY = math.Cos(fY) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Y軸制限-ジンバル] fSY: %f, fY: %f, fCY: %f\n", + frame, loop, linkBoneName, count-1, fSY, fY, fCY) + } + } + + // X軸回り + fSX := ikMat.AxisY().GetZ() / fCY // sin(θx) = m23 / cos(θy) + fCX := ikMat.AxisZ().GetZ() / fCY // cos(θx) = m33 / cos(θy) + fX := math.Atan2(fSX, fCX) // X軸回り決定 + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Y軸制限-X軸回り] fSX: %f, fCX: %f, fX: %f\n", + frame, loop, linkBoneName, count-1, fSX, fCX, fX) + } + + // Z軸周り + fSZ := ikMat.AxisX().GetY() / fCY // sin(θz) = m12 / cos(θy) + fCZ := ikMat.AxisX().GetX() / fCY // cos(θz) = m11 / cos(θy) + fZ := math.Atan2(fSZ, fCZ) // Z軸回り決定 + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Y軸制限-Z軸回り] fSZ: %f, fCZ: %f, fZ: %f\n", + frame, loop, linkBoneName, count-1, fSZ, fCZ, fZ) + } + + // 角度の制限 + fX = fs.getIkAxisValue(fX, minAngleLimitRadians.GetX(), maxAngleLimitRadians.GetX(), loop, loopCount, + frame, count, "Y軸制限-X", linkBoneName, ikMotion, ikFile) + fY = fs.getIkAxisValue(fY, minAngleLimitRadians.GetY(), maxAngleLimitRadians.GetY(), loop, loopCount, + frame, count, "Y軸制限-Y", linkBoneName, ikMotion, ikFile) + fZ = fs.getIkAxisValue(fZ, minAngleLimitRadians.GetZ(), maxAngleLimitRadians.GetZ(), loop, loopCount, + frame, count, "Y軸制限-Z", linkBoneName, ikMotion, ikFile) + + // 決定した角度でベクトルを回転 + xQuat := mmath.NewMQuaternionFromAxisAnglesRotate(xAxisVector, fX) + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Y軸制限-xQuat] xAxisVector: %s, fX: %f, xQuat: %s(%s)\n", + frame, loop, linkBoneName, count-1, xAxisVector.String(), fX, xQuat.String(), xQuat.ToMMDDegrees().String()) + } + + yQuat := mmath.NewMQuaternionFromAxisAnglesRotate(yAxisVector, fY) + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Y軸制限-yQuat] yAxisVector: %s, fY: %f, yQuat: %s(%s)\n", + frame, loop, linkBoneName, count-1, yAxisVector.String(), fY, yQuat.String(), yQuat.ToMMDDegrees().String()) + } + + zQuat := mmath.NewMQuaternionFromAxisAnglesRotate(zAxisVector, fZ) + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Y軸制限-zQuat] zAxisVector: %s, fZ: %f, zQuat: %s(%s)\n", + frame, loop, linkBoneName, count-1, zAxisVector.String(), fZ, zQuat.String(), zQuat.ToMMDDegrees().String()) + } + + return zQuat.Muled(yQuat).Muled(xQuat), count + } + + // Y*Z*X順 + // Z軸回り + fSZ := -ikMat.AxisY().GetX() // sin(θz) = m21 + fZ := math.Asin(fSZ) // Z軸回り決定 + fCZ := math.Cos(fZ) // cos(θz) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Z軸制限] fSZ: %f, fZ: %f, fCZ: %f\n", + frame, loop, linkBoneName, count-1, fSZ, fZ, fCZ) + } + + // ジンバルロック回避 + if math.Abs(fZ) > mmath.GIMBAL1_RAD { + if fZ < 0 { + fZ = -mmath.GIMBAL1_RAD + } else { + fZ = mmath.GIMBAL1_RAD + } + fCZ = math.Cos(fZ) + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Z軸制限-ジンバル] fSZ: %f, fZ: %f, fCZ: %f\n", + frame, loop, linkBoneName, count-1, fSZ, fZ, fCZ) + } + } + + // X軸回り + fSX := ikMat.AxisY().GetZ() / fCZ // sin(θx) = m23 / cos(θz) + fCX := ikMat.AxisY().GetY() / fCZ // cos(θx) = m22 / cos(θz) + fX := math.Atan2(fSX, fCX) // X軸回り決定 + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Z軸制限-X軸回り] fSX: %f, fCX: %f, fX: %f\n", + frame, loop, linkBoneName, count-1, fSX, fCX, fX) + } + + // Y軸周り + fSY := ikMat.AxisZ().GetX() / fCZ // sin(θy) = m31 / cos(θz) + fCY := ikMat.AxisX().GetX() / fCZ // cos(θy) = m11 / cos(θz) + fY := math.Atan2(fSY, fCY) // Y軸回り決定 + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Z軸制限-Y軸回り] fSY: %f, fCY: %f, fY: %f\n", + frame, loop, linkBoneName, count-1, fSY, fCY, fY) + } + + // 角度の制限 + fX = fs.getIkAxisValue(fX, minAngleLimitRadians.GetX(), maxAngleLimitRadians.GetX(), loop, loopCount, + frame, count, "Z軸制限-X", linkBoneName, ikMotion, ikFile) + fY = fs.getIkAxisValue(fY, minAngleLimitRadians.GetY(), maxAngleLimitRadians.GetY(), loop, loopCount, + frame, count, "Z軸制限-Y", linkBoneName, ikMotion, ikFile) + fZ = fs.getIkAxisValue(fZ, minAngleLimitRadians.GetZ(), maxAngleLimitRadians.GetZ(), loop, loopCount, + frame, count, "Z軸制限-Z", linkBoneName, ikMotion, ikFile) + + // 決定した角度でベクトルを回転 + xQuat := mmath.NewMQuaternionFromAxisAnglesRotate(xAxisVector, fX) + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Z軸制限-xQuat] xAxisVector: %s, fX: %f, xQuat: %s(%s)\n", + frame, loop, linkBoneName, count-1, xAxisVector.String(), fX, xQuat.String(), xQuat.ToMMDDegrees().String()) + } + + yQuat := mmath.NewMQuaternionFromAxisAnglesRotate(yAxisVector, fY) + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Z軸制限-yQuat] yAxisVector: %s, fY: %f, yQuat: %s(%s)\n", + frame, loop, linkBoneName, count-1, yAxisVector.String(), fY, yQuat.String(), yQuat.ToMMDDegrees().String()) + } + + zQuat := mmath.NewMQuaternionFromAxisAnglesRotate(zAxisVector, fZ) + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][Z軸制限-zQuat] zAxisVector: %s, fZ: %f, zQuat: %s(%s)\n", + frame, loop, linkBoneName, count-1, zAxisVector.String(), fZ, zQuat.String(), zQuat.ToMMDDegrees().String()) + } + + return xQuat.Muled(zQuat).Muled(yQuat), count +} + +func (fs *BoneFrames) getIkAxisValue( + fV, minAngleLimit, maxAngleLimit float64, + loop, loopCount int, + frame int, + count int, + axisName, linkBoneName string, + ikMotion *VmdMotion, + ikFile *os.File, +) float64 { + isInLoop := float64(loop) < float64(loopCount)/2.0 + + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][%s-getIkAxisValue] loop: %d, isInLoop: %v\n", + frame, loop, linkBoneName, count-1, axisName, loop, isInLoop) + } + + if fV < minAngleLimit { + tf := 2*minAngleLimit - fV + if tf <= maxAngleLimit && isInLoop { + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][%s-最小角度(loop内)] minAngleLimit: %f, fV: %f, tf: %f\n", + frame, loop, linkBoneName, count-1, axisName, minAngleLimit, fV, tf) + } + + fV = tf + } else { + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][%s-最小角度(loop外)] minAngleLimit: %f, fV: %f, tf: %f\n", + frame, loop, linkBoneName, count-1, axisName, minAngleLimit, fV, tf) + } + + fV = minAngleLimit + } + } + + if fV > maxAngleLimit { + tf := 2*maxAngleLimit - fV + if tf >= minAngleLimit && isInLoop { + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][%s-最大角度(loop内)] maxAngleLimit: %f, fV: %f, tf: %f\n", + frame, loop, linkBoneName, count-1, axisName, maxAngleLimit, fV, tf) + } + + fV = tf + } else { + if mlog.IsIkVerbose() && ikMotion != nil && ikFile != nil { + fmt.Fprintf(ikFile, "[%04d][%03d][%s][%05d][%s-最大角度(loop外)] maxAngleLimit: %f, fV: %f, tf: %f\n", + frame, loop, linkBoneName, count-1, axisName, maxAngleLimit, fV, tf) + } + + fV = maxAngleLimit + } + } + + return fV +} + +func (fs *BoneFrames) calcBoneDeltas( + frame int, + model *pmx.PmxModel, + deformBoneIndexes []int, + boneDeltas *BoneDeltas, +) *BoneDeltas { + for _, boneIndex := range deformBoneIndexes { + delta := boneDeltas.Get(boneIndex) + bone := model.Bones.Get(boneIndex) + if delta == nil { + delta = &BoneDelta{Bone: bone, Frame: frame} + } + + delta.unitMatrix = mmath.NewMMat4() + delta.globalMatrix = nil + delta.localMatrix = nil + delta.globalPosition = nil + + // スケール + if delta.frameScale != nil && !delta.frameScale.IsOne() { + delta.unitMatrix.Mul(delta.frameScale.ToScaleMat4()) + } + + // 回転 + rot := boneDeltas.LocalRotation(bone.Index, 0) + if rot != nil && !rot.IsIdent() { + delta.unitMatrix.Mul(rot.ToMat4()) + } + + // 移動 + pos := boneDeltas.LocalPosition(bone.Index, 0) + if pos != nil && !pos.IsZero() { + delta.unitMatrix.Mul(pos.ToMat4()) + } + + // x := math.Abs(rot.GetX()) + + // if bone.Name == "左袖_後_赤_04_04" { + // mlog.I("[%s][%04d]: pos: %s, rot: %s(%s), x: %f\n", bone.Name, frame, pos.String(), rot.String(), rot.ToMMDDegrees().String(), x) + // } + + // 逆BOf行列(初期姿勢行列) + delta.unitMatrix.Mul(delta.Bone.RevertOffsetMatrix) + } + + for _, boneIndex := range deformBoneIndexes { + delta := boneDeltas.Get(boneIndex) + parentDelta := boneDeltas.Get(delta.Bone.ParentIndex) + if parentDelta != nil && parentDelta.globalMatrix != nil { + delta.globalMatrix = delta.unitMatrix.Muled(parentDelta.globalMatrix) + } else { + // 対象ボーン自身の行列をかける + delta.globalMatrix = delta.unitMatrix.Copy() + } + + // delta.localMatrix = delta.Bone.OffsetMatrix.Muled(delta.globalMatrix) + // delta.globalPosition = delta.globalMatrix.Translation() + boneDeltas.Update(delta) + } + + return boneDeltas +} + +// デフォーム対象ボーン情報一覧取得 +func (fs *BoneFrames) createBoneDeltas( + frame int, + model *pmx.PmxModel, + boneNames []string, + boneDeltas *BoneDeltas, + isAfterPhysics bool, +) ([]int, *BoneDeltas) { + // ボーン名の存在チェック用マップ + targetSortedBones := model.Bones.LayerSortedBones[isAfterPhysics] + + if boneDeltas == nil { + boneDeltas = NewBoneDeltas(model.Bones) + } + + if len(boneNames) == 1 && model.Bones.ContainsByName(boneNames[0]) { + // 1ボーン指定の場合 + bone := model.Bones.GetByName(boneNames[0]) + return model.Bones.DeformBoneIndexes[bone.Index], boneDeltas + } + + // 変形階層順ボーンIndexリスト + deformBoneIndexes := make([]int, 0, len(targetSortedBones)) + + // 関連ボーンINDEXリスト（順不同） + relativeBoneIndexes := make(map[int]struct{}) + + if len(boneNames) > 0 { + // 指定ボーンに関連するボーンのみ対象とする + for _, boneName := range boneNames { + if !model.Bones.ContainsByName(boneName) { + continue + } + + // ボーン + bone := model.Bones.GetByName(boneName) + + // 対象のボーンは常に追加 + if _, ok := relativeBoneIndexes[bone.Index]; !ok { + relativeBoneIndexes[bone.Index] = struct{}{} + } + + // 関連するボーンの追加 + for _, index := range bone.RelativeBoneIndexes { + if _, ok := relativeBoneIndexes[index]; !ok { + relativeBoneIndexes[index] = struct{}{} + } + } + } + } else if isAfterPhysics { + // 物理後でボーン名の指定が無い場合、物理後全ボーンを対象とする + for _, bone := range targetSortedBones { + // 対象のボーンは常に追加 + if _, ok := relativeBoneIndexes[bone.Index]; !ok { + relativeBoneIndexes[bone.Index] = struct{}{} + } + + // 関連するボーンの追加 + for _, index := range bone.RelativeBoneIndexes { + if _, ok := relativeBoneIndexes[index]; !ok { + relativeBoneIndexes[index] = struct{}{} + } + } + } + } else { + // 物理前かつボーン名の指定が無い場合、物理前全ボーンを対象とする + for _, bone := range model.Bones.LayerSortedBones[isAfterPhysics] { + deformBoneIndexes = append(deformBoneIndexes, bone.Index) + if !boneDeltas.Contains(bone.Index) { + boneDeltas.Update(&BoneDelta{Bone: bone, Frame: frame}) + } + } + + return deformBoneIndexes, boneDeltas + } + + // 変形階層・ボーンINDEXでソート + for _, ap := range []bool{false, true} { + for _, bone := range model.Bones.LayerSortedBones[ap] { + if _, ok := relativeBoneIndexes[bone.Index]; ok { + deformBoneIndexes = append(deformBoneIndexes, bone.Index) + if !boneDeltas.Contains(bone.Index) { + boneDeltas.Update(&BoneDelta{Bone: bone, Frame: frame}) + } + } + } + } + + return deformBoneIndexes, boneDeltas +} + +// デフォーム情報を求めて設定 +func (fs *BoneFrames) fillBoneDeform( + frame int, + model *pmx.PmxModel, + deformBoneIndexes []int, + boneDeltas *BoneDeltas, + morphDeltas *MorphDeltas, +) *BoneDeltas { + for _, boneIndex := range deformBoneIndexes { + bone := model.Bones.Get(boneIndex) + delta := boneDeltas.Get(boneIndex) + if delta == nil { + delta = &BoneDelta{Bone: bone, Frame: frame} + } + + var bf *BoneFrame + if bone.IsAfterPhysicsDeform() || boneDeltas == nil || boneDeltas.Get(bone.Index) == nil || + boneDeltas.Get(bone.Index).framePosition == nil || + boneDeltas.Get(bone.Index).frameRotation == nil || + boneDeltas.Get(bone.Index).frameScale == nil { + bf = fs.Get(bone.Name).Get(frame) + } + // ボーンの移動位置、回転角度、拡大率を取得 + delta.framePosition, delta.frameMorphPosition = fs.getPosition(bf, bone, boneDeltas, morphDeltas) + delta.frameRotation, delta.frameMorphRotation = fs.getRotation(bf, bone, boneDeltas, morphDeltas) + delta.frameScale = fs.getScale(bf, bone, boneDeltas, morphDeltas) + boneDeltas.Update(delta) + } + + return boneDeltas +} + +// 該当キーフレにおけるボーンの移動位置 +func (fs *BoneFrames) getPosition( + bf *BoneFrame, + // frame int, + bone *pmx.Bone, + // model *pmx.PmxModel, + boneDeltas *BoneDeltas, + morphDeltas *MorphDeltas, +) (*mmath.MVec3, *mmath.MVec3) { + var pos *mmath.MVec3 + if boneDeltas != nil && boneDeltas.Get(bone.Index) != nil && boneDeltas.Get(bone.Index).framePosition != nil { + pos = boneDeltas.Get(bone.Index).framePosition.Copy() + } else if bf != nil && bf.Position != nil && !bf.Position.IsZero() { + pos = bf.Position.Copy() + } else { + pos = mmath.NewMVec3() + } + + var morphPos *mmath.MVec3 + if morphDeltas != nil && morphDeltas.Bones.Get(bone.Index) != nil && + morphDeltas.Bones.Get(bone.Index).framePosition != nil { + morphPos = morphDeltas.Bones.Get(bone.Index).framePosition + } + + return pos, morphPos +} + +// 該当キーフレにおけるボーンの回転角度 +func (fs *BoneFrames) getRotation( + bf *BoneFrame, + // frame int, + bone *pmx.Bone, + // model *pmx.PmxModel, + boneDeltas *BoneDeltas, + morphDeltas *MorphDeltas, +) (*mmath.MQuaternion, *mmath.MQuaternion) { + // FK(捩り) > IK(捩り) > 付与親(捩り) + var rot *mmath.MQuaternion + var morphRot *mmath.MQuaternion + if boneDeltas != nil && boneDeltas.Get(bone.Index) != nil && boneDeltas.Get(bone.Index).frameRotation != nil { + rot = boneDeltas.Get(bone.Index).frameRotation.Copy() + } else { + if bf != nil && bf.Rotation != nil && !bf.Rotation.IsIdent() { + rot = bf.Rotation.Copy() + } else { + rot = mmath.NewMQuaternion() + + if morphDeltas != nil && morphDeltas.Bones.Get(bone.Index) != nil && + morphDeltas.Bones.Get(bone.Index).frameRotation != nil { + // IKの場合はIK計算時に組み込まれているので、まだframeRotationが無い場合のみ加味 + morphRot = morphDeltas.Bones.Get(bone.Index).frameRotation + // mlog.I("[%s][%04d][%d]: rot: %s(%s), morphRot: %s(%s)\n", bone.Name, frame, loop, + // rot.String(), rot.ToMMDDegrees().String(), morphRot.String(), morphRot.ToMMDDegrees().String()) + } + } + } + + if bone.HasFixedAxis() { + rot = rot.ToFixedAxisRotation(bone.NormalizedFixedAxis) + } + + return rot, morphRot +} + +// 該当キーフレにおけるボーンの拡大率 +func (fs *BoneFrames) getScale( + bf *BoneFrame, + bone *pmx.Bone, + boneDeltas *BoneDeltas, + morphDeltas *MorphDeltas, +) *mmath.MVec3 { + + scale := &mmath.MVec3{1, 1, 1} + if boneDeltas != nil && boneDeltas.Get(bone.Index) != nil && + boneDeltas.Get(bone.Index).frameScale != nil { + scale = boneDeltas.Get(bone.Index).frameScale + } else if bf != nil && bf.Scale != nil && !bf.Scale.IsZero() { + scale.Add(bf.Scale) + } + + if morphDeltas != nil && morphDeltas.Bones.Get(bone.Index) != nil && + morphDeltas.Bones.Get(bone.Index).frameScale != nil { + return scale.Add(morphDeltas.Bones.Get(bone.Index).frameScale) + } + + return scale +} diff --git a/pkg/vmd/bone_name_frames.go b/pkg/vmd/bone_name_frames.go new file mode 100644 index 00000000..60da7c3c --- /dev/null +++ b/pkg/vmd/bone_name_frames.go @@ -0,0 +1,13 @@ +package vmd + +type BoneNameFrames struct { + *BaseFrames[*BoneFrame] + Name string // ボーン名 +} + +func NewBoneNameFrames(name string) *BoneNameFrames { + return &BoneNameFrames{ + BaseFrames: NewBaseFrames[*BoneFrame](NewBoneFrame, NullBoneFrame), + Name: name, + } +} diff --git a/pkg/vmd/camera_curves.go b/pkg/vmd/camera_curves.go new file mode 100644 index 00000000..eebd17dc --- /dev/null +++ b/pkg/vmd/camera_curves.go @@ -0,0 +1,143 @@ +package vmd + +import "github.com/miu200521358/mlib_go/pkg/mmath" + +var InitialCameraCurves = []byte{ + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, +} + +type CameraCurves struct { + TranslateX *mmath.Curve // 移動X + TranslateY *mmath.Curve // 移動Y + TranslateZ *mmath.Curve // 移動Z + Rotate *mmath.Curve // 回転 + Distance *mmath.Curve // 距離 + ViewOfAngle *mmath.Curve // 視野角 + Values []byte // 補間曲線の値 +} + +func NewCameraCurves() *CameraCurves { + return &CameraCurves{ + TranslateX: mmath.NewCurve(), + TranslateY: mmath.NewCurve(), + TranslateZ: mmath.NewCurve(), + Rotate: mmath.NewCurve(), + Distance: mmath.NewCurve(), + ViewOfAngle: mmath.NewCurve(), + Values: []byte{ + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + 107, + }, + } +} + +func NewCameraCurvesByValues(values []byte) *CameraCurves { + curves := &CameraCurves{ + TranslateX: mmath.NewCurveByValues(values[0], values[6], values[12], values[18]), // 移動X + TranslateY: mmath.NewCurveByValues(values[1], values[7], values[13], values[19]), // 移動Y + TranslateZ: mmath.NewCurveByValues(values[2], values[8], values[14], values[20]), // 移動Z + Rotate: mmath.NewCurveByValues(values[3], values[9], values[15], values[21]), // 回転 + Distance: mmath.NewCurveByValues(values[4], values[10], values[16], values[22]), // 距離 + ViewOfAngle: mmath.NewCurveByValues(values[5], values[11], values[17], values[23]), // 視野角 + Values: values, + } + return curves +} + +// 補間曲線の計算 +func (v *CameraCurves) Evaluate(prevIndex, nowIndex, nextIndex int) (float64, float64, float64, float64, float64, float64) { + var xy, yy, zy, ry, dy, vy float64 + _, xy, _ = mmath.Evaluate(v.TranslateX, prevIndex, nowIndex, nextIndex) + _, yy, _ = mmath.Evaluate(v.TranslateY, prevIndex, nowIndex, nextIndex) + _, zy, _ = mmath.Evaluate(v.TranslateZ, prevIndex, nowIndex, nextIndex) + _, ry, _ = mmath.Evaluate(v.Rotate, prevIndex, nowIndex, nextIndex) + _, dy, _ = mmath.Evaluate(v.Distance, prevIndex, nowIndex, nextIndex) + _, vy, _ = mmath.Evaluate(v.ViewOfAngle, prevIndex, nowIndex, nextIndex) + + return xy, yy, zy, ry, dy, vy +} + +func (c *CameraCurves) Merge() []byte { + return []byte{ + byte(c.TranslateX.Start.GetX()), + byte(c.TranslateY.Start.GetX()), + byte(c.TranslateZ.Start.GetX()), + byte(c.Rotate.Start.GetX()), + byte(c.Distance.Start.GetX()), + byte(c.ViewOfAngle.Start.GetX()), + byte(c.TranslateX.Start.GetY()), + byte(c.TranslateY.Start.GetY()), + byte(c.TranslateZ.Start.GetY()), + byte(c.Rotate.Start.GetY()), + byte(c.Distance.Start.GetY()), + byte(c.ViewOfAngle.Start.GetY()), + byte(c.TranslateX.End.GetX()), + byte(c.TranslateY.End.GetX()), + byte(c.TranslateZ.End.GetX()), + byte(c.Rotate.End.GetX()), + byte(c.Distance.End.GetX()), + byte(c.ViewOfAngle.End.GetX()), + byte(c.TranslateX.End.GetY()), + byte(c.TranslateY.End.GetY()), + byte(c.TranslateZ.End.GetY()), + byte(c.Rotate.End.GetY()), + byte(c.Distance.End.GetY()), + byte(c.ViewOfAngle.End.GetY()), + } +} + +func (c *CameraCurves) Copy() *CameraCurves { + return &CameraCurves{ + TranslateX: c.TranslateX.Copy(), + TranslateY: c.TranslateY.Copy(), + TranslateZ: c.TranslateZ.Copy(), + Rotate: c.Rotate.Copy(), + Distance: c.Distance.Copy(), + ViewOfAngle: c.ViewOfAngle.Copy(), + } +} diff --git a/pkg/vmd/camera_frame.go b/pkg/vmd/camera_frame.go new file mode 100644 index 00000000..244df58b --- /dev/null +++ b/pkg/vmd/camera_frame.go @@ -0,0 +1,111 @@ +package vmd + +import ( + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +type CameraFrame struct { + *BaseFrame // キーフレ + Position *mmath.MVec3 // 位置 + Rotation *mmath.MRotation // 回転 + Distance float64 // 距離 + ViewOfAngle int // 視野角 + IsPerspectiveOff bool // パースOFF + Curves *CameraCurves // 補間曲線 +} + +func NewCameraFrame(index int) *CameraFrame { + return &CameraFrame{ + BaseFrame: NewFrame(index).(*BaseFrame), + Position: mmath.NewMVec3(), + Rotation: mmath.NewRotationFromDegrees(&mmath.MVec3{0, 0, 0}), + Distance: 0.0, + ViewOfAngle: 0, + IsPerspectiveOff: true, + Curves: NewCameraCurves(), + } +} + +func NullCameraFrame() *CameraFrame { + return nil +} + +func (cf *CameraFrame) Add(v *CameraFrame) { + cf.Position.Add(v.Position) + cf.Rotation.Mul(v.Rotation) + cf.Distance += v.Distance + cf.ViewOfAngle += v.ViewOfAngle +} + +func (cf *CameraFrame) Added(v *CameraFrame) *CameraFrame { + copied := cf.Copy().(*CameraFrame) + + copied.Position.Add(v.Position) + copied.Rotation.Mul(v.Rotation) + copied.Distance += v.Distance + copied.ViewOfAngle += v.ViewOfAngle + + return copied +} + +func (cf *CameraFrame) Copy() IBaseFrame { + copied := NewCameraFrame(cf.GetIndex()) + copied.Position = cf.Position + copied.Rotation = cf.Rotation.Copy() + copied.Distance = cf.Distance + copied.ViewOfAngle = cf.ViewOfAngle + copied.IsPerspectiveOff = cf.IsPerspectiveOff + copied.Curves = cf.Curves.Copy() + + return copied +} + +func (nextCf *CameraFrame) lerpFrame(prevFrame IBaseFrame, index int) IBaseFrame { + prevCf := prevFrame.(*CameraFrame) + + if prevCf == nil || nextCf.GetIndex() <= index { + // 前がないか、最後より後の場合、次のキーフレをコピーして返す + frame := nextCf.Copy() + return frame + } + + if nextCf == nil { + frame := prevCf.Copy() + return frame + } + + cf := NewCameraFrame(index) + + xy, yy, zy, ry, dy, vy := nextCf.Curves.Evaluate(prevCf.GetIndex(), index, nextCf.GetIndex()) + + qq := prevCf.Rotation.GetQuaternion().Slerp(nextCf.Rotation.GetQuaternion(), ry) + cf.Rotation.SetQuaternion(qq) + + cf.Position.SetX(mmath.LerpFloat(prevCf.Position.GetX(), nextCf.Position.GetX(), xy)) + cf.Position.SetY(mmath.LerpFloat(prevCf.Position.GetY(), nextCf.Position.GetY(), yy)) + cf.Position.SetZ(mmath.LerpFloat(prevCf.Position.GetZ(), nextCf.Position.GetZ(), zy)) + + cf.Distance = mmath.LerpFloat(prevCf.Distance, nextCf.Distance, dy) + cf.ViewOfAngle = int(mmath.LerpFloat(float64(prevCf.ViewOfAngle), float64(nextCf.ViewOfAngle), vy)) + cf.IsPerspectiveOff = nextCf.IsPerspectiveOff + + return cf +} + +func (cf *CameraFrame) splitCurve(prevFrame IBaseFrame, nextFrame IBaseFrame, index int) { + prevCf := prevFrame.(*CameraFrame) + nextCf := nextFrame.(*CameraFrame) + + cf.Curves.TranslateX, nextCf.Curves.TranslateX = + mmath.SplitCurve(nextCf.Curves.TranslateX, prevCf.GetIndex(), index, nextCf.GetIndex()) + cf.Curves.TranslateY, nextCf.Curves.TranslateY = + mmath.SplitCurve(nextCf.Curves.TranslateY, prevCf.GetIndex(), index, nextCf.GetIndex()) + cf.Curves.TranslateZ, nextCf.Curves.TranslateZ = + mmath.SplitCurve(nextCf.Curves.TranslateZ, prevCf.GetIndex(), index, nextCf.GetIndex()) + cf.Curves.Rotate, nextCf.Curves.Rotate = + mmath.SplitCurve(nextCf.Curves.Rotate, prevCf.GetIndex(), index, nextCf.GetIndex()) + cf.Curves.Distance, nextCf.Curves.Distance = + mmath.SplitCurve(nextCf.Curves.Distance, prevCf.GetIndex(), index, nextCf.GetIndex()) + cf.Curves.ViewOfAngle, nextCf.Curves.ViewOfAngle = + mmath.SplitCurve(nextCf.Curves.ViewOfAngle, prevCf.GetIndex(), index, nextCf.GetIndex()) +} diff --git a/pkg/vmd/camera_frames.go b/pkg/vmd/camera_frames.go new file mode 100644 index 00000000..16ff1fba --- /dev/null +++ b/pkg/vmd/camera_frames.go @@ -0,0 +1,15 @@ +package vmd + +type CameraFrames struct { + *BaseFrames[*CameraFrame] +} + +func NewCameraFrames() *CameraFrames { + return &CameraFrames{ + BaseFrames: NewBaseFrames[*CameraFrame](NewCameraFrame, NullCameraFrame), + } +} + +func (i *CameraFrames) NewFrame(index int) *CameraFrame { + return NewCameraFrame(index) +} diff --git a/pkg/vmd/ik_frame.go b/pkg/vmd/ik_frame.go new file mode 100644 index 00000000..bf62ea79 --- /dev/null +++ b/pkg/vmd/ik_frame.go @@ -0,0 +1,85 @@ +package vmd + +type IkEnabledFrame struct { + *BaseFrame // キーフレ + BoneName string // IKボーン名 + Enabled bool // IKON/OFF +} + +func NewIkEnableFrame(index int) *IkEnabledFrame { + return &IkEnabledFrame{ + BaseFrame: NewFrame(index).(*BaseFrame), + BoneName: "", + Enabled: true, + } +} + +func (kf *IkEnabledFrame) Copy() *IkEnabledFrame { + vv := &IkEnabledFrame{ + BoneName: kf.BoneName, + Enabled: kf.Enabled, + } + return vv +} + +func (nextKf *IkEnabledFrame) LerpFrame(prevFrame IBaseFrame, index int) IBaseFrame { + // 補間なしで前のキーフレを引き継ぐ + return prevFrame +} + +type IkFrame struct { + *BaseFrame // キーフレ + Visible bool // 表示ON/OFF + IkList []*IkEnabledFrame // IKリスト +} + +func NewIkFrame(index int) *IkFrame { + return &IkFrame{ + BaseFrame: NewFrame(index).(*BaseFrame), + Visible: true, + IkList: make([]*IkEnabledFrame, 0), + } +} + +func NullNewIkFrame() *IkFrame { + return nil +} + +func (ikf *IkFrame) Copy() IBaseFrame { + vv := &IkFrame{ + BaseFrame: ikf.BaseFrame.Copy().(*BaseFrame), + Visible: ikf.Visible, + IkList: make([]*IkEnabledFrame, len(ikf.IkList)), + } + for i, v := range ikf.IkList { + vv.IkList[i] = v.Copy() + } + return vv +} + +func (nextIkf *IkFrame) lerpFrame(prevFrame IBaseFrame, index int) IBaseFrame { + prevIkf := prevFrame.(*IkFrame) + // 補間なしで前のキーフレを引き継ぐ + vv := &IkFrame{ + Visible: prevIkf.Visible, + IkList: make([]*IkEnabledFrame, 0, len(prevIkf.IkList)), + } + for _, v := range prevIkf.IkList { + vv.IkList = append(vv.IkList, v.Copy()) + } + return vv +} + +func (kf *IkFrame) splitCurve(prevFrame IBaseFrame, nextFrame IBaseFrame, index int) { +} + +func (kf *IkFrame) IsEnable(boneName string) bool { + for _, ik := range kf.IkList { + if ik.BoneName == boneName { + // IKボーン名がある場合、その結果を取得する + return ik.Enabled + } + } + // キーが無い場合、IK有効がデフォルト + return true +} diff --git a/pkg/vmd/ik_frames.go b/pkg/vmd/ik_frames.go new file mode 100644 index 00000000..63192635 --- /dev/null +++ b/pkg/vmd/ik_frames.go @@ -0,0 +1,15 @@ +package vmd + +type IkFrames struct { + *BaseFrames[*IkFrame] +} + +func NewIkFrames() *IkFrames { + return &IkFrames{ + BaseFrames: NewBaseFrames[*IkFrame](NewIkFrame, NullNewIkFrame), + } +} + +func (i *IkFrames) NewFrame(index int) *IkFrame { + return NewIkFrame(index) +} diff --git a/pkg/vmd/light_frame.go b/pkg/vmd/light_frame.go new file mode 100644 index 00000000..5ca53281 --- /dev/null +++ b/pkg/vmd/light_frame.go @@ -0,0 +1,59 @@ +package vmd + +import ( + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +type LightFrame struct { + *BaseFrame // キーフレ + Position *mmath.MVec3 // 位置 + Color *mmath.MVec3 // 色 +} + +func NewLightFrame(index int) *LightFrame { + return &LightFrame{ + BaseFrame: NewFrame(index).(*BaseFrame), + Position: mmath.NewMVec3(), + Color: mmath.NewMVec3(), + } +} + +func NullLightFrame() *LightFrame { + return nil +} + +func (lf *LightFrame) Add(v *LightFrame) { + lf.Position.Add(v.Position) + lf.Color.Add(v.Color) +} + +func (lf *LightFrame) Added(v *LightFrame) *LightFrame { + copied := lf.Copy().(*LightFrame) + + copied.Position.Add(v.Position) + copied.Color.Add(v.Color) + + return copied +} + +func (lf *LightFrame) Copy() IBaseFrame { + copied := NewLightFrame(lf.GetIndex()) + copied.Position = lf.Position + copied.Color = lf.Color + + return copied +} + +func (nextLf *LightFrame) lerpFrame(prevFrame IBaseFrame, index int) IBaseFrame { + prevLf := prevFrame.(*LightFrame) + // 線形補間 + t := float64(nextLf.GetIndex()-index) / float64(nextLf.GetIndex()-prevLf.GetIndex()) + vv := &LightFrame{ + Position: prevLf.Position.Lerp(nextLf.Position, t), + Color: prevLf.Color.Lerp(nextLf.Color, t), + } + return vv +} + +func (lf *LightFrame) splitCurve(prevFrame IBaseFrame, nextFrame IBaseFrame, index int) { +} diff --git a/pkg/vmd/light_frames.go b/pkg/vmd/light_frames.go new file mode 100644 index 00000000..65084700 --- /dev/null +++ b/pkg/vmd/light_frames.go @@ -0,0 +1,15 @@ +package vmd + +type LightFrames struct { + *BaseFrames[*LightFrame] +} + +func NewLightFrames() *LightFrames { + return &LightFrames{ + BaseFrames: NewBaseFrames[*LightFrame](NewLightFrame, NullLightFrame), + } +} + +func (i *LightFrames) NewFrame(index int) *LightFrame { + return NewLightFrame(index) +} diff --git a/pkg/vmd/morph_delta.go b/pkg/vmd/morph_delta.go new file mode 100644 index 00000000..3e57e149 --- /dev/null +++ b/pkg/vmd/morph_delta.go @@ -0,0 +1,396 @@ +package vmd + +import ( + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +type VertexMorphDelta struct { + Index int + Position *mmath.MVec3 + Uv *mmath.MVec2 + Uv1 *mmath.MVec2 + AfterPosition *mmath.MVec3 +} + +func NewVertexMorphDelta(index int) *VertexMorphDelta { + return &VertexMorphDelta{ + Index: index, + Position: nil, + Uv: nil, + Uv1: nil, + AfterPosition: nil, + } +} + +type VertexMorphDeltas struct { + Data map[int]*VertexMorphDelta +} + +func NewVertexMorphDeltas() *VertexMorphDeltas { + return &VertexMorphDeltas{ + Data: make(map[int]*VertexMorphDelta), + } +} + +type WireVertexMorphDeltas struct { + *VertexMorphDeltas +} + +func NewWireVertexMorphDeltas() *WireVertexMorphDeltas { + return &WireVertexMorphDeltas{ + VertexMorphDeltas: NewVertexMorphDeltas(), + } +} + +type SelectedVertexMorphDeltas struct { + *VertexMorphDeltas +} + +func NewSelectedVertexMorphDeltas() *SelectedVertexMorphDeltas { + return &SelectedVertexMorphDeltas{ + VertexMorphDeltas: NewVertexMorphDeltas(), + } +} + +type BoneMorphDelta struct { + BoneIndex int + *BoneFrame + *MorphFrameDelta +} + +func NewBoneMorphDelta(boneIndex int) *BoneMorphDelta { + return &BoneMorphDelta{ + BoneIndex: boneIndex, + BoneFrame: NewBoneFrame(boneIndex), + MorphFrameDelta: NewMorphFrameDelta(), + } +} + +type BoneMorphDeltas struct { + Data []*BoneMorphDelta +} + +func NewBoneMorphDeltas(bones *pmx.Bones) *BoneMorphDeltas { + return &BoneMorphDeltas{ + Data: make([]*BoneMorphDelta, bones.Len()), + } +} + +func (bts *BoneMorphDeltas) Get(boneIndex int) *BoneMorphDelta { + if boneIndex < 0 || boneIndex >= len(bts.Data) { + return nil + } + + return bts.Data[boneIndex] +} + +func (bts *BoneMorphDeltas) Update(b *BoneMorphDelta) { + bts.Data[b.BoneIndex] = b +} + +type MaterialMorphDelta struct { + *pmx.Material + AddMaterial *pmx.Material + MulMaterial *pmx.Material + AddRatios *pmx.Material + MulRatios *pmx.Material +} + +func NewMaterialMorphDelta(m *pmx.Material) *MaterialMorphDelta { + mm := &MaterialMorphDelta{ + Material: m.Copy().(*pmx.Material), + AddMaterial: &pmx.Material{ + Diffuse: &mmath.MVec4{}, + Specular: &mmath.MVec4{}, + Ambient: &mmath.MVec3{}, + Edge: &mmath.MVec4{}, + EdgeSize: 0, + TextureFactor: &mmath.MVec4{}, + SphereTextureFactor: &mmath.MVec4{}, + ToonTextureFactor: &mmath.MVec4{}, + }, + MulMaterial: &pmx.Material{ + Diffuse: &mmath.MVec4{1, 1, 1, 1}, + Specular: &mmath.MVec4{1, 1, 1, 1}, + Ambient: &mmath.MVec3{1, 1, 1}, + Edge: &mmath.MVec4{1, 1, 1, 1}, + EdgeSize: 1, + TextureFactor: &mmath.MVec4{1, 1, 1, 1}, + SphereTextureFactor: &mmath.MVec4{1, 1, 1, 1}, + ToonTextureFactor: &mmath.MVec4{1, 1, 1, 1}, + }, + AddRatios: &pmx.Material{ + Diffuse: &mmath.MVec4{}, + Specular: &mmath.MVec4{}, + Ambient: &mmath.MVec3{}, + Edge: &mmath.MVec4{}, + EdgeSize: 0, + TextureFactor: &mmath.MVec4{}, + SphereTextureFactor: &mmath.MVec4{}, + ToonTextureFactor: &mmath.MVec4{}, + }, + MulRatios: &pmx.Material{ + Diffuse: &mmath.MVec4{1, 1, 1, 1}, + Specular: &mmath.MVec4{1, 1, 1, 1}, + Ambient: &mmath.MVec3{1, 1, 1}, + Edge: &mmath.MVec4{1, 1, 1, 1}, + EdgeSize: 1, + TextureFactor: &mmath.MVec4{1, 1, 1, 1}, + SphereTextureFactor: &mmath.MVec4{1, 1, 1, 1}, + ToonTextureFactor: &mmath.MVec4{1, 1, 1, 1}, + }, + } + + if mm.Material.TextureFactor == nil { + mm.Material.TextureFactor = &mmath.MVec4{1, 1, 1, 1} + } + if mm.Material.SphereTextureFactor == nil { + mm.Material.SphereTextureFactor = &mmath.MVec4{1, 1, 1, 1} + } + if mm.Material.ToonTextureFactor == nil { + mm.Material.ToonTextureFactor = &mmath.MVec4{1, 1, 1, 1} + } + + return mm +} + +func (md *MaterialMorphDelta) Add(m *pmx.MaterialMorphOffset, ratio float64) { + md.AddMaterial.Diffuse.Add(m.Diffuse) + md.AddMaterial.Specular.Add(m.Specular) + md.AddMaterial.Ambient.Add(m.Ambient) + md.AddMaterial.Edge.Add(m.Edge) + md.AddMaterial.EdgeSize += m.EdgeSize + md.AddMaterial.TextureFactor.Add(m.TextureFactor) + md.AddMaterial.SphereTextureFactor.Add(m.SphereTextureFactor) + md.AddMaterial.ToonTextureFactor.Add(m.ToonTextureFactor) + if m.Diffuse.GetX() != 0 { + md.AddRatios.Diffuse.AddX(ratio) + } + if m.Diffuse.GetY() != 0 { + md.AddRatios.Diffuse.AddY(ratio) + } + if m.Diffuse.GetZ() != 0 { + md.AddRatios.Diffuse.AddZ(ratio) + } + if m.Diffuse.GetW() != 0 { + md.AddRatios.Diffuse.AddW(ratio) + } + if m.Specular.GetX() != 0 { + md.AddRatios.Specular.AddX(ratio) + } + if m.Specular.GetY() != 0 { + md.AddRatios.Specular.AddY(ratio) + } + if m.Specular.GetZ() != 0 { + md.AddRatios.Specular.AddZ(ratio) + } + if m.Specular.GetW() != 0 { + md.AddRatios.Specular.AddW(ratio) + } + if m.Ambient.GetX() != 0 { + md.AddRatios.Ambient.AddX(ratio) + } + if m.Ambient.GetY() != 0 { + md.AddRatios.Ambient.AddY(ratio) + } + if m.Ambient.GetZ() != 0 { + md.AddRatios.Ambient.AddZ(ratio) + } + if m.Edge.GetX() != 0 { + md.AddRatios.Edge.AddX(ratio) + } + if m.Edge.GetY() != 0 { + md.AddRatios.Edge.AddY(ratio) + } + if m.Edge.GetZ() != 0 { + md.AddRatios.Edge.AddZ(ratio) + } + if m.Edge.GetW() != 0 { + md.AddRatios.Edge.AddW(ratio) + } + if m.EdgeSize != 0 { + md.AddRatios.EdgeSize += ratio + } + if m.TextureFactor.GetX() != 0 { + md.AddRatios.TextureFactor.AddX(ratio) + } + if m.TextureFactor.GetY() != 0 { + md.AddRatios.TextureFactor.AddY(ratio) + } + if m.TextureFactor.GetZ() != 0 { + md.AddRatios.TextureFactor.AddZ(ratio) + } + if m.TextureFactor.GetW() != 0 { + md.AddRatios.TextureFactor.AddW(ratio) + } + if m.SphereTextureFactor.GetX() != 0 { + md.AddRatios.SphereTextureFactor.AddX(ratio) + } + if m.SphereTextureFactor.GetY() != 0 { + md.AddRatios.SphereTextureFactor.AddY(ratio) + } + if m.SphereTextureFactor.GetZ() != 0 { + md.AddRatios.SphereTextureFactor.AddZ(ratio) + } + if m.SphereTextureFactor.GetW() != 0 { + md.AddRatios.SphereTextureFactor.AddW(ratio) + } + if m.ToonTextureFactor.GetX() != 0 { + md.AddRatios.ToonTextureFactor.AddX(ratio) + } + if m.ToonTextureFactor.GetY() != 0 { + md.AddRatios.ToonTextureFactor.AddY(ratio) + } + if m.ToonTextureFactor.GetZ() != 0 { + md.AddRatios.ToonTextureFactor.AddZ(ratio) + } + if m.ToonTextureFactor.GetW() != 0 { + md.AddRatios.ToonTextureFactor.AddW(ratio) + } +} + +func (md *MaterialMorphDelta) Mul(m *pmx.MaterialMorphOffset, ratio float64) { + if m.Diffuse.GetX() != 1 { + md.MulMaterial.Diffuse.MulX(md.Material.Diffuse.GetX() - m.Diffuse.GetX()) + md.MulRatios.Diffuse.MulX(1 - ratio) + } + if m.Diffuse.GetY() != 1 { + md.MulMaterial.Diffuse.MulY(md.Material.Diffuse.GetY() - m.Diffuse.GetY()) + md.MulRatios.Diffuse.MulY(1 - ratio) + } + if m.Diffuse.GetZ() != 1 { + md.MulMaterial.Diffuse.MulZ(md.Material.Diffuse.GetZ() - m.Diffuse.GetZ()) + md.MulRatios.Diffuse.MulZ(1 - ratio) + } + if m.Diffuse.GetW() != 1 { + md.MulMaterial.Diffuse.MulW(md.Material.Diffuse.GetW() - m.Diffuse.GetW()) + md.MulRatios.Diffuse.MulW(1 - ratio) + } + if m.Specular.GetX() != 1 { + md.MulMaterial.Specular.MulX(md.Material.Specular.GetX() - m.Specular.GetX()) + md.MulRatios.Specular.MulX(1 - ratio) + } + if m.Specular.GetY() != 1 { + md.MulMaterial.Specular.MulY(md.Material.Specular.GetY() - m.Specular.GetY()) + md.MulRatios.Specular.MulY(1 - ratio) + } + if m.Specular.GetZ() != 1 { + md.MulMaterial.Specular.MulZ(md.Material.Specular.GetZ() - m.Specular.GetZ()) + md.MulRatios.Specular.MulZ(1 - ratio) + } + if m.Specular.GetW() != 1 { + md.MulMaterial.Specular.MulW(md.Material.Specular.GetW() - m.Specular.GetW()) + md.MulRatios.Specular.MulW(1 - ratio) + } + if m.Ambient.GetX() != 1 { + md.MulMaterial.Ambient.MulX(md.Material.Ambient.GetX() - m.Ambient.GetX()) + md.MulRatios.Ambient.MulX(1 - ratio) + } + if m.Ambient.GetY() != 1 { + md.MulMaterial.Ambient.MulY(md.Material.Ambient.GetY() - m.Ambient.GetY()) + md.MulRatios.Ambient.MulY(1 - ratio) + } + if m.Ambient.GetZ() != 1 { + md.MulMaterial.Ambient.MulZ(md.Material.Ambient.GetZ() - m.Ambient.GetZ()) + md.MulRatios.Ambient.MulZ(1 - ratio) + } + if m.Edge.GetX() != 1 { + md.MulMaterial.Edge.MulX(md.Material.Edge.GetX() - m.Edge.GetX()) + md.MulRatios.Edge.MulX(1 - ratio) + } + if m.Edge.GetY() != 1 { + md.MulMaterial.Edge.MulY(md.Material.Edge.GetY() - m.Edge.GetY()) + md.MulRatios.Edge.MulY(1 - ratio) + } + if m.Edge.GetZ() != 1 { + md.MulMaterial.Edge.MulZ(md.Material.Edge.GetZ() - m.Edge.GetZ()) + md.MulRatios.Edge.MulZ(1 - ratio) + } + if m.Edge.GetW() != 1 { + md.MulMaterial.Edge.MulW(md.Material.Edge.GetW() - m.Edge.GetW()) + md.MulRatios.Edge.MulW(1 - ratio) + } + if m.EdgeSize != 1 { + md.MulMaterial.EdgeSize *= md.Material.EdgeSize - m.EdgeSize + md.MulRatios.EdgeSize *= ratio + } + if m.TextureFactor.GetX() != 1 { + md.MulMaterial.TextureFactor.MulX(md.Material.TextureFactor.GetX() - m.TextureFactor.GetX()) + md.MulRatios.TextureFactor.MulX(1 - ratio) + } + if m.TextureFactor.GetY() != 1 { + md.MulMaterial.TextureFactor.MulY(md.Material.TextureFactor.GetY() - m.TextureFactor.GetY()) + md.MulRatios.TextureFactor.MulY(1 - ratio) + } + if m.TextureFactor.GetZ() != 1 { + md.MulMaterial.TextureFactor.MulZ(md.Material.TextureFactor.GetZ() - m.TextureFactor.GetZ()) + md.MulRatios.TextureFactor.MulZ(1 - ratio) + } + if m.TextureFactor.GetW() != 1 { + md.MulMaterial.TextureFactor.MulW(md.Material.TextureFactor.GetW() - m.TextureFactor.GetW()) + md.MulRatios.TextureFactor.MulW(1 - ratio) + } + if m.SphereTextureFactor.GetX() != 1 { + md.MulMaterial.SphereTextureFactor.MulX(md.Material.SphereTextureFactor.GetX() - m.SphereTextureFactor.GetX()) + md.MulRatios.SphereTextureFactor.MulX(1 - ratio) + } + if m.SphereTextureFactor.GetY() != 1 { + md.MulMaterial.SphereTextureFactor.MulY(md.Material.SphereTextureFactor.GetY() - m.SphereTextureFactor.GetY()) + md.MulRatios.SphereTextureFactor.MulY(1 - ratio) + } + if m.SphereTextureFactor.GetZ() != 1 { + md.MulMaterial.SphereTextureFactor.MulZ(md.Material.SphereTextureFactor.GetZ() - m.SphereTextureFactor.GetZ()) + md.MulRatios.SphereTextureFactor.MulZ(1 - ratio) + } + if m.SphereTextureFactor.GetW() != 1 { + md.MulMaterial.SphereTextureFactor.MulW(md.Material.SphereTextureFactor.GetW() - m.SphereTextureFactor.GetW()) + md.MulRatios.SphereTextureFactor.MulW(1 - ratio) + } + if m.ToonTextureFactor.GetX() != 1 { + md.MulMaterial.ToonTextureFactor.MulX(md.Material.ToonTextureFactor.GetX() - m.ToonTextureFactor.GetX()) + md.MulRatios.ToonTextureFactor.MulX(1 - ratio) + } + if m.ToonTextureFactor.GetY() != 1 { + md.MulMaterial.ToonTextureFactor.MulY(md.Material.ToonTextureFactor.GetY() - m.ToonTextureFactor.GetY()) + md.MulRatios.ToonTextureFactor.MulY(1 - ratio) + } + if m.ToonTextureFactor.GetZ() != 1 { + md.MulMaterial.ToonTextureFactor.MulZ(md.Material.ToonTextureFactor.GetZ() - m.ToonTextureFactor.GetZ()) + md.MulRatios.ToonTextureFactor.MulZ(1 - ratio) + } + if m.ToonTextureFactor.GetW() != 1 { + md.MulMaterial.ToonTextureFactor.MulW(md.Material.ToonTextureFactor.GetW() - m.ToonTextureFactor.GetW()) + md.MulRatios.ToonTextureFactor.MulW(1 - ratio) + } +} + +type MaterialMorphDeltas struct { + Data []*MaterialMorphDelta +} + +func NewMaterialMorphDeltas(materials *pmx.Materials) *MaterialMorphDeltas { + deltas := make([]*MaterialMorphDelta, len(materials.Data)) + for i := range materials.Data { + m := materials.Get(i) + deltas[i] = NewMaterialMorphDelta(m) + } + + return &MaterialMorphDeltas{ + Data: deltas, + } +} + +type MorphDeltas struct { + Vertices *VertexMorphDeltas + Bones *BoneMorphDeltas + Materials *MaterialMorphDeltas +} + +func NewMorphDeltas(materials *pmx.Materials, bones *pmx.Bones) *MorphDeltas { + return &MorphDeltas{ + Vertices: NewVertexMorphDeltas(), + Bones: NewBoneMorphDeltas(bones), + Materials: NewMaterialMorphDeltas(materials), + } +} diff --git a/pkg/vmd/morph_delta_gui.go b/pkg/vmd/morph_delta_gui.go new file mode 100644 index 00000000..c094c06d --- /dev/null +++ b/pkg/vmd/morph_delta_gui.go @@ -0,0 +1,225 @@ +//go:build windows +// +build windows + +package vmd + +import ( + "slices" + + "github.com/go-gl/mathgl/mgl32" + "github.com/miu200521358/mlib_go/pkg/mview" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +func (mds *VertexMorphDeltas) GL() ([]int, [][]float32) { + vertices := make([][]float32, 0) + indices := make([]int, 0) + for i, md := range mds.Data { + vertices = append(vertices, md.GL()) + indices = append(indices, i) + } + return indices, vertices +} + +func (md *VertexMorphDelta) GL() []float32 { + var p0, p1, p2 float32 + if md.Position != nil { + p := md.Position.GL() + p0, p1, p2 = p[0], p[1], p[2] + } + var ap0, ap1, ap2 float32 + if md.AfterPosition != nil { + ap := md.AfterPosition.GL() + ap0, ap1, ap2 = ap[0], ap[1], ap[2] + } + // UVは符号関係ないのでそのまま取得する + var u0x, u0y, u1x, u1y float32 + if md.Uv != nil { + u0x = float32(md.Uv.GetX()) + u0y = float32(md.Uv.GetY()) + } + if md.Uv1 != nil { + u1x = float32(md.Uv1.GetX()) + u1y = float32(md.Uv1.GetY()) + } + return []float32{ + p0, p1, p2, + u0x, u0y, 0, 0, + u1x, u1y, 0, 0, + ap0, ap1, ap2, + } +} + +func (mds *SelectedVertexMorphDeltas) GL( + model *pmx.PmxModel, selectedVertexIndexes, nextSelectedVertexIndexes []int, +) ([]int, [][]float32) { + indices := make([]int, 0) + vertices := make([][]float32, 0) + for i := range len(model.Vertices.Data) { + // 選択頂点 + var selectedVertexDelta []float32 + // 選択頂点 + if selectedVertexIndexes != nil && nextSelectedVertexIndexes != nil { + if slices.Contains(selectedVertexIndexes, i) { + // 選択されている頂点のUVXを＋にして（フラグをたてて）非表示にする + selectedVertexDelta = []float32{ + 0, 0, 0, + 1, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, + } + } + if slices.Contains(nextSelectedVertexIndexes, i) { + // 選択されている頂点のUVXを0にして（フラグを落として）表示する + selectedVertexDelta = []float32{ + 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, + } + } + } else if selectedVertexIndexes != nil && slices.Contains(selectedVertexIndexes, i) { + // 選択されている頂点のUVXを0にして（フラグを落として）表示する + selectedVertexDelta = []float32{ + 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, + } + } + + if selectedVertexDelta != nil { + vertices = append(vertices, selectedVertexDelta) + indices = append(indices, i) + } + } + return indices, vertices +} + +func (md *MaterialMorphDelta) Result() *pmx.MeshDelta { + material := &pmx.MeshDelta{ + Diffuse: md.diffuse(), + Specular: md.specular(), + Ambient: md.ambient(), + Edge: md.edge(), + EdgeSize: md.edgeSize(), + TextureMulFactor: md.textureMulFactor(), + TextureAddFactor: md.textureAddFactor(), + SphereMulFactor: md.sphereMulFactor(), + SphereAddFactor: md.sphereAddFactor(), + ToonMulFactor: md.toonMulFactor(), + ToonAddFactor: md.toonAddFactor(), + } + + return material +} + +func (md *MaterialMorphDelta) diffuse() mgl32.Vec4 { + d1 := md.Diffuse.GetXYZ().Copy() + d2 := d1.MulScalar(float64(mview.LIGHT_AMBIENT)).Add(md.Ambient) + dm := md.MulMaterial.Diffuse.Muled(md.MulRatios.Diffuse) + da := md.AddMaterial.Diffuse.Muled(md.AddRatios.Diffuse) + + return mgl32.Vec4{ + float32(d2.GetX()*dm.GetX() + da.GetX()), + float32(d2.GetY()*dm.GetY() + da.GetY()), + float32(d2.GetZ()*dm.GetZ() + da.GetZ()), + float32(md.Diffuse.GetW()*dm.GetW() + da.GetW()), + } +} + +func (md *MaterialMorphDelta) specular() mgl32.Vec4 { + s1 := md.Specular.GetXYZ().MuledScalar(float64(mview.LIGHT_AMBIENT)) + sm := md.MulMaterial.Specular.Muled(md.MulRatios.Specular) + sa := md.AddMaterial.Specular.Muled(md.AddRatios.Specular) + + return mgl32.Vec4{ + float32(s1.GetX()*sm.GetX() + sa.GetX()), + float32(s1.GetY()*sm.GetY() + sa.GetY()), + float32(s1.GetZ()*sm.GetZ() + sa.GetZ()), + float32(md.Specular.GetW()*sm.GetW() + sa.GetW()), + } +} + +func (md *MaterialMorphDelta) ambient() mgl32.Vec3 { + a := md.Diffuse.GetXYZ().MuledScalar(float64(mview.LIGHT_AMBIENT)) + am := md.MulMaterial.Ambient.Muled(md.MulRatios.Ambient) + aa := md.AddMaterial.Ambient.Muled(md.AddRatios.Ambient) + return mgl32.Vec3{ + float32(a.GetX()*am.GetX() + aa.GetX()), + float32(a.GetY()*am.GetY() + aa.GetY()), + float32(a.GetZ()*am.GetZ() + aa.GetZ()), + } +} + +func (md *MaterialMorphDelta) edge() mgl32.Vec4 { + e := md.Edge.GetXYZ().MuledScalar(float64(md.Diffuse.GetW())) + em := md.MulMaterial.Edge.Muled(md.MulRatios.Edge) + ea := md.AddMaterial.Edge.Muled(md.AddRatios.Edge) + + return mgl32.Vec4{ + float32(e.GetX()*em.GetX() + ea.GetX()), + float32(e.GetY()*em.GetY() + ea.GetY()), + float32(e.GetZ()*em.GetZ() + ea.GetZ()), + float32(md.Edge.GetW()) * float32(md.Diffuse.GetW()*em.GetW()+ea.GetW()), + } +} + +func (md *MaterialMorphDelta) edgeSize() float32 { + return float32(md.Material.EdgeSize*(md.MulMaterial.EdgeSize*md.MulRatios.EdgeSize) + + (md.AddMaterial.EdgeSize * md.AddRatios.EdgeSize)) +} + +func (md *MaterialMorphDelta) textureMulFactor() mgl32.Vec4 { + return mgl32.Vec4{ + float32(md.MulMaterial.TextureFactor.GetX() * md.MulRatios.TextureFactor.GetX()), + float32(md.MulMaterial.TextureFactor.GetY() * md.MulRatios.TextureFactor.GetY()), + float32(md.MulMaterial.TextureFactor.GetZ() * md.MulRatios.TextureFactor.GetZ()), + float32(md.MulMaterial.TextureFactor.GetW() * md.MulRatios.TextureFactor.GetW()), + } +} + +func (md *MaterialMorphDelta) textureAddFactor() mgl32.Vec4 { + return mgl32.Vec4{ + float32(md.AddMaterial.TextureFactor.GetX() * md.AddRatios.TextureFactor.GetX()), + float32(md.AddMaterial.TextureFactor.GetY() * md.AddRatios.TextureFactor.GetY()), + float32(md.AddMaterial.TextureFactor.GetZ() * md.AddRatios.TextureFactor.GetZ()), + float32(md.AddMaterial.TextureFactor.GetW() * md.AddRatios.TextureFactor.GetW()), + } +} + +func (md *MaterialMorphDelta) sphereMulFactor() mgl32.Vec4 { + return mgl32.Vec4{ + float32(md.MulMaterial.SphereTextureFactor.GetX() * md.MulRatios.SphereTextureFactor.GetX()), + float32(md.MulMaterial.SphereTextureFactor.GetY() * md.MulRatios.SphereTextureFactor.GetY()), + float32(md.MulMaterial.SphereTextureFactor.GetZ() * md.MulRatios.SphereTextureFactor.GetZ()), + float32(md.MulMaterial.SphereTextureFactor.GetW() * md.MulRatios.SphereTextureFactor.GetW()), + } +} + +func (md *MaterialMorphDelta) sphereAddFactor() mgl32.Vec4 { + return mgl32.Vec4{ + float32(md.AddMaterial.SphereTextureFactor.GetX() * md.AddRatios.SphereTextureFactor.GetX()), + float32(md.AddMaterial.SphereTextureFactor.GetY() * md.AddRatios.SphereTextureFactor.GetY()), + float32(md.AddMaterial.SphereTextureFactor.GetZ() * md.AddRatios.SphereTextureFactor.GetZ()), + float32(md.AddMaterial.SphereTextureFactor.GetW() * md.AddRatios.SphereTextureFactor.GetW()), + } +} + +func (md *MaterialMorphDelta) toonMulFactor() mgl32.Vec4 { + return mgl32.Vec4{ + float32(md.MulMaterial.ToonTextureFactor.GetX() * md.MulRatios.ToonTextureFactor.GetX()), + float32(md.MulMaterial.ToonTextureFactor.GetY() * md.MulRatios.ToonTextureFactor.GetY()), + float32(md.MulMaterial.ToonTextureFactor.GetZ() * md.MulRatios.ToonTextureFactor.GetZ()), + float32(md.MulMaterial.ToonTextureFactor.GetW() * md.MulRatios.ToonTextureFactor.GetW()), + } +} + +func (md *MaterialMorphDelta) toonAddFactor() mgl32.Vec4 { + return mgl32.Vec4{ + float32(md.AddMaterial.ToonTextureFactor.GetX() * md.AddRatios.ToonTextureFactor.GetX()), + float32(md.AddMaterial.ToonTextureFactor.GetY() * md.AddRatios.ToonTextureFactor.GetY()), + float32(md.AddMaterial.ToonTextureFactor.GetZ() * md.AddRatios.ToonTextureFactor.GetZ()), + float32(md.AddMaterial.ToonTextureFactor.GetW() * md.AddRatios.ToonTextureFactor.GetW()), + } +} diff --git a/pkg/vmd/morph_frame.go b/pkg/vmd/morph_frame.go new file mode 100644 index 00000000..e47fd902 --- /dev/null +++ b/pkg/vmd/morph_frame.go @@ -0,0 +1,290 @@ +package vmd + +import ( + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +type MorphFrame struct { + *BaseFrame // キーフレ + Ratio float64 // モーフの割合 +} + +func NewMorphFrame(index int) *MorphFrame { + return &MorphFrame{ + BaseFrame: NewFrame(index).(*BaseFrame), + Ratio: 0.0, + } +} + +func NullMorphFrame() *MorphFrame { + return nil +} + +func (mf *MorphFrame) Add(v *MorphFrame) { + mf.Ratio += v.Ratio +} + +func (mf *MorphFrame) Added(v *MorphFrame) *MorphFrame { + copied := mf.Copy().(*MorphFrame) + copied.Ratio += v.Ratio + return copied +} + +func (mf *MorphFrame) Copy() IBaseFrame { + copied := NewMorphFrame(mf.GetIndex()) + copied.Ratio = mf.Ratio + return copied +} + +func (nextMf *MorphFrame) lerpFrame(prevFrame IBaseFrame, index int) IBaseFrame { + prevMf := prevFrame.(*MorphFrame) + + prevIndex := prevMf.GetIndex() + nextIndex := nextMf.GetIndex() + + mf := NewMorphFrame(index) + + ry := float64(index-prevIndex) / float64(nextIndex-prevIndex) + mf.Ratio = prevMf.Ratio + (nextMf.Ratio-prevMf.Ratio)*ry + + return mf +} + +func (mf *MorphFrame) splitCurve(prevFrame IBaseFrame, nextFrame IBaseFrame, index int) { +} + +type MorphFrameDelta struct { + framePosition *mmath.MVec3 // キーフレ位置の変動量 + frameRotation *mmath.MQuaternion // キーフレ回転の変動量 + frameScale *mmath.MVec3 // キーフレスケールの変動量 +} + +func (md *MorphFrameDelta) FramePosition() *mmath.MVec3 { + if md.framePosition == nil { + md.framePosition = mmath.NewMVec3() + } + return md.framePosition +} + +func (md *MorphFrameDelta) FrameRotation() *mmath.MQuaternion { + if md.frameRotation == nil { + md.frameRotation = mmath.NewMQuaternion() + } + return md.frameRotation +} + +func (md *MorphFrameDelta) FrameScale() *mmath.MVec3 { + if md.frameScale == nil { + md.frameScale = mmath.NewMVec3() + } + return md.frameScale +} + +func NewMorphFrameDelta() *MorphFrameDelta { + return &MorphFrameDelta{} +} + +func (md *MorphFrameDelta) Copy() *MorphFrameDelta { + return &MorphFrameDelta{ + framePosition: md.FramePosition().Copy(), + frameRotation: md.FrameRotation().Copy(), + frameScale: md.FrameScale().Copy(), + } +} + +func (mf *MorphFrame) DeformVertex( + morphName string, + model *pmx.PmxModel, + deltas *VertexMorphDeltas, + ratio float64, +) *VertexMorphDeltas { + morph := model.Morphs.GetByName(morphName) + for _, o := range morph.Offsets { + offset := o.(*pmx.VertexMorphOffset) + if 0 < offset.VertexIndex { + delta := deltas.Data[offset.VertexIndex] + if delta == nil { + delta = NewVertexMorphDelta(offset.VertexIndex) + } + if offset.Position != nil { + if delta.Position == nil { + delta.Position = offset.Position.MuledScalar(ratio) + } else if !offset.Position.IsZero() { + delta.Position.Add(offset.Position.MuledScalar(ratio)) + } + } + deltas.Data[offset.VertexIndex] = delta + } + } + + return deltas +} + +func (mf *MorphFrame) DeformAfterVertex( + morphName string, + model *pmx.PmxModel, + deltas *VertexMorphDeltas, + ratio float64, +) *VertexMorphDeltas { + morph := model.Morphs.GetByName(morphName) + for _, o := range morph.Offsets { + offset := o.(*pmx.VertexMorphOffset) + if 0 < offset.VertexIndex { + delta := deltas.Data[offset.VertexIndex] + if delta == nil { + delta = NewVertexMorphDelta(offset.VertexIndex) + } + if delta.AfterPosition == nil { + delta.AfterPosition = mmath.NewMVec3() + } + delta.AfterPosition.Add(offset.Position.MuledScalar(ratio)) + deltas.Data[offset.VertexIndex] = delta + } + } + + return deltas +} + +func (mf *MorphFrame) DeformUv( + morphName string, + model *pmx.PmxModel, + deltas *VertexMorphDeltas, + ratio float64, +) *VertexMorphDeltas { + morph := model.Morphs.GetByName(morphName) + for _, o := range morph.Offsets { + offset := o.(*pmx.UvMorphOffset) + if 0 < offset.VertexIndex { + delta := deltas.Data[offset.VertexIndex] + if delta == nil { + delta = NewVertexMorphDelta(offset.VertexIndex) + } + if delta.Uv == nil { + delta.Uv = mmath.NewMVec2() + } + uv := offset.Uv.MuledScalar(ratio).GetXY() + delta.Uv.Add(uv) + deltas.Data[offset.VertexIndex] = delta + } + } + + return deltas +} + +func (mf *MorphFrame) DeformUv1( + morphName string, + model *pmx.PmxModel, + deltas *VertexMorphDeltas, + ratio float64, +) *VertexMorphDeltas { + morph := model.Morphs.GetByName(morphName) + for _, o := range morph.Offsets { + offset := o.(*pmx.UvMorphOffset) + if 0 < offset.VertexIndex { + delta := deltas.Data[offset.VertexIndex] + if delta == nil { + delta = NewVertexMorphDelta(offset.VertexIndex) + } + if delta.Uv1 == nil { + delta.Uv1 = mmath.NewMVec2() + } + uv := offset.Uv.MuledScalar(ratio) + delta.Uv1.Add(uv.GetXY()) + deltas.Data[offset.VertexIndex] = delta + } + } + + return deltas +} + +func (mf *MorphFrame) DeformBone( + morphName string, + model *pmx.PmxModel, + deltas *BoneMorphDeltas, + ratio float64, +) *BoneMorphDeltas { + morph := model.Morphs.GetByName(morphName) + for _, o := range morph.Offsets { + offset := o.(*pmx.BoneMorphOffset) + if 0 < offset.BoneIndex { + delta := deltas.Get(offset.BoneIndex) + if delta == nil { + delta = NewBoneMorphDelta(offset.BoneIndex) + } + + offsetPos := offset.Position.MuledScalar(ratio) + offsetQuat := offset.Rotation.GetQuaternion().MuledScalar(ratio).Normalize() + offsetScale := offset.Scale.MuledScalar(ratio) + + if delta.MorphFrameDelta.framePosition == nil { + delta.MorphFrameDelta.framePosition = offsetPos + } else { + delta.MorphFrameDelta.framePosition.Add(offsetPos) + } + + if delta.MorphFrameDelta.frameRotation == nil { + delta.MorphFrameDelta.frameRotation = offsetQuat + } else { + delta.MorphFrameDelta.frameRotation = offsetQuat.Mul(delta.MorphFrameDelta.frameRotation) + } + + if delta.MorphFrameDelta.frameScale == nil { + delta.MorphFrameDelta.frameScale = offsetScale + } else { + delta.MorphFrameDelta.frameScale.Add(offsetScale) + } + + deltas.Update(delta) + } + } + + return deltas +} + +// DeformMaterial 材質モーフの適用 +func (mf *MorphFrame) DeformMaterial( + morphName string, + model *pmx.PmxModel, + deltas *MaterialMorphDeltas, + ratio float64, +) *MaterialMorphDeltas { + morph := model.Morphs.GetByName(morphName) + // 乗算→加算の順で処理 + for _, calcMode := range []pmx.MaterialMorphCalcMode{pmx.CALC_MODE_MULTIPLICATION, pmx.CALC_MODE_ADDITION} { + for _, o := range morph.Offsets { + offset := o.(*pmx.MaterialMorphOffset) + if offset.CalcMode != calcMode { + continue + } + if offset.MaterialIndex < 0 { + // 全材質対象の場合 + for m, delta := range deltas.Data { + if delta == nil { + delta = NewMaterialMorphDelta(model.Materials.Get(m)) + } + if calcMode == pmx.CALC_MODE_MULTIPLICATION { + delta.Mul(offset, ratio) + } else { + delta.Add(offset, ratio) + } + deltas.Data[m] = delta + } + } else if 0 <= offset.MaterialIndex && offset.MaterialIndex <= len(deltas.Data) { + // 特定材質のみの場合 + delta := deltas.Data[offset.MaterialIndex] + if delta == nil { + delta = NewMaterialMorphDelta(model.Materials.Get(offset.MaterialIndex)) + } + if calcMode == pmx.CALC_MODE_MULTIPLICATION { + delta.Mul(offset, ratio) + } else { + delta.Add(offset, ratio) + } + deltas.Data[offset.MaterialIndex] = delta + } + } + } + + return deltas +} diff --git a/pkg/vmd/morph_frames.go b/pkg/vmd/morph_frames.go new file mode 100644 index 00000000..237f4b79 --- /dev/null +++ b/pkg/vmd/morph_frames.go @@ -0,0 +1,137 @@ +package vmd + +import ( + "math" + + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +type MorphFrames struct { + Data map[string]*MorphNameFrames +} + +func NewMorphFrames() *MorphFrames { + return &MorphFrames{ + Data: make(map[string]*MorphNameFrames, 0), + } +} + +func (mfs *MorphFrames) Contains(morphName string) bool { + _, ok := mfs.Data[morphName] + return ok +} + +func (mfs *MorphFrames) Update(fs *MorphNameFrames) { + mfs.Data[fs.Name] = fs +} + +func (mfs *MorphFrames) GetNames() []string { + names := make([]string, 0, len(mfs.Data)) + for name := range mfs.Data { + names = append(names, name) + } + return names +} + +func (mfs *MorphFrames) Get(morphName string) *MorphNameFrames { + if !mfs.Contains(morphName) { + mfs.Update(NewMorphNameFrames(morphName)) + } + return mfs.Data[morphName] +} + +func (mfs *MorphFrames) Deform( + frame int, + model *pmx.PmxModel, + morphNames []string, +) *MorphDeltas { + mds := NewMorphDeltas(model.Materials, model.Bones) + for _, morphName := range morphNames { + if !mfs.Contains(morphName) || !model.Morphs.ContainsByName(morphName) { + continue + } + + mf := mfs.Get(morphName).Get(frame) + if mf == nil { + continue + } + + morph := model.Morphs.GetByName(morphName) + switch morph.MorphType { + case pmx.MORPH_TYPE_VERTEX: + mds.Vertices = mf.DeformVertex(morphName, model, mds.Vertices, mf.Ratio) + case pmx.MORPH_TYPE_AFTER_VERTEX: + mds.Vertices = mf.DeformAfterVertex(morphName, model, mds.Vertices, mf.Ratio) + case pmx.MORPH_TYPE_UV: + mds.Vertices = mf.DeformUv(morphName, model, mds.Vertices, mf.Ratio) + case pmx.MORPH_TYPE_EXTENDED_UV1: + mds.Vertices = mf.DeformUv1(morphName, model, mds.Vertices, mf.Ratio) + case pmx.MORPH_TYPE_BONE: + mds.Bones = mf.DeformBone(morphName, model, mds.Bones, mf.Ratio) + case pmx.MORPH_TYPE_MATERIAL: + mds.Materials = mf.DeformMaterial(morphName, model, mds.Materials, mf.Ratio) + case pmx.MORPH_TYPE_GROUP: + // グループモーフは細分化 + for _, offset := range morph.Offsets { + groupOffset := offset.(*pmx.GroupMorphOffset) + groupMorph := model.Morphs.Get(groupOffset.MorphIndex) + if groupMorph == nil { + continue + } + gmf := mfs.Get(groupMorph.Name).Get(frame) + switch groupMorph.MorphType { + case pmx.MORPH_TYPE_VERTEX: + mds.Vertices = gmf.DeformVertex( + groupMorph.Name, model, mds.Vertices, mf.Ratio*groupOffset.MorphFactor) + case pmx.MORPH_TYPE_AFTER_VERTEX: + mds.Vertices = gmf.DeformAfterVertex( + groupMorph.Name, model, mds.Vertices, mf.Ratio*groupOffset.MorphFactor) + case pmx.MORPH_TYPE_UV: + mds.Vertices = gmf.DeformUv( + groupMorph.Name, model, mds.Vertices, mf.Ratio*groupOffset.MorphFactor) + case pmx.MORPH_TYPE_EXTENDED_UV1: + mds.Vertices = gmf.DeformUv1( + groupMorph.Name, model, mds.Vertices, mf.Ratio*groupOffset.MorphFactor) + case pmx.MORPH_TYPE_BONE: + mds.Bones = gmf.DeformBone( + groupMorph.Name, model, mds.Bones, mf.Ratio*groupOffset.MorphFactor) + case pmx.MORPH_TYPE_MATERIAL: + mds.Materials = gmf.DeformMaterial( + groupMorph.Name, model, mds.Materials, mf.Ratio*groupOffset.MorphFactor) + } + } + } + } + + return mds +} + +func (mfs *MorphFrames) GetMaxFrame() int { + maxFno := int(0) + for _, mnfs := range mfs.Data { + fno := mnfs.GetMaxFrame() + if fno > maxFno { + maxFno = fno + } + } + return maxFno +} + +func (mfs *MorphFrames) GetMinFrame() int { + minFno := math.MaxInt + for _, mnfs := range mfs.Data { + fno := mnfs.GetMinFrame() + if fno < minFno { + minFno = fno + } + } + return minFno +} + +func (fs *MorphFrames) Len() int { + count := 0 + for _, fs := range fs.Data { + count += fs.RegisteredIndexes.Len() + } + return count +} diff --git a/pkg/vmd/morph_name_frames.go b/pkg/vmd/morph_name_frames.go new file mode 100644 index 00000000..520c2750 --- /dev/null +++ b/pkg/vmd/morph_name_frames.go @@ -0,0 +1,17 @@ +package vmd + +type MorphNameFrames struct { + *BaseFrames[*MorphFrame] + Name string // ボーン名 +} + +func NewMorphNameFrames(name string) *MorphNameFrames { + return &MorphNameFrames{ + BaseFrames: NewBaseFrames[*MorphFrame](NewMorphFrame, NullMorphFrame), + Name: name, + } +} + +func (i *MorphNameFrames) NewFrame(index int) *MorphFrame { + return NewMorphFrame(index) +} diff --git a/pkg/vmd/shadow_frame.go b/pkg/vmd/shadow_frame.go new file mode 100644 index 00000000..4e4a6912 --- /dev/null +++ b/pkg/vmd/shadow_frame.go @@ -0,0 +1,47 @@ +package vmd + +import "github.com/miu200521358/mlib_go/pkg/mmath" + +type ShadowFrame struct { + *BaseFrame // キーフレ + ShadowMode int // セルフ影モード + Distance float64 // 影範囲距離 +} + +func NewShadowFrame(index int) *ShadowFrame { + return &ShadowFrame{ + BaseFrame: NewFrame(index).(*BaseFrame), + ShadowMode: 0, + Distance: 0.0, + } +} + +func NullShadowFrame() *ShadowFrame { + return nil +} + +func (sf *ShadowFrame) Copy() IBaseFrame { + vv := &ShadowFrame{ + ShadowMode: sf.ShadowMode, + Distance: sf.Distance, + } + return vv +} + +func (nextSf *ShadowFrame) lerpFrame(prevFrame IBaseFrame, index int) IBaseFrame { + prevSf := prevFrame.(*ShadowFrame) + + prevIndex := prevSf.GetIndex() + nextIndex := nextSf.GetIndex() + + sf := NewShadowFrame(index) + + ry := float64(index-prevIndex) / float64(nextIndex-prevIndex) + sf.ShadowMode = prevSf.ShadowMode + sf.Distance = mmath.LerpFloat(prevSf.Distance, nextSf.Distance, ry) + + return sf +} + +func (sf *ShadowFrame) splitCurve(prevFrame IBaseFrame, nextFrame IBaseFrame, index int) { +} diff --git a/pkg/vmd/shadow_frames.go b/pkg/vmd/shadow_frames.go new file mode 100644 index 00000000..1b6f4159 --- /dev/null +++ b/pkg/vmd/shadow_frames.go @@ -0,0 +1,15 @@ +package vmd + +type ShadowFrames struct { + *BaseFrames[*ShadowFrame] +} + +func NewShadowFrames() *ShadowFrames { + return &ShadowFrames{ + BaseFrames: NewBaseFrames[*ShadowFrame](NewShadowFrame, NullShadowFrame), + } +} + +func (i *ShadowFrames) NewFrame(index int) *ShadowFrame { + return NewShadowFrame(index) +} diff --git a/pkg/vmd/vertex_delta.go b/pkg/vmd/vertex_delta.go new file mode 100644 index 00000000..4328e28b --- /dev/null +++ b/pkg/vmd/vertex_delta.go @@ -0,0 +1,132 @@ +package vmd + +import ( + "math" + "slices" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +type VertexDelta struct { + Position *mmath.MVec3 +} + +func NewVertexDelta(pos *mmath.MVec3) *VertexDelta { + return &VertexDelta{ + Position: pos, + } +} + +type VertexDeltas struct { + Data []*VertexDelta + Vertices *pmx.Vertices +} + +func NewVertexDeltas(vertices *pmx.Vertices) *VertexDeltas { + return &VertexDeltas{ + Data: make([]*VertexDelta, vertices.Len()), + Vertices: vertices, + } +} + +func (vds *VertexDeltas) Get(vertexIndex int) *VertexDelta { + if vertexIndex < 0 || vertexIndex >= len(vds.Data) { + return nil + } + + return vds.Data[vertexIndex] +} + +func (vds *VertexDeltas) FindNearestVertexIndexes(frontPos *mmath.MVec3, visibleMaterialIndexes []int) [][]int { + nearestVertexIndexes := make([][]int, 0) + distances := make([]float64, len(vds.Data)) + for i := range len(vds.Data) { + vd := vds.Get(i) + vertex := vds.Vertices.Get(i) + if visibleMaterialIndexes == nil { + distances[i] = frontPos.Distance(vd.Position) + } else { + for _, materialIndex := range visibleMaterialIndexes { + if slices.Contains(vertex.MaterialIndexes, materialIndex) { + distances[i] = frontPos.Distance(vd.Position) + break + } else { + // 非表示材質は最長距離をとりあえず入れておく + distances[i] = math.MaxFloat64 + } + } + } + } + if len(distances) == 0 { + return nearestVertexIndexes + } + sortedDistances := mmath.Float64Slice(distances) + sortedIndexes := mmath.ArgSort(sortedDistances) + nearestVertex := vds.Get(sortedIndexes[0]) + + nearestVertexIndexes = append(nearestVertexIndexes, make([]int, 0)) + nearestVertexIndexes[0] = append(nearestVertexIndexes[0], sortedIndexes[0]) + + for i := range sortedIndexes { + vd := vds.Get(sortedIndexes[i]) + if !vd.Position.NearEquals(nearestVertex.Position, 0.01) { + break + } + nearestVertexIndexes[0] = append(nearestVertexIndexes[0], sortedIndexes[i]) + } + return nearestVertexIndexes +} + +func (vds *VertexDeltas) FindVerticesInBox(prevXprevYFrontPos, prevXprevYBackPos, prevXnowYFrontPos, + prevXnowYBackPos, nowXprevYFrontPos, nowXprevYBackPos, nowXnowYFrontPos, nowXnowYBackPos *mmath.MVec3, + visibleMaterialIndexes []int) [][]int { + + boxVertexIndexes := make([][]int, 0) + vertexIndexMap := make(map[mmath.MVec3][]int, 0) + + // 境界ボックスを計算 + minPos, maxPos := mmath.CalculateBoundingBox( + prevXprevYFrontPos, prevXprevYBackPos, prevXnowYFrontPos, prevXnowYBackPos, + nowXprevYFrontPos, nowXprevYBackPos, nowXnowYFrontPos, nowXnowYBackPos, + ) + + for i := range len(vds.Data) { + vd := vds.Get(i) + vertex := vds.Vertices.Get(i) + if visibleMaterialIndexes == nil { + if vd.Position.IsPointInsideBox(minPos, maxPos) { + // 小数点第二位で四捨五入 + posKey := mmath.MVec3{math.Round(vd.Position.GetX()*100) / 100, + math.Round(vd.Position.GetY()*100) / 100, math.Round(vd.Position.GetZ()*100) / 100} + if _, ok := vertexIndexMap[posKey]; !ok { + vertexIndexMap[posKey] = make([]int, 0) + } + vertexIndexMap[posKey] = append(vertexIndexMap[posKey], vertex.Index) + } + } else { + for _, materialIndex := range visibleMaterialIndexes { + if slices.Contains(vertex.MaterialIndexes, materialIndex) { + if vd.Position.IsPointInsideBox(minPos, maxPos) { + // 小数点第二位で四捨五入 + posKey := mmath.MVec3{math.Round(vd.Position.GetX()*100) / 100, + math.Round(vd.Position.GetY()*100) / 100, math.Round(vd.Position.GetZ()*100) / 100} + if _, ok := vertexIndexMap[posKey]; !ok { + vertexIndexMap[posKey] = make([]int, 0) + } + vertexIndexMap[posKey] = append(vertexIndexMap[posKey], vertex.Index) + } + break + } + } + } + } + + for _, vertexIndexes := range vertexIndexMap { + if len(vertexIndexes) > 0 { + boxVertexIndexes = append(boxVertexIndexes, vertexIndexes) + } + } + + return boxVertexIndexes +} diff --git a/pkg/vmd/vmd_deltas.go b/pkg/vmd/vmd_deltas.go new file mode 100644 index 00000000..e2ba80c6 --- /dev/null +++ b/pkg/vmd/vmd_deltas.go @@ -0,0 +1,26 @@ +package vmd + +import ( + "github.com/go-gl/mathgl/mgl32" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +type VmdDeltas struct { + Vertices *VertexDeltas + Bones *BoneDeltas + Morphs *MorphDeltas + SelectedVertexDeltas *SelectedVertexMorphDeltas + BoneGlDeltas []mgl32.Mat4 + MeshGlDeltas []*pmx.MeshDelta + VertexMorphIndexes []int + VertexMorphGlDeltas [][]float32 + SelectedVertexIndexes []int + SelectedVertexGlDeltas [][]float32 +} + +func NewVmdDeltas(vertices *pmx.Vertices) *VmdDeltas { + return &VmdDeltas{ + Vertices: NewVertexDeltas(vertices), + SelectedVertexDeltas: NewSelectedVertexMorphDeltas(), + } +} diff --git a/pkg/vmd/vmd_motion.go b/pkg/vmd/vmd_motion.go new file mode 100644 index 00000000..ed611162 --- /dev/null +++ b/pkg/vmd/vmd_motion.go @@ -0,0 +1,134 @@ +package vmd + +import ( + "github.com/jinzhu/copier" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +type VmdMotion struct { + *mcore.HashModel + Signature string // vmdバージョン + ModelName string // モデル名 + BoneFrames *BoneFrames + MorphFrames *MorphFrames + CameraFrames *CameraFrames + LightFrames *LightFrames + ShadowFrames *ShadowFrames + IkFrames *IkFrames +} + +func NewVmdMotion(path string) *VmdMotion { + return &VmdMotion{ + HashModel: mcore.NewHashModel(path), + ModelName: "", + BoneFrames: NewBoneFrames(), + MorphFrames: NewMorphFrames(), + CameraFrames: NewCameraFrames(), + LightFrames: NewLightFrames(), + ShadowFrames: NewShadowFrames(), + IkFrames: NewIkFrames(), + } +} + +func (m *VmdMotion) Copy() mcore.IHashModel { + copied := NewVmdMotion("") + copier.CopyWithOption(copied, m, copier.Option{DeepCopy: true}) + return copied +} + +func (m *VmdMotion) GetName() string { + return m.ModelName +} + +func (m *VmdMotion) SetName(name string) { + m.ModelName = name +} + +func (m *VmdMotion) GetMaxFrame() int { + return max(m.BoneFrames.GetMaxFrame(), m.MorphFrames.GetMaxFrame()) +} + +func (m *VmdMotion) GetMinFrame() int { + return min(m.BoneFrames.GetMinFrame(), m.MorphFrames.GetMinFrame()) +} + +func (m *VmdMotion) AppendBoneFrame(boneName string, bf *BoneFrame) { + m.BoneFrames.Get(boneName).Append(bf) +} + +func (m *VmdMotion) AppendRegisteredBoneFrame(boneName string, bf *BoneFrame) { + bf.Registered = true + m.BoneFrames.Get(boneName).Append(bf) +} + +func (m *VmdMotion) AppendMorphFrame(morphName string, mf *MorphFrame) { + m.MorphFrames.Get(morphName).Append(mf) +} + +func (m *VmdMotion) AppendRegisteredMorphFrame(morphName string, mf *MorphFrame) { + mf.Registered = true + m.MorphFrames.Get(morphName).Append(mf) +} + +func (m *VmdMotion) AppendCameraFrame(cf *CameraFrame) { + m.CameraFrames.Append(cf) +} + +func (m *VmdMotion) AppendLightFrame(lf *LightFrame) { + m.LightFrames.Append(lf) +} + +func (m *VmdMotion) AppendShadowFrame(sf *ShadowFrame) { + m.ShadowFrames.Append(sf) +} + +func (m *VmdMotion) AppendIkFrame(ikf *IkFrame) { + m.IkFrames.Append(ikf) +} + +func (m *VmdMotion) InsertBoneFrame(boneName string, bf *BoneFrame) { + m.BoneFrames.Get(boneName).Insert(bf) +} + +func (m *VmdMotion) InsertRegisteredBoneFrame(boneName string, bf *BoneFrame) { + bf.Registered = true + m.BoneFrames.Get(boneName).Insert(bf) +} + +func (m *VmdMotion) InsertMorphFrame(morphName string, mf *MorphFrame) { + m.MorphFrames.Get(morphName).Insert(mf) +} + +func (m *VmdMotion) InsertCameraFrame(cf *CameraFrame) { + m.CameraFrames.Insert(cf) +} + +func (m *VmdMotion) InsertLightFrame(lf *LightFrame) { + m.LightFrames.Insert(lf) +} + +func (m *VmdMotion) InsertShadowFrame(sf *ShadowFrame) { + m.ShadowFrames.Insert(sf) +} + +func (m *VmdMotion) InsertIkFrame(ikf *IkFrame) { + m.IkFrames.Insert(ikf) +} + +func (m *VmdMotion) DeformMorph( + frame int, + model *pmx.PmxModel, + morphNames []string, +) *MorphDeltas { + if morphNames == nil { + // モーフの指定がなければ全モーフチェック + morphNames = make([]string, 0) + for _, morph := range model.Morphs.Data { + morphNames = append(morphNames, morph.Name) + } + } + + return m.MorphFrames.Deform(frame, model, morphNames) +} diff --git a/pkg/vmd/vmd_motion_2_test.go b/pkg/vmd/vmd_motion_2_test.go new file mode 100644 index 00000000..d950eb3a --- /dev/null +++ b/pkg/vmd/vmd_motion_2_test.go @@ -0,0 +1,1432 @@ +package vmd + +import ( + "testing" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +func TestVmdMotion_DeformArmIk4_DMF(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/nac_dmf_601.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/ISAO式ミク/I_ミクv4/Miku_V4.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{6.210230, 8.439670, 0.496305} + if !boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{6.210230, 8.849669, 0.496305} + if !boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{6.210230, 12.836980, -0.159825} + if !boneDeltas.GetByName("上半身").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("上半身").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("上半身").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{6.261481, 13.968025, 0.288966} + if !boneDeltas.GetByName("上半身2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("上半身2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("上半身2").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{6.541666, 15.754716, 1.421828} + if !boneDeltas.GetByName("左肩").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左肩").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左肩").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.451898, 16.031992, 1.675949} + if !boneDeltas.GetByName("左腕").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.135534, 15.373729, 1.715530} + if !boneDeltas.GetByName("左腕捩").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.646749, 13.918620, 1.803021} + if !boneDeltas.GetByName("左ひじ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.164164, 13.503792, 1.706635} + if !boneDeltas.GetByName("左手捩").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.772219, 12.307291, 1.428628} + if !boneDeltas.GetByName("左手首").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手首").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手首").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.390504, 12.011601, 1.405503} + if !boneDeltas.GetByName("左手先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.451900, 16.031990, 1.675949} + if !boneDeltas.GetByName("左腕YZ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕YZ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕YZ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.690105, 15.802624, 1.689741} + if !boneDeltas.GetByName("左腕YZ先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕YZ先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕YZ先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.690105, 15.802622, 1.689740} + if !boneDeltas.GetByName("左腕YZIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕YZIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕YZIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.451899, 16.031988, 1.675950} + if !boneDeltas.GetByName("左腕X").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕X").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕X").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.816861, 16.406412, 1.599419} + if !boneDeltas.GetByName("左腕X先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕X先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕X先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.816858, 16.406418, 1.599418} + if !boneDeltas.GetByName("左腕XIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕XIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕XIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.135530, 15.373726, 1.715530} + if !boneDeltas.GetByName("左腕捩YZ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩YZ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩YZ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.409824, 15.109610, 1.731412} + if !boneDeltas.GetByName("左腕捩YZTgt").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩YZTgt").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩YZTgt").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.409830, 15.109617, 1.731411} + if !boneDeltas.GetByName("左腕捩YZIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩YZIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩YZIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.135530, 15.373725, 1.715531} + if !boneDeltas.GetByName("左腕捩X").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩X").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩X").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.500528, 15.748149, 1.639511} + if !boneDeltas.GetByName("左腕捩XTgt").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩XTgt").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩XTgt").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.500531, 15.748233, 1.639508} + if !boneDeltas.GetByName("左腕捩XIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩XIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩XIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.646743, 13.918595, 1.803029} + if !boneDeltas.GetByName("左ひじYZ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじYZ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじYZ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.360763, 13.672787, 1.745903} + if !boneDeltas.GetByName("左ひじYZ先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじYZ先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじYZ先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.360781, 13.672805, 1.745905} + if !boneDeltas.GetByName("左ひじYZIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじYZIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじYZIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.646734, 13.918593, 1.803028} + if !boneDeltas.GetByName("左ひじX").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじX").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじX").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.944283, 13.652989, 1.456379} + if !boneDeltas.GetByName("左ひじX先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじX先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじX先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.944304, 13.653007, 1.456381} + if !boneDeltas.GetByName("左ひじXIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじXIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじXIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.646734, 13.918596, 1.803028} + if !boneDeltas.GetByName("左ひじY").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじY").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじY").GlobalPosition().MMD())) + } + } + { + // FIXME + expectedPosition := &mmath.MVec3{9.560862, 13.926876, 1.431514} + if !boneDeltas.GetByName("左ひじY先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじY先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじY先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.360781, 13.672805, 1.745905} + if !boneDeltas.GetByName("左ひじYIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじYIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじYIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.164141, 13.503780, 1.706625} + if !boneDeltas.GetByName("左手捩YZ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩YZ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩YZ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.414344, 12.859288, 1.556843} + if !boneDeltas.GetByName("左手捩YZTgt").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩YZTgt").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩YZTgt").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.414370, 12.859282, 1.556885} + if !boneDeltas.GetByName("左手捩YZIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩YZIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩YZIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.164142, 13.503780, 1.706624} + if !boneDeltas.GetByName("左手捩X").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩X").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩X").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.511073, 12.928087, 2.447041} + if !boneDeltas.GetByName("左手捩XTgt").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩XTgt").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩XTgt").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.511120, 12.928122, 2.447057} + if !boneDeltas.GetByName("左手捩XIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩XIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩XIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.471097, 12.074032, 1.410383} + if !boneDeltas.GetByName("左手YZ先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手YZ先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手YZ先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.471111, 12.074042, 1.410384} + if !boneDeltas.GetByName("左手YZIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手YZIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手YZIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.772183, 12.307314, 1.428564} + if !boneDeltas.GetByName("左手X").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手X").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手X").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.802912, 12.308764, 0.901022} + if !boneDeltas.GetByName("左手X先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手X先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手X先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.802991, 12.308830, 0.901079} + if !boneDeltas.GetByName("左手XIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手XIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手XIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.130125, 15.368912, 1.728851} + if !boneDeltas.GetByName("左腕捩1").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩1").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩1").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.365511, 15.142246, 1.742475} + if !boneDeltas.GetByName("左腕捩2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩2").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.639965, 14.877952, 1.758356} + if !boneDeltas.GetByName("左腕捩3").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩3").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩3").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.901615, 14.625986, 1.773497} + if !boneDeltas.GetByName("左腕捩4").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩4").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩4").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.641270, 13.913721, 1.816324} + if !boneDeltas.GetByName("左ひじsub").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじsub").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじsub").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.907782, 13.661371, 2.034630} + if !boneDeltas.GetByName("左ひじsub先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじsub先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじsub先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.165060, 13.499348, 1.721094} + if !boneDeltas.GetByName("左手捩1").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩1").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩1").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.978877, 13.339340, 1.683909} + if !boneDeltas.GetByName("左手捩2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩2").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.741154, 13.135028, 1.636428} + if !boneDeltas.GetByName("左手捩3").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩3").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩3").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.516553, 12.942023, 1.591578} + if !boneDeltas.GetByName("左手捩4").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩4").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩4").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.301016, 12.748707, 1.544439} + if !boneDeltas.GetByName("左手捩5").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩5").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩5").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{8.145000, 12.614601, 1.513277} + if !boneDeltas.GetByName("左手捩6").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手捩6").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手捩6").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.777408, 12.298634, 1.439762} + if !boneDeltas.GetByName("左手首R").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手首R").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手首R").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.777408, 12.298635, 1.439762} + if !boneDeltas.GetByName("左手首1").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手首1").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手首1").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.670320, 12.202144, 1.486689} + if !boneDeltas.GetByName("左手首2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左手首2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左手首2").GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformArmIk2(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("C:/MMD/mmd_base/tests/resources/唱(ダンスのみ)_0274F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/ISAO式ミク/I_ミクv4/Miku_V4_準標準.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.04952335, 9.0, 1.72378033} + if !boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.04952335, 7.97980869, 1.72378033} + if !boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.04952335, 11.02838314, 2.29172656} + if !boneDeltas.GetByName("腰").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("腰").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("腰").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.04952335, 11.9671191, 1.06765032} + if !boneDeltas.GetByName("上半身").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("上半身").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("上半身").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.26284261, 13.14576297, 0.84720008} + if !boneDeltas.GetByName("上半身2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("上半身2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("上半身2").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.33636433, 15.27729547, 0.77435588} + if !boneDeltas.GetByName("右肩").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右肩").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右肩").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.63104276, 15.44542768, 0.8507726} + if !boneDeltas.GetByName("右肩C").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右肩C").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右肩C").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.63104276, 15.44542768, 0.8507726} + if !boneDeltas.GetByName("右腕").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.90326269, 14.53727204, 0.7925801} + if !boneDeltas.GetByName("右腕捩").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.50502977, 12.52976106, 0.66393998} + if !boneDeltas.GetByName("右ひじ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.46843236, 12.88476121, 0.12831076} + if !boneDeltas.GetByName("右手捩").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.36287259, 13.90869981, -1.41662258} + if !boneDeltas.GetByName("右手首").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手首").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手首").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.81521586, 14.00661535, -1.55616424} + if !boneDeltas.GetByName("右手先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.63104276, 15.44542768, 0.8507726} + if !boneDeltas.GetByName("右腕YZ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕YZ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕YZ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.72589296, 15.12898892, 0.83049645} + if !boneDeltas.GetByName("右腕YZ先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕YZ先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕YZ先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.72589374, 15.12898632, 0.83049628} + if !boneDeltas.GetByName("右腕YZIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕YZIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕YZIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.63104276, 15.44542768, 0.8507726} + if !boneDeltas.GetByName("右腕X").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕X").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕X").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.125321, 15.600293, 0.746130} + if !boneDeltas.GetByName("右腕X先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕X先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕X先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.1253241, 15.60029489, 0.7461294} + if !boneDeltas.GetByName("右腕XIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕XIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕XIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.90325538, 14.53727326, 0.79258165} + if !boneDeltas.GetByName("右腕捩YZ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩YZ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩YZ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.01247534, 14.17289417, 0.76923367} + if !boneDeltas.GetByName("右腕捩YZTgt").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩YZTgt").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩YZTgt").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.01248754, 14.17289597, 0.76923112} + if !boneDeltas.GetByName("右腕捩YZIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩YZIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩YZIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.90325538, 14.53727326, 0.79258165} + if !boneDeltas.GetByName("右腕捩X").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩X").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩X").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.40656426, 14.68386802, 0.85919594} + if !boneDeltas.GetByName("右腕捩XTgt").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩XTgt").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩XTgt").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.40657579, 14.68387899, 0.8591982} + if !boneDeltas.GetByName("右腕捩XIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩XIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩XIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.50499623, 12.52974836, 0.66394738} + if !boneDeltas.GetByName("右ひじYZ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじYZ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじYZ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.48334366, 12.74011791, 0.34655051} + if !boneDeltas.GetByName("右ひじYZ先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじYZ先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじYZ先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.48334297, 12.74012453, 0.34654052} + if !boneDeltas.GetByName("右ひじYZIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじYZIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじYZIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.50499623, 12.52974836, 0.66394738} + if !boneDeltas.GetByName("右ひじX").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじX").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじX").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.01179616, 12.66809052, 0.72106658} + if !boneDeltas.GetByName("右ひじX先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじX先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじX先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.00760407, 12.67958516, 0.7289003} + if !boneDeltas.GetByName("右ひじXIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじXIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじXIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.50499623, 12.52974836, 0.66394738} + if !boneDeltas.GetByName("右ひじY").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじY").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじY").GlobalPosition().MMD())) + } + } + { + + expectedPosition := &mmath.MVec3{-1.485519, 12.740760, 0.346835} + if !boneDeltas.GetByName("右ひじY先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじY先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじY先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.48334297, 12.74012453, 0.34654052} + if !boneDeltas.GetByName("右ひじYIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじYIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじYIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.46845628, 12.88475892, 0.12832214} + if !boneDeltas.GetByName("右手捩YZ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩YZ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩YZ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.41168478, 13.4363328, -0.7038697} + if !boneDeltas.GetByName("右手捩YZTgt").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩YZTgt").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩YZTgt").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.41156715, 13.43632015, -0.70389025} + if !boneDeltas.GetByName("右手捩YZIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩YZIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩YZIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.46845628, 12.88475892, 0.12832214} + if !boneDeltas.GetByName("右手捩X").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩X").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩X").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.5965686, 12.06213832, -0.42564769} + if !boneDeltas.GetByName("右手捩XTgt").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩XTgt").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩XTgt").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.5965684, 12.06214091, -0.42565404} + if !boneDeltas.GetByName("右手捩XIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩XIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩XIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.7198605, 13.98597326, -1.5267472} + if !boneDeltas.GetByName("右手YZ先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手YZ先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手YZ先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.71969424, 13.98593727, -1.52669587} + if !boneDeltas.GetByName("右手YZIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手YZIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手YZIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.36306295, 13.90872698, -1.41659848} + if !boneDeltas.GetByName("右手X").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手X").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手X").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.54727182, 13.56147176, -1.06342964} + if !boneDeltas.GetByName("右手X先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手X先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手X先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.54700171, 13.5614545, -1.0633896} + if !boneDeltas.GetByName("右手XIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手XIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手XIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.90581859, 14.5370842, 0.80752276} + if !boneDeltas.GetByName("右腕捩1").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩1").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩1").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.99954005, 14.2243783, 0.78748743} + if !boneDeltas.GetByName("右腕捩2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩2").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.10880907, 13.85976329, 0.76412793} + if !boneDeltas.GetByName("右腕捩3").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩3").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩3").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.21298069, 13.51216081, 0.74185819} + if !boneDeltas.GetByName("右腕捩4").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右腕捩4").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右腕捩4").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.5074743, 12.52953348, 0.67889319} + if !boneDeltas.GetByName("右ひじsub").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじsub").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじsub").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.617075, 12.131149, 0.786797} + if !boneDeltas.GetByName("右ひじsub先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右ひじsub先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右ひじsub先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.472866, 12.872813, 0.120103} + if !boneDeltas.GetByName("右手捩1").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩1").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩1").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.458749, 13.009759, -0.086526} + if !boneDeltas.GetByName("右手捩2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩2").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.440727, 13.184620, -0.350361} + if !boneDeltas.GetByName("右手捩3").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩3").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩3").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.42368773, 13.34980879, -0.59962077} + if !boneDeltas.GetByName("右手捩4").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩4").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩4").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.40457204, 13.511055, -0.84384039} + if !boneDeltas.GetByName("右手捩5").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩5").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩5").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.39275926, 13.62582429, -1.01699954} + if !boneDeltas.GetByName("右手捩6").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手捩6").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手捩6").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.36500465, 13.89623575, -1.42501008} + if !boneDeltas.GetByName("右手首R").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手首R").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手首R").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.36500465, 13.89623575, -1.42501008} + if !boneDeltas.GetByName("右手首1").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手首1").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手首1").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.472418, 13.917203, -1.529887} + if !boneDeltas.GetByName("右手首2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右手首2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右手首2").GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk25_Addiction_Wa_Left(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/[A]ddiction_和洋_0126F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/_VMDサイジング/wa_129cm 20231028/wa_129cm_20240406.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-0.225006, 9.705784, 2.033072} + if !boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.237383, 10.769137, 2.039952} + if !boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.460140, 13.290816, 2.531440} + if !boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.460140, 13.290816, 2.531440} + if !boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.784452, 13.728909, 2.608527} + if !boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.272067, 12.381887, 2.182425} + if !boneDeltas.GetByName("左上半身C-A").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左上半身C-A").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左上半身C-A").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.406217, 13.797803, 2.460243} + if !boneDeltas.GetByName("左鎖骨IK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左鎖骨IK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左鎖骨IK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.052427, 13.347448, 2.216718} + if !boneDeltas.GetByName("左鎖骨").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左鎖骨").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左鎖骨").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.659554, 14.017852, 2.591099} + if !boneDeltas.GetByName("左鎖骨先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左鎖骨先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左鎖骨先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.065147, 13.296564, 2.607907} + if !boneDeltas.GetByName("左肩Rz検").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左肩Rz検").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左肩Rz検").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.517776, 14.134196, 2.645912} + if !boneDeltas.GetByName("左肩Rz検先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左肩Rz検先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左肩Rz検先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.065148, 13.296564, 2.607907} + if !boneDeltas.GetByName("左肩Ry検").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左肩Ry検").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左肩Ry検").GlobalPosition().MMD())) + } + } + { + // FIXME + expectedPosition := &mmath.MVec3{0.860159, 13.190875, 3.122428} + if !boneDeltas.GetByName("左肩Ry検先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左肩Ry検先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左肩Ry検先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.195053, 12.648546, 2.236849} + if !boneDeltas.GetByName("左上半身C-B").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左上半身C-B").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左上半身C-B").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.294257, 12.912640, 2.257159} + if !boneDeltas.GetByName("左上半身C-C").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左上半身C-C").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左上半身C-C").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.210011, 10.897711, 1.973442} + if !boneDeltas.GetByName("左上半身2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左上半身2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左上半身2").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.320589, 14.049745, 2.637018} + if !boneDeltas.GetByName("左襟").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左襟").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左襟").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.297636, 14.263302, 2.374467} + if !boneDeltas.GetByName("左襟先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左襟先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左襟先").GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk25_Addiction_Wa_Right(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/[A]ddiction_和洋_0126F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/_VMDサイジング/wa_129cm 20231028/wa_129cm_20240406.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{"右襟先"}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-0.225006, 9.705784, 2.033072} + if !boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.237383, 10.769137, 2.039952} + if !boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.630130, 13.306682, 2.752505} + if !boneDeltas.GetByName(pmx.SHOULDER_P.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.SHOULDER_P.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.SHOULDER_P.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.630131, 13.306683, 2.742505} + if !boneDeltas.GetByName(pmx.SHOULDER.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.SHOULDER.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.SHOULDER.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.948004, 13.753115, 2.690539} + if !boneDeltas.GetByName(pmx.ARM.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ARM.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ARM.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.611438, 12.394744, 2.353463} + if !boneDeltas.GetByName("右上半身C-A").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右上半身C-A").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右上半身C-A").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.664344, 13.835273, 2.403165} + if !boneDeltas.GetByName("右鎖骨IK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右鎖骨IK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右鎖骨IK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.270636, 13.350624, 2.258960} + if !boneDeltas.GetByName("右鎖骨").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右鎖骨").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右鎖骨").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.963317, 14.098928, 2.497183} + if !boneDeltas.GetByName("右鎖骨先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右鎖骨先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右鎖骨先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.235138, 13.300934, 2.666039} + if !boneDeltas.GetByName("右肩Rz検").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右肩Rz検").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右肩Rz検").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.847069, 13.997178, 2.886786} + if !boneDeltas.GetByName("右肩Rz検先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右肩Rz検先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右肩Rz検先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.235138, 13.300934, 2.666039} + if !boneDeltas.GetByName("右肩Ry検").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右肩Ry検").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右肩Ry検").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.172100, 13.315790, 2.838742} + if !boneDeltas.GetByName("右肩Ry検先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右肩Ry検先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右肩Ry検先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.591152, 12.674325, 2.391185} + if !boneDeltas.GetByName("右上半身C-B").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右上半身C-B").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右上半身C-B").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.588046, 12.954157, 2.432232} + if !boneDeltas.GetByName("右上半身C-C").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右上半身C-C").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右上半身C-C").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.672292, 10.939227, 2.148515} + if !boneDeltas.GetByName("右上半身2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右上半身2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右上半身2").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.520068, 14.089510, 2.812157} + if !boneDeltas.GetByName("右襟").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右襟").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右襟").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.491354, 14.225309, 2.502640} + if !boneDeltas.GetByName("右襟先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("右襟先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("右襟先").GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformIk28_Simple(t *testing.T) { + mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/IKの挙動を見たい_020.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/IKの挙動を見たい.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-9.433129, 1.363848, 1.867427} + if !boneDeltas.GetByName("A+tail").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("A+tail").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("A+tail").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-9.433129, 1.363847, 1.867427} + if !boneDeltas.GetByName("A+IK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("A+IK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("A+IK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{5.0, 4.517528, 2.142881} + if !boneDeltas.GetByName("B+tail").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("B+tail").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("B+tail").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.566871, 1.363847, 1.867427} + if !boneDeltas.GetByName("B+IK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("B+IK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("B+IK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{10.0, 3.020634, 3.984441} + if !boneDeltas.GetByName("C+tail").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("C+tail").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("C+tail").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{5.566871, 1.363848, 1.867427} + if !boneDeltas.GetByName("C+IK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("C+IK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("C+IK").GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformIk29_Simple(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/IKの挙動を見たい2_040.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/IKの挙動を見たい2.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + boneName := "A+2" + expectedPosition := &mmath.MVec3{-5.440584, 2.324726, 0.816799} + if !boneDeltas.GetByName(boneName).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(boneName).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(boneName).GlobalPosition().MMD())) + } + } + { + boneName := "A+2tail" + expectedPosition := &mmath.MVec3{-4.671312, 3.980981, -0.895119} + if !boneDeltas.GetByName(boneName).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(boneName).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(boneName).GlobalPosition().MMD())) + } + } + { + boneName := "B+2" + expectedPosition := &mmath.MVec3{4.559244, 2.324562, 0.817174} + if !boneDeltas.GetByName(boneName).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(boneName).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(boneName).GlobalPosition().MMD())) + } + } + { + boneName := "B+2tail" + expectedPosition := &mmath.MVec3{5.328533, 3.980770, -0.894783} + if !boneDeltas.GetByName(boneName).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(boneName).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(boneName).GlobalPosition().MMD())) + } + } + { + boneName := "C+2" + expectedPosition := &mmath.MVec3{8.753987, 2.042284, -0.736314} + if !boneDeltas.GetByName(boneName).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(boneName).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(boneName).GlobalPosition().MMD())) + } + } + { + boneName := "C+2tail" + expectedPosition := &mmath.MVec3{10.328943, 3.981413, -0.894101} + if !boneDeltas.GetByName(boneName).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(boneName).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(boneName).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk30_Addiction_Shoes(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/[A]ddiction_和洋_1037F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/_VMDサイジング/wa_129cm 20231028/wa_129cm_20240406.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0, 0, 0} + if !boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.748025, 1.683590, 0.556993} + if !boneDeltas.GetByName(pmx.LEG_IK.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.111190, 4.955496, 1.070225} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.724965, 3.674735, 0.810759} + if !boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.924419, 3.943549, -1.420897} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.743128, 1.672784, 0.551317} + if !boneDeltas.GetByName("左脛骨").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左脛骨").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左脛骨").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.743128, 1.672784, 0.551317} + if !boneDeltas.GetByName("左脛骨D").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左脛骨D").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左脛骨D").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.118480, 3.432016, -1.657329} + if !boneDeltas.GetByName("左脛骨D先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左脛骨D先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左脛骨D先").GlobalPosition().MMD())) + } + } + { + // FIXME + expectedPosition := &mmath.MVec3{1.763123, 3.708842, 0.369619} + if !boneDeltas.GetByName("左足Dw").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足Dw").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足Dw").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.698137, 0.674393, 0.043128} + if !boneDeltas.GetByName("左足先EX").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足先EX").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足先EX").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.712729, 0.919505, 0.174835} + if !boneDeltas.GetByName("左素足先A").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先A").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先A").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.494684, 0.328695, -0.500715} + if !boneDeltas.GetByName("左素足先A先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先A先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先A先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.494684, 0.328695, -0.500715} + if !boneDeltas.GetByName("左素足先AIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先AIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先AIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.224127, 1.738605, 0.240794} + if !boneDeltas.GetByName("左素足先B").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先B").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先B").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.582481, 0.627567, -0.222556} + if !boneDeltas.GetByName("左素足先B先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先B先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先B先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.572457, 0.658645, -0.209595} + if !boneDeltas.GetByName("左素足先BIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先BIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先BIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.448783, 1.760351, 0.405702} + if !boneDeltas.GetByName("左靴調節").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左靴調節").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左靴調節").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.875421, 0.917357, 0.652144} + if !boneDeltas.GetByName("左靴追従").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左靴追従").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左靴追従").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.404960, 1.846940, 0.380388} + if !boneDeltas.GetByName("左靴追従先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左靴追従先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左靴追従先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.448783, 1.760351, 0.405702} + if !boneDeltas.GetByName("左靴追従IK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左靴追従IK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左靴追従IK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.330700, 3.021906, 0.153679} + if !boneDeltas.GetByName("左足補D").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足補D").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足補D").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.625984, 3.444340, -1.272553} + if !boneDeltas.GetByName("左足補D先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足補D先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足補D先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.625984, 3.444340, -1.272553} + if !boneDeltas.GetByName("左足補DIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足補DIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足補DIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.724964, 3.674735, 0.810759} + if !boneDeltas.GetByName("左足向検A").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向検A").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向検A").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.924420, 3.943550, -1.420897} + if !boneDeltas.GetByName("左足向検A先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向検A先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向検A先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.924419, 3.943550, -1.420896} + if !boneDeltas.GetByName("左足向検AIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向検AIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向検AIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.724965, 3.674735, 0.810760} + if !boneDeltas.GetByName("左足向-").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向-").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向-").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.566813, 3.645544, 0.177956} + if !boneDeltas.GetByName("左足w").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足w").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足w").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.879506, 3.670895, -2.715526} + if !boneDeltas.GetByName("左足w先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足w先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足w先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.631964, 3.647012, -1.211210} + if !boneDeltas.GetByName("左膝補").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左膝補").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左膝補").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.83923, 2.876222, -1.494900} + if !boneDeltas.GetByName("左膝補先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左膝補先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左膝補先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.686400, 3.444961, -1.285575} + if !boneDeltas.GetByName("左膝補IK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左膝補IK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左膝補IK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.924420, 3.943550, -1.420896} + if !boneDeltas.GetByName("左足捩検B").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩検B").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩検B").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.952927, 7.388766, -0.972059} + if !boneDeltas.GetByName("左足捩検B先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩検B先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩検B先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.952927, 7.388766, -0.972060} + if !boneDeltas.GetByName("左足捩検BIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩検BIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩検BIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.400272, 3.809143, -0.305068} + if !boneDeltas.GetByName("左足捩").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.371963, 4.256704, -0.267830} + if !boneDeltas.GetByName("左足捩先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩先").GlobalPosition().MMD())) + } + } + } +} diff --git a/pkg/vmd/vmd_motion_test.go b/pkg/vmd/vmd_motion_test.go new file mode 100644 index 00000000..199bcf50 --- /dev/null +++ b/pkg/vmd/vmd_motion_test.go @@ -0,0 +1,3116 @@ +package vmd + +import ( + "testing" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +func TestVmdMotion_Deform_Exists(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/サンプルモーション.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(10.0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.INDEX3.Left()}, false, nil, nil) + { + expectedPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.044920, 8.218059, 0.069347} + if !boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.044920, 9.392067, 0.064877} + if !boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.044920, 11.740084, 0.055937} + if !boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.044920, 12.390969, -0.100531} + if !boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.044920, 13.803633, -0.138654} + if !boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.044920, 15.149180, 0.044429} + if !boneDeltas.GetByName(pmx.UPPER3.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER3.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER3.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.324862, 16.470263, 0.419041} + if !boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.324862, 16.470263, 0.419041} + if !boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.369838, 16.312170, 0.676838} + if !boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.845001, 15.024807, 0.747681} + if !boneDeltas.GetByName(pmx.ARM_TWIST.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ARM_TWIST.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ARM_TWIST.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.320162, 13.737446, 0.818525} + if !boneDeltas.GetByName(pmx.ELBOW.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ELBOW.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ELBOW.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.526190, 12.502445, 0.336127} + if !boneDeltas.GetByName(pmx.WRIST_TWIST.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.WRIST_TWIST.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.WRIST_TWIST.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.732219, 11.267447, -0.146273} + if !boneDeltas.GetByName(pmx.WRIST.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.WRIST.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.WRIST.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.649188, 10.546797, -0.607412} + if !boneDeltas.GetByName(pmx.INDEX1.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.INDEX1.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.INDEX1.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.408238, 10.209290, -0.576288} + if !boneDeltas.GetByName(pmx.INDEX2.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.INDEX2.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.INDEX2.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.360455, 10.422402, -0.442668} + if !boneDeltas.GetByName(pmx.INDEX3.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.INDEX3.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.INDEX3.Left()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_Deform_Lerp(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/サンプルモーション.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + fno := int(999) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.INDEX3.Left()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.508560, 8.218059, 0.791827} + if !boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.508560, 9.182008, 0.787357} + if !boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.508560, 11.530025, 0.778416} + if !boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.508560, 12.180910, 0.621949} + if !boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.437343, 13.588836, 0.523215} + if !boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.552491, 14.941880, 0.528703} + if !boneDeltas.GetByName(pmx.UPPER3.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER3.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER3.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.590927, 16.312325, 0.819156} + if !boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.590927, 16.312325, 0.819156} + if !boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.072990, 16.156742, 1.666761} + if !boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.043336, 15.182318, 2.635117} + if !boneDeltas.GetByName(pmx.ARM_TWIST.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ARM_TWIST.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ARM_TWIST.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.013682, 14.207894, 3.603473} + if !boneDeltas.GetByName(pmx.ELBOW.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ELBOW.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ELBOW.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.222444, 13.711100, 3.299384} + if !boneDeltas.GetByName(pmx.WRIST_TWIST.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.WRIST_TWIST.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.WRIST_TWIST.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.431205, 13.214306, 2.995294} + if !boneDeltas.GetByName(pmx.WRIST.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.WRIST.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.WRIST.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{3.283628, 13.209089, 2.884702} + if !boneDeltas.GetByName(pmx.INDEX1.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.INDEX1.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.INDEX1.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{3.665809, 13.070156, 2.797680} + if !boneDeltas.GetByName(pmx.INDEX2.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.INDEX2.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.INDEX2.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{3.886795, 12.968100, 2.718276} + if !boneDeltas.GetByName(pmx.INDEX3.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.INDEX3.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.INDEX3.Left()).GlobalPosition().MMD())) + } + } + } + +} + +func TestVmdMotion_DeformLegIk1_Matsu(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/サンプルモーション.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + fno := int(29) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Left(), pmx.HEEL.Left()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-0.781335, 11.717622, 1.557067} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.368843, 10.614175, 2.532657} + if !boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.983212, 6.945313, 0.487476} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.345842, 2.211842, 2.182894} + if !boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.109262, -0.025810, 1.147780} + if !boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.923587, 0.733788, 2.624565} + if !boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk2_Matsu(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/サンプルモーション.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(3152) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Left(), pmx.HEEL.Left()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{7.928583, 11.713336, 1.998830} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{7.370017, 10.665785, 2.963280} + if !boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.282883, 6.689319, 2.96825} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{4.115521, 7.276527, 2.980609} + if !boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.931355, 6.108739, 2.994883} + if !boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.569512, 7.844740, 3.002920} + if !boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk3_Matsu(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/腰元.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(60) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{1.931959, 11.695199, -1.411883} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.927524, 10.550287, -1.218106} + if !boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.263363, 7.061642, -3.837192} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.747242, 2.529942, -1.331971} + if !boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.263363, 7.061642, -3.837192} + if !boneDeltas.GetByName(pmx.KNEE_D.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE_D.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE_D.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.916109, 1.177077, -1.452845} + if !boneDeltas.GetByName(pmx.TOE_EX.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE_EX.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE_EX.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.809291, 0.242514, -1.182168} + if !boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{3.311764, 1.159233, -0.613653} + if !boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk4_Snow(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/好き雪_2794.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{1.316121, 11.687257, 2.263307} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.175478, 10.780540, 2.728409} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.950410, 11.256771, -1.589462} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.025194, 7.871110, 1.828258} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.701147, 6.066556, 3.384271} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.379169, 7.887148, 3.436968} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk5_Koshi(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/腰元.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(7409) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-7.652257, 11.990970, -4.511993} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-8.637265, 10.835548, -4.326830} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-8.693436, 7.595280, -7.321638} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-7.521027, 2.827226, -9.035607} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-7.453236, 0.356456, -8.876783} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.04) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-7.030497, 1.820072, -7.827912} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk6_KoshiOff(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/腰元.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + // IK OFF + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, false, nil, nil) + { + expectedPosition := &mmath.MVec3{1.622245, 6.632885, 0.713205} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.003185, 1.474691, 0.475763} + if !boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD())) + } + } + } + } +} + +func TestVmdMotion_DeformLegIk6_KoshiOn(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/腰元.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + // IK ON + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{2.143878, 6.558880, 1.121747} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.214143, 1.689811, 2.947619} + if !boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD())) + } + } + } + } + +} + +func TestVmdMotion_DeformLegIk6_KoshiIkOn(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/腰元.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + // IK ON + { + fno := int(0) + + ikEnabledFrame := NewIkEnableFrame(fno) + ikEnabledFrame.Enabled = true + ikEnabledFrame.BoneName = pmx.LEG_IK.Left() + + ikFrame := NewIkFrame(fno) + ikFrame.IkList = append(ikFrame.IkList, ikEnabledFrame) + + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, ikFrame) + { + expectedPosition := &mmath.MVec3{2.143878, 6.558880, 1.121747} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.214143, 1.689811, 2.947619} + if !boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD())) + } + } + } + } + +} + +func TestVmdMotion_DeformLegIk6_KoshiIkOff(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/腰元.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + // IK OFF + { + fno := int(0) + + ikEnabledFrame := NewIkEnableFrame(fno) + ikEnabledFrame.Enabled = false + ikEnabledFrame.BoneName = pmx.LEG_IK.Left() + + ikFrame := NewIkFrame(fno) + ikFrame.IkList = append(ikFrame.IkList, ikEnabledFrame) + + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, false, nil, ikFrame) + { + expectedPosition := &mmath.MVec3{1.622245, 6.632885, 0.713205} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.003185, 1.474691, 0.475763} + if !boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD())) + } + } + } + } +} + +func TestVmdMotion_DeformLegIk7_Syou(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/唱(ダンスのみ)_0278F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + // 残存回転判定用 + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.721499, 11.767294, 1.638818} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.133304, 10.693992, 2.314730} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.833401, 8.174604, -0.100545} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.409387, 5.341005, 3.524572} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.578271, 2.874233, 3.669599} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.322606, 4.249237, 4.517416} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk8_Syou(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/唱(ダンスのみ)_0-300F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(278) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.721499, 11.767294, 1.638818} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.133304, 10.693992, 2.314730} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.833401, 8.174604, -0.100545} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.409387, 5.341005, 3.524572} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.578271, 2.874233, 3.669599} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.322606, 4.249237, 4.517416} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk10_Syou1(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/唱(ダンスのみ)_0-300F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + fno := int(100) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.365000, 11.411437, 1.963828} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.513678, 10.280550, 2.500991} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.891708, 8.162312, -0.553409} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.826174, 4.330670, 2.292396} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.063101, 1.865613, 2.335564} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.178356, 3.184965, 3.282950} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } +} + +func TestVmdMotion_DeformLegIk10_Syou2(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/唱(ダンスのみ)_0-300F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + fno := int(107) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.365000, 12.042871, 2.034023} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.488466, 10.920292, 2.626419} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.607765, 6.763937, 1.653586} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.110289, 1.718307, 2.809817} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.753089, -0.026766, 1.173958} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.952785, 0.078826, 2.838099} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + +} + +func TestVmdMotion_DeformLegIk10_Syou3(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/唱(ダンスのみ)_0-300F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + fno := int(272) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-0.330117, 10.811301, 1.914508} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.325985, 9.797281, 2.479780} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.394679, 6.299243, -0.209150} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.865021, 1.642431, 2.044760} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.191817, -0.000789, 0.220605} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.958608, -0.002146, 2.055439} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + +} + +func TestVmdMotion_DeformLegIk10_Syou4(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/唱(ダンスのみ)_0-300F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + fno := int(273) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-0.154848, 10.862784, 1.868560} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.153633, 9.846655, 2.436846} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.498977, 6.380789, -0.272370} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.845777, 1.802650, 2.106815} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.239674, 0.026274, 0.426385} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.797867, 0.159797, 2.217469} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + +} + +func TestVmdMotion_DeformLegIk10_Syou5(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/唱(ダンスのみ)_0-300F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + fno := int(274) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.049523, 10.960778, 1.822612} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.930675, 9.938401, 2.400088} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.710987, 6.669293, -0.459177} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.773748, 2.387820, 2.340310} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.256876, 0.365575, 0.994345} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.556038, 0.785363, 2.653745} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + +} + +func TestVmdMotion_DeformLegIk10_Syou6(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/唱(ダンスのみ)_0-300F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + fno := int(278) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.721499, 11.767294, 1.638818} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.133304, 10.693992, 2.314730} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.833401, 8.174604, -0.100545} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.409387, 5.341005, 3.524572} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.578271, 2.874233, 3.669599} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.322606, 4.249237, 4.517416} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + +} + +func TestVmdMotion_DeformLegIk11_Shining_Miku(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/シャイニングミラクル_50F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/Tda式初音ミク_盗賊つばき流Ｍトレースモデル配布 v1.07/Tda式初音ミク_盗賊つばき流Mトレースモデルv1.07_かかと.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.LEG_IK.Right(), pmx.HEEL.Right(), "足首_R_"}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-1.869911, 2.074591, -0.911531} + if !boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.0, 0.002071, 0.0} + if !boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.0, 8.404771, -0.850001} + if !boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.0, 5.593470, -0.850001} + if !boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.0, 9.311928, -0.586922} + if !boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.0, 10.142656, -1.362172} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.843381, 8.895412, -0.666409} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.274925, 5.679991, -4.384042} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.870632, 2.072767, -0.910016} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.485913, -0.300011, -1.310446} + if !boneDeltas.GetByName("足首_R_").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("足首_R_").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("足首_R_").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.894769, 0.790468, 0.087442} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk11_Shining_Vroid(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/シャイニングミラクル_50F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.0, 9.379668, -1.051170} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.919751, 8.397145, -0.324375} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.422861, 6.169319, -4.100779} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.821804, 2.095607, -1.186269} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.390510, -0.316872, -1.544655} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.852786, 0.811991, -0.154341} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + +} + +func TestVmdMotion_DeformLegIk12_Down_Miku(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/しゃがむ.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/Tda式初音ミク_盗賊つばき流Ｍトレースモデル配布 v1.07/Tda式初音ミク_盗賊つばき流Mトレースモデルv1.07_かかと.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.LEG_IK.Right(), pmx.HEEL.Right(), "足首_R_"}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-1.012964, 1.623157, 0.680305} + if !boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.0, 5.953951, -0.512170} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.896440, 4.569404, -0.337760} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.691207, 1.986888, -4.553376} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.012964, 1.623157, 0.680305} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.013000, 0.002578, -1.146909} + if !boneDeltas.GetByName("足首_R_").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("足首_R_").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("足首_R_").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.056216, -0.001008, 0.676086} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } +} + +func TestVmdMotion_DeformLegIk13_Lamb(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/Lamb_2689F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/ゲーム/戦国BASARA/幸村 たぬき式 ver.1.24/真田幸村没第二衣装1.24軽量版.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + boneDeltas := motion.BoneFrames.Deform(0, model, + []string{pmx.LEG_IK.Right(), pmx.TOE.Right(), pmx.LEG_IK.Left(), pmx.TOE.Left(), pmx.HEEL.Left()}, true, nil, nil) + + { + + { + expectedPosition := &mmath.MVec3{-1.216134, 1.887670, -10.78867} + if !boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.803149, 6.056844, -10.232766} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.728442, 4.560226, -11.571869} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{4.173470, 0.361388, -11.217197} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.217569, 1.885731, -10.788104} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.922247, -1.163554, -10.794323} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + } + { + + { + expectedPosition := &mmath.MVec3{2.322227, 1.150214, -9.644499} + if !boneDeltas.GetByName(pmx.LEG_IK.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.803149, 6.056844, -10.232766} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.720821, 4.639688, -8.810255} + if !boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{6.126388, 5.074682, -8.346903} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.323599, 1.147291, -9.645196} + if !boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{5.163002, -0.000894, -9.714369} + if !boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk14_Ballet(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/ミク用バレリーコ_1069.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/_あにまさ式/初音ミク_準標準.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.LEG_IK.Right(), pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{11.324574, 10.920002, -7.150005} + if !boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.433170, 13.740387, 0.992719} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.982654, 11.188538, 0.602013} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{5.661557, 11.008962, -2.259013} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.224476, 10.979847, -5.407887} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{11.345482, 10.263426, -7.003638} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{9.406674, 9.687277, -5.710646} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk15_Bottom(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/●ボトム_0-300.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/Tda式初音ミク_盗賊つばき流Ｍトレースモデル配布 v1.07/Tda式初音ミク_盗賊つばき流Mトレースモデルv1.07_かかと.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(218) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.LEG_IK.Right(), pmx.HEEL.Right(), "足首_R_"}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-1.358434, 1.913062, 0.611182} + if !boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.150000, 4.253955, 0.237829} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.906292, 2.996784, 0.471846} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.533418, 3.889916, -4.114837} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.358807, 1.912181, 0.611265} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.040872, -0.188916, -0.430442} + if !boneDeltas.GetByName("足首_R_").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("足首_R_").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("足首_R_").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.292688, 0.375211, 1.133899} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk16_Lamb(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/Lamb_2689F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/ゲーム/戦国BASARA/幸村 たぬき式 ver.1.24/真田幸村没第二衣装1.24軽量版.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.LEG_IK.Right(), pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-1.216134, 1.887670, -10.78867} + if !boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.803149, 6.056844, -10.232766} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.728442, 4.560226, -11.571869} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{4.173470, 0.361388, -11.217197} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.217569, 1.885731, -10.788104} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.922247, -1.163554, -10.794323} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk17_Snow(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/好き雪_1075.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/Lat式ミクVer2.31/Lat式ミクVer2.31_White_準標準.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{2.049998, 12.957623, 1.477440} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.201382, 11.353215, 2.266898} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.443043, 7.640018, -1.308741} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.574753, 7.943915, 3.279809} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.443098, 6.324932, 4.837177} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.701516, 8.181108, 4.687274} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk18_Syou(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/唱(ダンスのみ)_0-300F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(107) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.365000, 12.042871, 2.034023} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.488466, 10.920292, 2.626419} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.607765, 6.763937, 1.653586} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.110289, 1.718307, 2.809817} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.753089, -0.026766, 1.173958} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.952785, 0.078826, 2.838099} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk19_Wa(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/129cm_001_10F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/_VMDサイジング/wa_129cm 20231028/wa_129cm_bone-structure.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.000000, 9.900000, 0.000000} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.599319, 8.639606, 0.369618} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.486516, 6.323577, -2.217865} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.501665, 2.859252, -1.902513} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-3.071062, 0.841962, -2.077063} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk20_Syou(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/唱(ダンスのみ)_0-300F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(107) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.365000, 12.042871, 2.034023} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.488466, 10.920292, 2.626419} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.607765, 6.763937, 1.653586} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.110289, 1.718307, 2.809817} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.753089, -0.026766, 1.173958} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.952785, 0.078826, 2.838099} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk21_FK(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/足FK.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル_ひざ制限なし.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, false, nil, nil) + { + expectedPosition := &mmath.MVec3{-0.133305, 10.693993, 2.314730} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.708069, 9.216356, -0.720822} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk22_Bake(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/足FK焼き込み.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル_ひざ制限なし.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-0.133306, 10.693994, 2.314731} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-3.753989, 8.506582, 1.058842} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk22_NoLimit(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/足FK.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/サンプルモデル_ひざ制限なし.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-0.133305, 10.693993, 2.314730} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{2.081436, 7.884178, -0.268146} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk23_Addiction(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/[A]ddiction_Lat式_0171F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/Tda式ミクワンピース/Tda式ミクワンピースRSP.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE_IK.Right(), "右つま先"}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0, 0.2593031, 0} + if !boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.528317, 5.033707, 3.125487} + if !boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.609285, 12.001350, 1.666402} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.129098, 10.550634, 1.348259} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.661012, 6.604201, -1.196993} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-1.529553, 5.033699, 3.127081} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.044619, 3.204468, 2.877363} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk24_Positive(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/ポジティブパレード_0526.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/_VMDサイジング/wa_129cm 20231028/wa_129cm_20240406.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0, 0, 0} + if !boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-3.312041, 6.310613, -1.134230} + if !boneDeltas.GetByName(pmx.LEG_IK.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.754258, 7.935882, -2.298871} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.455364, 6.571013, -1.935295} + if !boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.695464, 4.323516, -4.574024} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-3.322137, 6.302598, -1.131305} + if !boneDeltas.GetByName("左脛骨").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左脛骨").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左脛骨").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.575414, 5.447266, -3.254661} + if !boneDeltas.GetByName("左足捩").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.229677, 5.626327, -3.481028} + if !boneDeltas.GetByName("左足捩先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.455364, 6.571013, -1.935295} + if !boneDeltas.GetByName("左足向検A").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向検A").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向検A").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.695177, 4.324148, -4.574588} + if !boneDeltas.GetByName("左足向検A先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向検A先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向検A先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.695177, 4.324148, -4.574588} + if !boneDeltas.GetByName("左足捩検B").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩検B").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩検B").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.002697, 5.869486, -6.134800} + if !boneDeltas.GetByName("左足捩検B先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩検B先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩検B先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.877639, 4.4450495, -4.164494} + if !boneDeltas.GetByName("左膝補").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左膝補").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左膝補").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-3.523895, 4.135535, -3.716305} + if !boneDeltas.GetByName("左膝補先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左膝補先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左膝補先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.118768, 6.263350, -2.402574} + if !boneDeltas.GetByName("左足w").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足w").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足w").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.480717, 3.120446, -5.602753} + if !boneDeltas.GetByName("左足w先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足w先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足w先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.455364, 6.571013, -1.935294} + if !boneDeltas.GetByName("左足向-").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向-").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向-").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-3.322137, 6.302598, -1.131305} + if !boneDeltas.GetByName("左脛骨D").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左脛骨D").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左脛骨D").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-3.199167, 3.952319, -4.391296} + if !boneDeltas.GetByName("左脛骨D先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左脛骨D先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左脛骨D先").GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformArmIk(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/サンプルモーション.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("../../test_resources/ボーンツリーテストモデル.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(3182) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0, 0, 0} + if !boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.400011, 9.000000, 1.885650} + if !boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.400011, 8.580067, 1.885650} + if !boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.400011, 11.628636, 2.453597} + if !boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.WAIST.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.400011, 12.567377, 1.229520} + if !boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.344202, 13.782951, 1.178849} + if !boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.UPPER2.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.425960, 15.893852, 1.481421} + if !boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.SHOULDER_P.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.425960, 15.893852, 1.481421} + if !boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.SHOULDER.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{13.348320, 15.767927, 1.802947} + if !boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ARM.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{13.564770, 14.998386, 1.289923} + if !boneDeltas.GetByName(pmx.ARM_TWIST.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ARM_TWIST.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ARM_TWIST.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{14.043257, 13.297290, 0.155864} + if !boneDeltas.GetByName(pmx.ELBOW.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ELBOW.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ELBOW.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{13.811955, 13.552182, -0.388005} + if !boneDeltas.GetByName(pmx.WRIST_TWIST.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.WRIST_TWIST.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.WRIST_TWIST.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{13.144803, 14.287374, -1.956703} + if !boneDeltas.GetByName(pmx.WRIST.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.WRIST.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.WRIST.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.813587, 14.873419, -2.570278} + if !boneDeltas.GetByName(pmx.INDEX1.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.INDEX1.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.INDEX1.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.541822, 15.029200, -2.709604} + if !boneDeltas.GetByName(pmx.INDEX2.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.INDEX2.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.INDEX2.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.476499, 14.950351, -2.502167} + if !boneDeltas.GetByName(pmx.INDEX3.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.INDEX3.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.INDEX3.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{12.620306, 14.795185, -2.295859} + if !boneDeltas.GetByName("左人指先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左人指先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左人指先").GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk2(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("C:/MMD/mmd_base/tests/resources/唱(ダンスのみ)_0274F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/ISAO式ミク/I_ミクv4/Miku_V4_準標準.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0.04952335, 9.0, 1.72378033} + if !boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.CENTER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.04952335, 7.97980869, 1.72378033} + if !boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.GROOVE.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.04952335, 11.02838314, 2.29172656} + if !boneDeltas.GetByName("腰").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("腰").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("腰").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.04952335, 11.9671191, 1.06765032} + if !boneDeltas.GetByName("下半身").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("下半身").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("下半身").GlobalPosition().MMD())) + } + } + // FIXME: 物理後なので求められない + // { + // expectedPosition := &mmath.MVec3{-0.24102019, 9.79926074, 1.08498769} + // if !boneDeltas.GetByName("下半身先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + // t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("下半身先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("下半身先").GlobalPosition().MMD())) + // } + // } + { + expectedPosition := &mmath.MVec3{0.90331914, 10.27362702, 1.009499759} + if !boneDeltas.GetByName("腰キャンセル左").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("腰キャンセル左").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("腰キャンセル左").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.90331914, 10.27362702, 1.00949975} + if !boneDeltas.GetByName("左足").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.08276818, 5.59348757, -1.24981795} + if !boneDeltas.GetByName("左ひざ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひざ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひざ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{5.63290634e-01, -2.12439821e-04, -3.87768478e-01} + if !boneDeltas.GetByName("左つま先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左つま先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左つま先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.90331914, 10.27362702, 1.00949975} + if !boneDeltas.GetByName("左足D").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足D").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足D").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.23453057, 5.6736954, -0.76228439} + if !boneDeltas.GetByName("左ひざ2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひざ2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひざ2").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.12060311, 4.95396153, -1.23761938} + if !boneDeltas.GetByName("左ひざ2先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひざ2先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひざ2先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.90331914, 10.27362702, 1.00949975} + if !boneDeltas.GetByName("左足y+").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足y+").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足y+").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.74736036, 9.38409308, 0.58008117} + if !boneDeltas.GetByName("左足yTgt").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足yTgt").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足yTgt").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.74736036, 9.38409308, 0.58008117} + if !boneDeltas.GetByName("左足yIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足yIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足yIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.03018836, 10.40081089, 1.26859617} + if !boneDeltas.GetByName("左尻").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左尻").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左尻").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.08276818, 5.59348757, -1.24981795} + if !boneDeltas.GetByName("左ひざsub").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひざsub").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひざsub").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.09359026, 5.54494997, -1.80895985} + if !boneDeltas.GetByName("左ひざsub先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひざsub先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひざsub先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.23779916, 1.28891465, 1.65257835} + if !boneDeltas.GetByName("左ひざD2").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひざD2").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひざD2").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.1106881, 4.98643066, -1.26321915} + if !boneDeltas.GetByName("左ひざD2先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひざD2先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひざD2先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.12060311, 4.95396153, -1.23761938} + if !boneDeltas.GetByName("左ひざD2IK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひざD2IK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひざD2IK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.88590917, 0.38407067, 0.56801614} + if !boneDeltas.GetByName("左足ゆび").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足ゆび").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足ゆび").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{5.63290634e-01, -2.12439821e-04, -3.87768478e-01} + if !boneDeltas.GetByName("左つま先D").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左つま先D").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左つま先D").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.90331914, 10.27362702, 1.00949975} + if !boneDeltas.GetByName("左足D").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足D").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足D").GlobalPosition().MMD())) + } + } + // { + // expectedPosition := &mmath.MVec3{0.08276818, 5.59348757, -1.24981795} + // if !boneDeltas.GetByName("左ひざD").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + // t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひざD").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひざD").GlobalPosition().MMD())) + // } + // } + // { + // expectedPosition := &mmath.MVec3{1.23779916, 1.28891465, 1.65257835} + // if !boneDeltas.GetByName("左足首D").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + // t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足首D").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足首D").GlobalPosition().MMD())) + // } + // } + } +} + +func TestVmdMotion_DeformArmIk3(t *testing.T) { + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("C:/MMD/mlib_go/test_resources/Addiction_0F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/VOCALOID/初音ミク/Sour式初音ミクVer.1.02/Black_全表示.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{1.018832, 15.840092, 0.532239} + if !boneDeltas.GetByName("左腕").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.186002, 14.510550, 0.099023} + if !boneDeltas.GetByName("左腕捩").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕捩").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕捩").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.353175, 13.181011, -0.334196} + if !boneDeltas.GetByName("左ひじ").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左ひじ").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左ひじ").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.018832, 15.840092, 0.532239} + if !boneDeltas.GetByName("左腕W").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕W").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕W").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.353175, 13.181011, -0.334196} + if !boneDeltas.GetByName("左腕W先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕W先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕W先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.353175, 13.181011, -0.334196} + if !boneDeltas.GetByName("左腕WIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左腕WIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左腕WIK").GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk25_Ballet(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/青江バレリーコ_1543F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/刀剣乱舞/019_にっかり青江/にっかり青江 帽子屋式 ver2.1/帽子屋式にっかり青江（戦装束）_表示枠.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Left(), pmx.HEEL.Left(), pmx.TOE_EX.Left()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-4.374956, 13.203792, 1.554190} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-3.481956, 11.214747, 1.127255} + if !boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-7.173243, 7.787793, 0.013533} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-11.529483, 3.689184, -1.119154} + if !boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-13.408189, 1.877100, -2.183821} + if !boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-12.545708, 4.008257, -0.932670} + if !boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-3.481956, 11.214747, 1.127255} + if !boneDeltas.GetByName(pmx.LEG_D.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_D.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_D.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-7.173243, 7.787793, 0.013533} + if !boneDeltas.GetByName(pmx.KNEE_D.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE_D.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE_D.Left()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-11.529483, 3.689184, -1.119154} + if !boneDeltas.GetByName(pmx.ANKLE_D.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE_D.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE_D.Left()).GlobalPosition().MMD())) + } + } + // { + // expectedPosition := &mmath.MVec3{-12.845280, 2.816309, -2.136874} + // if !boneDeltas.GetByName(pmx.TOE_EX.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + // t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE_EX.Left()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE_EX.Left()).GlobalPosition().MMD())) + // } + // } + } +} + +func TestVmdMotion_DeformLegIk26_Far(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/足IK乖離.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/_あにまさ式ミク準標準見せパン/初音ミクVer2 準標準 見せパン 3.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + + fno := int(0) + boneDeltas := motion.BoneFrames.Deform(fno, model, []string{pmx.TOE.Right(), pmx.TOE_EX.Right(), pmx.HEEL.Right()}, true, nil, nil) + { + expectedPosition := &mmath.MVec3{-0.796811, 10.752734, -0.072743} + if !boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.202487, 10.921064, -4.695134} + if !boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-4.193142, 11.026311, -8.844866} + if !boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ANKLE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-5.108798, 10.935530, -11.494570} + if !boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-4.800813, 10.964218, -10.612234} + if !boneDeltas.GetByName(pmx.TOE_EX.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.TOE_EX.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.TOE_EX.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-4.331888, 12.178923, -9.514071} + if !boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.HEEL.Right()).GlobalPosition().MMD())) + } + } + } +} + +func TestVmdMotion_DeformLegIk27_Addiction_Shoes(t *testing.T) { + // mlog.SetLevel(mlog.IK_VERBOSE) + + vr := &VmdMotionReader{} + motionData, err := vr.ReadByFilepath("../../test_resources/[A]ddiction_和洋_1074-1078F.vmd") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + motion := motionData.(*VmdMotion) + + pr := &pmx.PmxReader{} + modelData, err := pr.ReadByFilepath("D:/MMD/MikuMikuDance_v926x64/UserFile/Model/_VMDサイジング/wa_129cm 20231028/wa_129cm_20240406.pmx") + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + model := modelData.(*pmx.PmxModel) + + { + fno := int(2) + boneDeltas := motion.BoneFrames.Deform(fno, model, nil, true, nil, nil) + { + expectedPosition := &mmath.MVec3{0, 0, 0} + if !boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.ROOT.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.406722, 1.841236, 0.277818} + if !boneDeltas.GetByName(pmx.LEG_IK.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG_IK.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.510231, 9.009953, 0.592482} + if !boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LOWER.String()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.355914, 7.853320, 0.415251} + if !boneDeltas.GetByName(pmx.LEG.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.LEG.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.327781, 5.203806, -1.073718} + if !boneDeltas.GetByName(pmx.KNEE.Left()).GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName(pmx.KNEE.Right()).GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.407848, 1.839228, 0.278700} + if !boneDeltas.GetByName("左脛骨").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左脛骨").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左脛骨").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.407848, 1.839228, 0.278700} + if !boneDeltas.GetByName("左脛骨D").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左脛骨D").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左脛骨D").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.498054, 5.045506, -1.221016} + if !boneDeltas.GetByName("左脛骨D先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左脛骨D先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左脛骨D先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.462306, 7.684025, 0.087026} + if !boneDeltas.GetByName("左足Dw").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足Dw").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足Dw").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.593721, 0.784840, -0.054141} + if !boneDeltas.GetByName("左足先EX").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足先EX").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足先EX").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.551940, 1.045847, 0.034003} + if !boneDeltas.GetByName("左素足先A").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先A").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先A").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.453982, 0.305976, -0.510022} + if !boneDeltas.GetByName("左素足先A先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先A先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先A先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.453982, 0.305976, -0.510022} + if !boneDeltas.GetByName("左素足先AIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先AIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先AIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.941880, 2.132958, 0.020403} + if !boneDeltas.GetByName("左素足先B").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先B").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先B").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.359364, 0.974298, -0.226041} + if !boneDeltas.GetByName("左素足先B先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先B先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先B先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.460890, 0.692527, -0.285973} + if !boneDeltas.GetByName("左素足先BIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左素足先BIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左素足先BIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.173929, 2.066327, 0.182685} + if !boneDeltas.GetByName("左靴調節").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左靴調節").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左靴調節").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.739235, 1.171441, 0.485052} + if !boneDeltas.GetByName("左靴追従").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左靴追従").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左靴追従").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.186359, 2.046771, 0.189367} + if !boneDeltas.GetByName("左靴追従先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左靴追従先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左靴追従先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.173929, 2.066327, 0.182685} + if !boneDeltas.GetByName("左靴追従IK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左靴追従IK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左靴追従IK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.574899, 6.873434, 0.342768} + if !boneDeltas.GetByName("左足補D").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足補D").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足補D").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.150401, 5.170907, -0.712416} + if !boneDeltas.GetByName("左足補D先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足補D先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足補D先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.150401, 5.170907, -0.712416} + if !boneDeltas.GetByName("左足補DIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足補DIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足補DIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.355915, 7.853319, 0.415251} + if !boneDeltas.GetByName("左足向検A").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向検A").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向検A").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.327781, 5.203805, -1.073719} + if !boneDeltas.GetByName("左足向検A先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向検A先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向検A先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.327781, 5.203805, -1.073719} + if !boneDeltas.GetByName("左足向検AIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向検AIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向検AIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.355914, 7.853319, 0.415251} + if !boneDeltas.GetByName("左足向-").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足向-").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足向-").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{1.264808, 7.561551, -0.161703} + if !boneDeltas.GetByName("左足w").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足w").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足w").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.714029, 3.930234, -1.935889} + if !boneDeltas.GetByName("左足w先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足w先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足w先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.016770, 5.319929, -0.781771} + if !boneDeltas.GetByName("左膝補").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左膝補").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左膝補").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.164672, 4.511360, -0.957886} + if !boneDeltas.GetByName("左膝補先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左膝補先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左膝補先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.099887, 4.800064, -0.895003} + if !boneDeltas.GetByName("左膝補IK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左膝補IK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左膝補IK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-0.327781, 5.203806, -1.073718} + if !boneDeltas.GetByName("左足捩検B").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩検B").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩検B").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.392915, 7.450026, -2.735495} + if !boneDeltas.GetByName("左足捩検B先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩検B先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩検B先").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{-2.392915, 7.450026, -2.735495} + if !boneDeltas.GetByName("左足捩検BIK").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩検BIK").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩検BIK").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.514067, 6.528563, -0.329234} + if !boneDeltas.GetByName("左足捩").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩").GlobalPosition().MMD())) + } + } + { + expectedPosition := &mmath.MVec3{0.231636, 6.794109, -0.557747} + if !boneDeltas.GetByName("左足捩先").GlobalPosition().MMD().NearEquals(expectedPosition, 0.03) { + t.Errorf("Expected %v, got %v (%.3f)", expectedPosition, boneDeltas.GetByName("左足捩先").GlobalPosition().MMD(), expectedPosition.Distance(boneDeltas.GetByName("左足捩先").GlobalPosition().MMD())) + } + } + } +} diff --git a/pkg/vmd/vmd_reader.go b/pkg/vmd/vmd_reader.go new file mode 100644 index 00000000..e7b41111 --- /dev/null +++ b/pkg/vmd/vmd_reader.go @@ -0,0 +1,488 @@ +package vmd + +import ( + "bytes" + + "golang.org/x/text/encoding/japanese" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" +) + +// https://hariganep.seesaa.net/article/201103article_1.html +// https://blog.goo.ne.jp/torisu_tetosuki/e/bc9f1c4d597341b394bd02b64597499d +// https://w.atwiki.jp/kumiho_k/pages/15.html + +// VMDリーダー +type VmdMotionReader struct { + mcore.BaseReader[*VmdMotion] +} + +func (r *VmdMotionReader) createModel(path string) *VmdMotion { + model := NewVmdMotion(path) + return model +} + +// 指定されたパスのファイルからデータを読み込む +func (r *VmdMotionReader) ReadByFilepath(path string) (mcore.IHashModel, error) { + // モデルを新規作成 + motion := r.createModel(path) + + hash, err := r.ReadHashByFilePath(path) + if err != nil { + mlog.E("ReadByFilepath.ReadHashByFilePath error: %v", err) + return motion, err + } + motion.Hash = hash + + // ファイルを開く + err = r.Open(path) + if err != nil { + mlog.E("ReadByFilepath.Open error: %v", err) + return motion, err + } + + err = r.readHeader(motion) + if err != nil { + mlog.E("ReadByFilepath.readHeader error: %v", err) + return motion, err + } + + err = r.readData(motion) + if err != nil { + mlog.E("ReadByFilepath.readData error: %v", err) + return motion, err + } + + r.Close() + + return motion, nil +} + +func (r *VmdMotionReader) ReadNameByFilepath(path string) (string, error) { + // モデルを新規作成 + motion := r.createModel(path) + + // ファイルを開く + err := r.Open(path) + if err != nil { + mlog.E("ReadNameByFilepath.Open error: %v", err) + return "", err + } + + err = r.readHeader(motion) + if err != nil { + mlog.E("ReadNameByFilepath.readHeader error: %v", err) + return "", err + } + + r.Close() + + return motion.ModelName, nil +} + +func (r *VmdMotionReader) DecodeShiftJIS(fbytes []byte) (string, error) { + // VMDは空白込みで入っているので、正規表現で空白以降は削除する + decodedBytes, err := japanese.ShiftJIS.NewDecoder().Bytes(fbytes) + if err != nil { + mlog.E("DecodeShiftJIS error: %v", err) + return "", err + } + + trimBytes := bytes.TrimRight(decodedBytes, "\xfd") // PMDで保存したVMDに入ってる + trimBytes = bytes.TrimRight(trimBytes, "\x00") + + decodedText := string(trimBytes) + + return decodedText, nil +} + +func (r *VmdMotionReader) ReadText(size int) (string, error) { + fbytes, err := r.UnpackBytes(size) + if err != nil { + mlog.E("ReadText error: %v", err) + return "", err + } + return r.DecodeShiftJIS(fbytes) +} + +func (r *VmdMotionReader) readHeader(motion *VmdMotion) error { + r.DefineEncoding(japanese.ShiftJIS) + + // vmdバージョン + signature, err := r.ReadText(30) + if err != nil { + mlog.E("readHeader.ReadText error: %v", err) + return err + } + motion.Signature = signature + + // モデル名 + motion.ModelName, err = r.ReadText(20) + if err != nil { + mlog.E("readHeader.ReadText error: %v", err) + return err + } + + return nil +} + +func (r *VmdMotionReader) readData(motion *VmdMotion) error { + err := r.readBones(motion) + if err != nil { + mlog.E("readData.readBones error: %v", err) + return err + } + + err = r.readMorphs(motion) + if err != nil { + mlog.E("readData.readMorphs error: %v", err) + return err + } + + err = r.readCameras(motion) + if err != nil { + // カメラがなくてもエラーにしないが、後続は読まない + mlog.E("readData.readCameras error: %v", err) + return nil + } + + err = r.readLights(motion) + if err != nil { + // ライトがなくてもエラーにしないが、後続は読まない + mlog.E("readData.readLights error: %v", err) + return nil + } + + err = r.readShadows(motion) + if err != nil { + // シャドウがなくてもエラーにしないが、後続は読まない + mlog.E("readData.readShadows error: %v", err) + return nil + } + + err = r.readIks(motion) + if err != nil { + // IKがなくてもエラーにしないが、後続は読まない + mlog.E("readData.readIks error: %v", err) + return nil + } + + return nil +} + +func (r *VmdMotionReader) readBones(motion *VmdMotion) error { + totalCount, err := r.UnpackUInt() + if err != nil { + mlog.E("readBones.totalCount error: %v", err) + return err + } + + for i := 0; i < int(totalCount); i++ { + v := &BoneFrame{ + BaseFrame: NewFrame(i).(*BaseFrame), + } + v.Read = true + + // ボーン名 + boneName, err := r.ReadText(15) + if err != nil { + mlog.E("[%d] readBones.boneName error: %v", i, err) + return err + } + + // キーフレ番号 + index, err := r.UnpackUInt() + if err != nil { + mlog.E("[%d] readBones.index error: %v", i, err) + return err + } + v.SetIndex(int(index)) + + // 位置X,Y,Z + position, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readBones.Position error: %v", i, err) + return err + } + v.Position = &position + + // 回転X,Y,Z,W + qq, err := r.UnpackQuaternion(true) + if err != nil { + mlog.E("[%d] readBones.Quaternion error: %v", i, err) + return err + } + v.Rotation = &qq + + // 補間曲線 + curves, err := r.UnpackBytes(64) + if err != nil { + mlog.E("[%d] readBones.Curves error: %v", i, err) + return err + } + v.Curves = NewBoneCurvesByValues(curves) + + motion.AppendRegisteredBoneFrame(boneName, v) + } + + return nil +} + +func (r *VmdMotionReader) readMorphs(motion *VmdMotion) error { + totalCount, err := r.UnpackUInt() + if err != nil { + mlog.E("readMorphs.totalCount error: %v", err) + return err + } + + for i := 0; i < int(totalCount); i++ { + v := NewMorphFrame(0) + v.Registered = true + v.Read = true + + // モーフ名 + morphName, err := r.ReadText(15) + if err != nil { + mlog.E("[%d] readMorphs.morphName error: %v", i, err) + return err + } + + // キーフレ番号 + index, err := r.UnpackUInt() + if err != nil { + mlog.E("[%d] readMorphs.index error: %v", i, err) + return err + } + v.SetIndex(int(index)) + + // ratio + v.Ratio, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readMorphs.Ratio error: %v", i, err) + return err + } + + motion.AppendMorphFrame(morphName, v) + } + + return nil +} + +func (r *VmdMotionReader) readCameras(motion *VmdMotion) error { + totalCount, err := r.UnpackUInt() + if err != nil { + mlog.E("readCameras.totalCount error: %v", err) + return err + } + + for i := 0; i < int(totalCount); i++ { + v := NewCameraFrame(0) + v.Registered = true + v.Read = true + + // キーフレ番号 + index, err := r.UnpackUInt() + if err != nil { + mlog.E("[%d] readCameras.index error: %v", i, err) + return err + } + v.SetIndex(int(index)) + + // 距離 + v.Distance, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readCameras.Distance error: %v", i, err) + return err + } + + // 位置X,Y,Z + position, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readCameras.Position error: %v", i, err) + return err + } + v.Position = &position + + // 回転(オイラー角度) + degrees, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readCameras.Degrees error: %v", i, err) + return err + } + v.Rotation = mmath.NewRotationFromDegrees(°rees) + + // 補間曲線 + curves, err := r.UnpackBytes(24) + if err != nil { + mlog.E("[%d] readCameras.Curves error: %v", i, err) + return err + } + v.Curves = NewCameraCurvesByValues(curves) + + // 視野角 + viewOfAngle, err := r.UnpackUInt() + if err != nil { + mlog.E("[%d] readCameras.ViewOfAngle error: %v", i, err) + return err + } + v.ViewOfAngle = int(viewOfAngle) + + // パースOFF + perspective, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readCameras.Perspective error: %v", i, err) + return err + } + v.IsPerspectiveOff = perspective == 1 + + motion.AppendCameraFrame(v) + } + + return nil +} + +func (r *VmdMotionReader) readLights(motion *VmdMotion) error { + totalCount, err := r.UnpackUInt() + if err != nil { + mlog.E("readLights.totalCount error: %v", err) + return err + } + + for i := 0; i < int(totalCount); i++ { + v := NewLightFrame(0) + v.Registered = true + v.Read = true + + // キーフレ番号 + index, err := r.UnpackUInt() + if err != nil { + mlog.E("[%d] readLights.index error: %v", i, err) + return err + } + v.SetIndex(int(index)) + + // 照明色 + color, err := r.UnpackVec3(false) + if err != nil { + mlog.E("[%d] readLights.Color error: %v", i, err) + return err + } + v.Color = &color + + // 位置X,Y,Z + position, err := r.UnpackVec3(true) + if err != nil { + mlog.E("[%d] readLights.Position error: %v", i, err) + return err + } + v.Position = &position + + motion.AppendLightFrame(v) + } + + return nil +} + +func (r *VmdMotionReader) readShadows(motion *VmdMotion) error { + totalCount, err := r.UnpackUInt() + if err != nil { + mlog.E("readShadows.totalCount error: %v", err) + return err + } + + for i := 0; i < int(totalCount); i++ { + v := NewShadowFrame(0) + v.Registered = true + v.Read = true + + // キーフレ番号 + index, err := r.UnpackUInt() + if err != nil { + mlog.E("[%d] readShadows.index error: %v", i, err) + return err + } + v.SetIndex(int(index)) + + // セルフ影タイプ + shadowMode, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readShadows.ShadowMode error: %v", i, err) + return err + } + v.ShadowMode = int(shadowMode) + + // 距離 + v.Distance, err = r.UnpackFloat() + if err != nil { + mlog.E("[%d] readShadows.Distance error: %v", i, err) + return err + } + + motion.AppendShadowFrame(v) + } + + return nil +} + +func (r *VmdMotionReader) readIks(motion *VmdMotion) error { + totalCount, err := r.UnpackUInt() + if err != nil { + mlog.E("readIks.totalCount error: %v", err) + return err + } + + for i := 0; i < int(totalCount); i++ { + v := NewIkFrame(0) + v.Registered = true + v.Read = true + + // キーフレ番号 + index, err := r.UnpackUInt() + if err != nil { + mlog.E("[%d] readIks.index error: %v", i, err) + return err + } + v.SetIndex(int(index)) + + // モデル表示 + visible, err := r.UnpackByte() + if err != nil { + mlog.E("[%d] readIks.Visible error: %v", i, err) + return err + } + v.Visible = visible == 1 + + // IKリストの数 + ikCount, err := r.UnpackUInt() + if err != nil { + mlog.E("[%d] readIks.IkCount error: %v", i, err) + return err + } + for j := 0; j < int(ikCount); j++ { + ik := NewIkEnableFrame(v.GetIndex()) + + // IKボーン名 + ik.BoneName, err = r.ReadText(20) + if err != nil { + mlog.E("[%d][%d] readIks.Ik.BoneName error: %v", i, j, err) + return err + } + + // IK有効無効 + enabled, err := r.UnpackByte() + if err != nil { + mlog.E("[%d][%d] readIks.Ik.Enabled error: %v", i, j, err) + return err + } + ik.Enabled = enabled == 1 + + v.IkList = append(v.IkList, ik) + } + + motion.AppendIkFrame(v) + } + + return nil +} diff --git a/pkg/vmd/vmd_reader_test.go b/pkg/vmd/vmd_reader_test.go new file mode 100644 index 00000000..6d3c2f9e --- /dev/null +++ b/pkg/vmd/vmd_reader_test.go @@ -0,0 +1,341 @@ +package vmd + +import ( + "testing" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/pmx" +) + +func TestVmdMotionReader_ReadNameByFilepath(t *testing.T) { + r := &VmdMotionReader{} + + // Test case 1: Successful read + path := "../../test_resources/サンプルモーション_0046.vmd" + modelName, err := r.ReadNameByFilepath(path) + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + expectedModelName := "初音ミク準標準" + if modelName != expectedModelName { + t.Errorf("Expected modelName to be %q, got %q", expectedModelName, modelName) + } +} + +func TestVmdMotionReader_ReadByFilepath(t *testing.T) { + r := &VmdMotionReader{} + + // Test case 2: File not found + invalidPath := "../../test_resources/nonexistent.vmd" + _, err := r.ReadByFilepath(invalidPath) + + if err == nil { + t.Errorf("Expected error to be not nil, got nil") + } + + // Test case 1: Successful read + path := "../../test_resources/サンプルモーション.vmd" + model, err := r.ReadByFilepath(path) + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + // Verify the model properties + expectedPath := path + if model.GetPath() != expectedPath { + t.Errorf("Expected Path to be %q, got %q", expectedPath, model.GetPath()) + } + + // モデル名 + expectedModelName := "日本 roco式 トレス用" + if model.GetName() != expectedModelName { + t.Errorf("Expected modelName to be %q, got %q", expectedModelName, model.GetName()) + } + + motion := model.(*VmdMotion) + + // キーフレがある + { + bf := motion.BoneFrames.Get(pmx.CENTER.String()).Get(358) + + // フレーム番号 + expectedFrameNo := int(358) + if bf.GetIndex() != expectedFrameNo { + t.Errorf("Expected FrameNo to be %d, got %d", expectedFrameNo, bf.GetIndex()) + } + + // 位置 + expectedPosition := &mmath.MVec3{1.094920158, 0, 0.100637913} + if !bf.Position.MMD().NearEquals(expectedPosition, 1e-8) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, bf.Position.MMD()) + } + + // 回転 + expectedRotation := mmath.NewMQuaternionByValues(0, 0, 0, 1) + if 1-bf.Rotation.Dot(expectedRotation) > 1e-8 { + t.Errorf("Expected Rotation to be %v, got %v", expectedRotation, bf.Rotation) + } + + // 補間曲線 + expectedTranslateXStart := &mmath.MVec2{64, 0} + if !bf.Curves.TranslateX.Start.NearEquals(expectedTranslateXStart, 1e-5) { + t.Errorf("Expected TranslateX.Start to be %v, got %v", expectedTranslateXStart, bf.Curves.TranslateX.Start) + } + + expectedTranslateXEnd := &mmath.MVec2{87, 87} + if !bf.Curves.TranslateX.End.NearEquals(expectedTranslateXEnd, 1e-5) { + t.Errorf("Expected TranslateX.End to be %v, got %v", expectedTranslateXEnd, bf.Curves.TranslateX.End) + } + + expectedTranslateYStart := &mmath.MVec2{20, 20} + if !bf.Curves.TranslateY.Start.NearEquals(expectedTranslateYStart, 1e-5) { + t.Errorf("Expected TranslateY.Start to be %v, got %v", expectedTranslateYStart, bf.Curves.TranslateY.Start) + } + + expectedTranslateYEnd := &mmath.MVec2{107, 107} + if !bf.Curves.TranslateY.End.NearEquals(expectedTranslateYEnd, 1e-5) { + t.Errorf("Expected TranslateY.End to be %v, got %v", expectedTranslateYEnd, bf.Curves.TranslateY.End) + } + + expectedTranslateZStart := &mmath.MVec2{64, 0} + if !bf.Curves.TranslateZ.Start.NearEquals(expectedTranslateZStart, 1e-5) { + t.Errorf("Expected TranslateZ.Start to be %v, got %v", expectedTranslateZStart, bf.Curves.TranslateZ.Start) + } + + expectedTranslateZEnd := &mmath.MVec2{87, 87} + if !bf.Curves.TranslateZ.End.NearEquals(expectedTranslateZEnd, 1e-5) { + t.Errorf("Expected TranslateZ.End to be %v, got %v", expectedTranslateZEnd, bf.Curves.TranslateZ.End) + } + + expectedRotateStart := &mmath.MVec2{20, 20} + if !bf.Curves.Rotate.Start.NearEquals(expectedRotateStart, 1e-5) { + t.Errorf("Expected Rotate.Start to be %v, got %v", expectedRotateStart, bf.Curves.Rotate.Start) + } + + expectedRotateEnd := &mmath.MVec2{107, 107} + if !bf.Curves.Rotate.End.NearEquals(expectedRotateEnd, 1e-5) { + t.Errorf("Expected Rotate.End to be %v, got %v", expectedRotateEnd, bf.Curves.Rotate.End) + } + } + + { + bf := motion.BoneFrames.Get(pmx.UPPER.String()).Get(689) + + // フレーム番号 + expectedFrameNo := int(689) + if bf.GetIndex() != expectedFrameNo { + t.Errorf("Expected FrameNo to be %d, got %d", expectedFrameNo, bf.GetIndex()) + } + + // 位置 + expectedPosition := &mmath.MVec3{0, 0, 0} + if !bf.Position.MMD().NearEquals(expectedPosition, 1e-8) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, bf.Position.MMD()) + } + + // 回転 + expectedDegrees := &mmath.MVec3{-6.270921156, -26.96361355, 0.63172903} + if bf.Rotation.ToMMDDegrees().NearEquals(expectedDegrees, 1e-8) { + t.Errorf("Expected Rotation to be %v, got %v", expectedDegrees, bf.Rotation) + } + + // 補間曲線 + expectedTranslateXStart := &mmath.MVec2{20, 20} + if !bf.Curves.TranslateX.Start.NearEquals(expectedTranslateXStart, 1e-5) { + t.Errorf("Expected TranslateX.Start to be %v, got %v", expectedTranslateXStart, bf.Curves.TranslateX.Start) + } + + expectedTranslateXEnd := &mmath.MVec2{107, 107} + if !bf.Curves.TranslateX.End.NearEquals(expectedTranslateXEnd, 1e-5) { + t.Errorf("Expected TranslateX.End to be %v, got %v", expectedTranslateXEnd, bf.Curves.TranslateX.End) + } + + expectedTranslateYStart := &mmath.MVec2{20, 20} + if !bf.Curves.TranslateY.Start.NearEquals(expectedTranslateYStart, 1e-5) { + t.Errorf("Expected TranslateY.Start to be %v, got %v", expectedTranslateYStart, bf.Curves.TranslateY.Start) + } + + expectedTranslateYEnd := &mmath.MVec2{107, 107} + if !bf.Curves.TranslateY.End.NearEquals(expectedTranslateYEnd, 1e-5) { + t.Errorf("Expected TranslateY.End to be %v, got %v", expectedTranslateYEnd, bf.Curves.TranslateY.End) + } + + expectedTranslateZStart := &mmath.MVec2{20, 20} + if !bf.Curves.TranslateZ.Start.NearEquals(expectedTranslateZStart, 1e-5) { + t.Errorf("Expected TranslateZ.Start to be %v, got %v", expectedTranslateZStart, bf.Curves.TranslateZ.Start) + } + + expectedTranslateZEnd := &mmath.MVec2{107, 107} + if !bf.Curves.TranslateZ.End.NearEquals(expectedTranslateZEnd, 1e-5) { + t.Errorf("Expected TranslateZ.End to be %v, got %v", expectedTranslateZEnd, bf.Curves.TranslateZ.End) + } + + expectedRotateStart := &mmath.MVec2{20, 20} + if !bf.Curves.Rotate.Start.NearEquals(expectedRotateStart, 1e-5) { + t.Errorf("Expected Rotate.Start to be %v, got %v", expectedRotateStart, bf.Curves.Rotate.Start) + } + + expectedRotateEnd := &mmath.MVec2{107, 107} + if !bf.Curves.Rotate.End.NearEquals(expectedRotateEnd, 1e-5) { + t.Errorf("Expected Rotate.End to be %v, got %v", expectedRotateEnd, bf.Curves.Rotate.End) + } + } + + { + bf := motion.BoneFrames.Get(pmx.LEG_IK.Right()).Get(384) + + // フレーム番号 + expectedFrameNo := int(384) + if bf.GetIndex() != expectedFrameNo { + t.Errorf("Expected FrameNo to be %d, got %d", expectedFrameNo, bf.GetIndex()) + } + + // 位置 + expectedPosition := &mmath.MVec3{0.548680067, 0.134522215, -2.504074097} + if !bf.Position.MMD().NearEquals(expectedPosition, 1e-8) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, bf.Position.MMD()) + } + + // 回転 + expectedDegrees := &mmath.MVec3{22.20309405, 6.80959631, 2.583712695} + if bf.Rotation.ToMMDDegrees().NearEquals(expectedDegrees, 1e-8) { + t.Errorf("Expected Rotation to be %v, got %v", expectedDegrees, bf.Rotation) + } + + // 補間曲線 + expectedTranslateXStart := &mmath.MVec2{64, 0} + if !bf.Curves.TranslateX.Start.NearEquals(expectedTranslateXStart, 1e-5) { + t.Errorf("Expected TranslateX.Start to be %v, got %v", expectedTranslateXStart, bf.Curves.TranslateX.Start) + } + + expectedTranslateXEnd := &mmath.MVec2{64, 127} + if !bf.Curves.TranslateX.End.NearEquals(expectedTranslateXEnd, 1e-5) { + t.Errorf("Expected TranslateX.End to be %v, got %v", expectedTranslateXEnd, bf.Curves.TranslateX.End) + } + + expectedTranslateYStart := &mmath.MVec2{64, 0} + if !bf.Curves.TranslateY.Start.NearEquals(expectedTranslateYStart, 1e-5) { + t.Errorf("Expected TranslateY.Start to be %v, got %v", expectedTranslateYStart, bf.Curves.TranslateY.Start) + } + + expectedTranslateYEnd := &mmath.MVec2{87, 87} + if !bf.Curves.TranslateY.End.NearEquals(expectedTranslateYEnd, 1e-5) { + t.Errorf("Expected TranslateY.End to be %v, got %v", expectedTranslateYEnd, bf.Curves.TranslateY.End) + } + + expectedTranslateZStart := &mmath.MVec2{64, 0} + if !bf.Curves.TranslateZ.Start.NearEquals(expectedTranslateZStart, 1e-5) { + t.Errorf("Expected TranslateZ.Start to be %v, got %v", expectedTranslateZStart, bf.Curves.TranslateZ.Start) + } + + expectedTranslateZEnd := &mmath.MVec2{64, 127} + if !bf.Curves.TranslateZ.End.NearEquals(expectedTranslateZEnd, 1e-5) { + t.Errorf("Expected TranslateZ.End to be %v, got %v", expectedTranslateZEnd, bf.Curves.TranslateZ.End) + } + + expectedRotateStart := &mmath.MVec2{64, 0} + if !bf.Curves.Rotate.Start.NearEquals(expectedRotateStart, 1e-5) { + t.Errorf("Expected Rotate.Start to be %v, got %v", expectedRotateStart, bf.Curves.Rotate.Start) + } + + expectedRotateEnd := &mmath.MVec2{87, 87} + if !bf.Curves.Rotate.End.NearEquals(expectedRotateEnd, 1e-5) { + t.Errorf("Expected Rotate.End to be %v, got %v", expectedRotateEnd, bf.Curves.Rotate.End) + } + } + + { + // キーがないフレーム + bf := motion.BoneFrames.Get(pmx.LEG_IK.Left()).Get(384) + + // フレーム番号 + expectedFrameNo := int(384) + if bf.GetIndex() != expectedFrameNo { + t.Errorf("Expected FrameNo to be %d, got %d", expectedFrameNo, bf.GetIndex()) + } + + // 位置 + expectedPosition := &mmath.MVec3{-1.63, 0.05, 2.58} + if !bf.Position.MMD().NearEquals(expectedPosition, 1e-2) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, bf.Position.MMD()) + } + + // 回転 + expectedDegrees := &mmath.MVec3{-1.4, 6.7, -5.2} + if bf.Rotation.ToMMDDegrees().NearEquals(expectedDegrees, 1e-2) { + t.Errorf("Expected Rotation to be %v, got %v", expectedDegrees, bf.Rotation) + } + } + + { + // キーがないフレーム + bf := motion.BoneFrames.Get(pmx.LEG_IK.Left()).Get(394) + + // フレーム番号 + expectedFrameNo := int(394) + if bf.GetIndex() != expectedFrameNo { + t.Errorf("Expected FrameNo to be %d, got %d", expectedFrameNo, bf.GetIndex()) + } + + // 位置 + expectedPosition := &mmath.MVec3{0.76, 1.17, 1.34} + if !bf.Position.MMD().NearEquals(expectedPosition, 1e-2) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, bf.Position.MMD()) + } + + // 回転 + expectedDegrees := &mmath.MVec3{-41.9, -1.6, 1.0} + if bf.Rotation.ToMMDDegrees().NearEquals(expectedDegrees, 1e-2) { + t.Errorf("Expected Rotation to be %v, got %v", expectedDegrees, bf.Rotation) + } + } + + { + // キーがないフレーム + bf := motion.BoneFrames.Get(pmx.LEG_IK.Left()).Get(412) + + // フレーム番号 + expectedFrameNo := int(412) + if bf.GetIndex() != expectedFrameNo { + t.Errorf("Expected FrameNo to be %d, got %d", expectedFrameNo, bf.GetIndex()) + } + + // 位置 + expectedPosition := &mmath.MVec3{-0.76, -0.61, -1.76} + if !bf.Position.MMD().NearEquals(expectedPosition, 1e-2) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, bf.Position.MMD()) + } + + // 回転 + expectedDegrees := &mmath.MVec3{43.1, 0.0, 0.0} + if bf.Rotation.ToMMDDegrees().NearEquals(expectedDegrees, 1e-2) { + t.Errorf("Expected Rotation to be %v, got %v", expectedDegrees, bf.Rotation) + } + } + + { + // キーがないフレーム + bf := motion.BoneFrames.Get(pmx.ARM.Right()).Get(384) + + // フレーム番号 + expectedFrameNo := int(384) + if bf.GetIndex() != expectedFrameNo { + t.Errorf("Expected FrameNo to be %d, got %d", expectedFrameNo, bf.GetIndex()) + } + + // 位置 + expectedPosition := &mmath.MVec3{0.0, 0.0, 0.0} + if !bf.Position.MMD().NearEquals(expectedPosition, 1e-2) { + t.Errorf("Expected Position to be %v, got %v", expectedPosition, bf.Position.MMD()) + } + + // 回転 + expectedDegrees := &mmath.MVec3{13.5, -4.3, 27.0} + if bf.Rotation.ToMMDDegrees().NearEquals(expectedDegrees, 1e-2) { + t.Errorf("Expected Rotation to be %v, got %v", expectedDegrees, bf.Rotation) + } + } +} diff --git a/pkg/vmd/vmd_vpd_reader.go b/pkg/vmd/vmd_vpd_reader.go new file mode 100644 index 00000000..dfd3305f --- /dev/null +++ b/pkg/vmd/vmd_vpd_reader.go @@ -0,0 +1,38 @@ +package vmd + +import ( + "strings" + + "github.com/miu200521358/mlib_go/pkg/mcore" +) + +// VMDリーダー +type VmdVpdMotionReader struct { + mcore.BaseReader[*VmdMotion] + vmdReader *VmdMotionReader + vpdReader *VpdMotionReader +} + +func NewVmdVpdMotionReader() *VmdVpdMotionReader { + reader := new(VmdVpdMotionReader) + reader.vmdReader = &VmdMotionReader{} + reader.vpdReader = &VpdMotionReader{} + return reader +} + +// 指定されたパスのファイルからデータを読み込む +func (r *VmdVpdMotionReader) ReadByFilepath(path string) (mcore.IHashModel, error) { + if strings.HasSuffix(strings.ToLower(path), ".vpd") { + return r.vpdReader.ReadByFilepath(path) + } else { + return r.vmdReader.ReadByFilepath(path) + } +} + +func (r *VmdVpdMotionReader) ReadNameByFilepath(path string) (string, error) { + if strings.HasSuffix(strings.ToLower(path), ".vpd") { + return r.vpdReader.ReadNameByFilepath(path) + } else { + return r.vmdReader.ReadNameByFilepath(path) + } +} diff --git a/pkg/vmd/vmd_writer.go b/pkg/vmd/vmd_writer.go new file mode 100644 index 00000000..5d90b6c0 --- /dev/null +++ b/pkg/vmd/vmd_writer.go @@ -0,0 +1,454 @@ +package vmd + +import ( + "bytes" + "encoding/binary" + "fmt" + "io" + "math" + "os" + + "golang.org/x/text/encoding/japanese" + "golang.org/x/text/transform" + + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils" + "github.com/miu200521358/mlib_go/pkg/mutils/mi18n" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" +) + +func (motion *VmdMotion) Save(overrideModelName, overridePath string) error { + path := motion.GetPath() + // 保存可能なパスである場合、上書き + if mutils.CanSave(overridePath) { + path = overridePath + } + + modelName := motion.GetName() + // モデル名が指定されている場合、上書き + if overrideModelName != "" { + modelName = overrideModelName + } + + // Open the output file + fout, err := os.Create(path) + if err != nil { + return err + } + + // Write the header + header := []byte("Vocaloid Motion Data 0002\x00\x00\x00\x00\x00") + _, err = fout.Write(header) + if err != nil { + return err + } + + // Convert model name to shift_jis encoding + modelBName, err := encodeName(modelName, 20) + if err != nil { + mlog.W(mi18n.T("モデル名エンコードエラー", map[string]interface{}{"Name": modelName})) + modelBName = []byte("Vmd Model") + } + + // Write the model name + err = binary.Write(fout, binary.LittleEndian, modelBName) + if err != nil { + return err + } + + // Write the bone frames + err = writeBoneFrames(fout, motion) + if err != nil { + mlog.E(mi18n.T("ボーンフレーム書き込みエラー")) + return err + } + + // Write the morph frames + err = writeMorphFrames(fout, motion) + if err != nil { + mlog.E(mi18n.T("モーフフレーム書き込みエラー")) + return err + } + + // Write the camera frames + err = writeCameraFrames(fout, motion) + if err != nil { + mlog.E(mi18n.T("カメラフレーム書き込みエラー")) + return err + } + + // Write the Light frames + err = writeLightFrames(fout, motion) + if err != nil { + mlog.E(mi18n.T("照明フレーム書き込みエラー")) + return err + } + + // Write the Shadow frames + err = writeShadowFrames(fout, motion) + if err != nil { + mlog.E(mi18n.T("照明フレーム書き込みエラー")) + return err + } + + // Write the IK frames + err = writeIkFrames(fout, motion) + if err != nil { + mlog.E(mi18n.T("IKフレーム書き込みエラー")) + return err + } + + // foutを書き込んで終了する + err = fout.Close() + if err != nil { + mlog.E(mi18n.T("ファイルクローズエラー", map[string]interface{}{"Path": motion.GetPath()})) + return err + } + + return nil +} + +func writeBoneFrames(fout *os.File, motion *VmdMotion) error { + names := motion.BoneFrames.GetNames() + + binary.Write(fout, binary.LittleEndian, uint32(motion.BoneFrames.Len())) + for _, name := range names { + fs := motion.BoneFrames.Data[name] + + if fs.Len() > 0 { + // 各ボーンの最大キーフレを先に出力する + bf := motion.BoneFrames.Data[name].Get(fs.RegisteredIndexes.Max()) + err := writeBoneFrame(fout, name, bf) + if err != nil { + return err + } + } + } + + for _, name := range names { + fs := motion.BoneFrames.Data[name] + if fs.Len() > 1 { + // 普通のキーフレをそのまま出力する + for _, fno := range fs.RegisteredIndexes.List()[:fs.Len()-1] { + bf := fs.Get(fno) + err := writeBoneFrame(fout, name, bf) + if err != nil { + return err + } + } + } + } + + return nil +} + +func writeBoneFrame(fout *os.File, name string, bf *BoneFrame) error { + if bf == nil { + return fmt.Errorf("BoneFrame is nil") + } + + encodedName, err := encodeName(name, 15) + if err != nil { + mlog.W(mi18n.T("ボーン名エンコードエラー", map[string]interface{}{"Name": name})) + return err + } + + var posMMD *mmath.MVec3 + if bf.Position != nil { + posMMD = bf.Position + } else { + posMMD = mmath.MVec3Zero + } + binary.Write(fout, binary.LittleEndian, encodedName) + binary.Write(fout, binary.LittleEndian, uint32(bf.Index)) + binary.Write(fout, binary.LittleEndian, float32(posMMD.GetX())) + binary.Write(fout, binary.LittleEndian, float32(posMMD.GetY())) + binary.Write(fout, binary.LittleEndian, float32(posMMD.GetZ())) + + var quatMMD *mmath.MQuaternion + if bf.Rotation != nil { + quatMMD = bf.Rotation.Normalized() + } else { + quatMMD = &mmath.MQuaternionIdent + } + binary.Write(fout, binary.LittleEndian, float32(quatMMD.GetX())) + binary.Write(fout, binary.LittleEndian, float32(quatMMD.GetY())) + binary.Write(fout, binary.LittleEndian, float32(quatMMD.GetZ())) + binary.Write(fout, binary.LittleEndian, float32(quatMMD.GetW())) + + var curves []byte + if bf.Curves == nil { + curves = InitialBoneCurves + } else { + curves = make([]byte, len(bf.Curves.Values)) + for i, x := range bf.Curves.Merge() { + curves[i] = byte(math.Min(255, math.Max(0, float64(x)))) + } + } + binary.Write(fout, binary.LittleEndian, curves) + + return nil +} + +func writeMorphFrames(fout *os.File, motion *VmdMotion) error { + binary.Write(fout, binary.LittleEndian, uint32(motion.MorphFrames.Len())) + + names := motion.MorphFrames.GetNames() + + for _, name := range names { + fs := motion.MorphFrames.Data[name] + if fs.RegisteredIndexes.Len() > 0 { + // 普通のキーフレをそのまま出力する + for _, fno := range fs.RegisteredIndexes.List() { + mf := fs.Get(fno) + err := writeMorphFrame(fout, name, mf) + if err != nil { + return err + } + } + } + } + + return nil +} + +func writeMorphFrame(fout *os.File, name string, mf *MorphFrame) error { + if mf == nil { + return fmt.Errorf("MorphFrame is nil") + } + + encodedName, err := encodeName(name, 15) + if err != nil { + mlog.W(mi18n.T("ボーン名エンコードエラー", map[string]interface{}{"Name": name})) + return err + } + + binary.Write(fout, binary.LittleEndian, encodedName) + binary.Write(fout, binary.LittleEndian, uint32(mf.Index)) + binary.Write(fout, binary.LittleEndian, float32(mf.Ratio)) + + return nil +} + +func writeCameraFrames(fout *os.File, motion *VmdMotion) error { + binary.Write(fout, binary.LittleEndian, uint32(motion.CameraFrames.Len())) + + fs := motion.CameraFrames + if fs.RegisteredIndexes.Len() > 0 { + // 普通のキーフレをそのまま出力する + for _, fno := range fs.RegisteredIndexes.List() { + cf := fs.Get(fno) + err := writeCameraFrame(fout, cf) + if err != nil { + return err + } + } + } + + return nil +} + +func writeCameraFrame(fout *os.File, cf *CameraFrame) error { + if cf == nil { + return fmt.Errorf("CameraFrame is nil") + } + + binary.Write(fout, binary.LittleEndian, uint32(cf.Index)) + binary.Write(fout, binary.LittleEndian, float32(cf.Distance)) + + var posMMD *mmath.MVec3 + if cf.Position != nil { + posMMD = cf.Position + } else { + posMMD = mmath.MVec3Zero + } + + binary.Write(fout, binary.LittleEndian, float32(posMMD.GetX())) + binary.Write(fout, binary.LittleEndian, float32(posMMD.GetY())) + binary.Write(fout, binary.LittleEndian, float32(posMMD.GetZ())) + + var degreeMMD *mmath.MVec3 + if cf.Rotation != nil { + degreeMMD = cf.Rotation.GetDegrees() + } else { + degreeMMD = mmath.MVec3Zero + } + binary.Write(fout, binary.LittleEndian, float32(degreeMMD.GetX())) + binary.Write(fout, binary.LittleEndian, float32(degreeMMD.GetY())) + binary.Write(fout, binary.LittleEndian, float32(degreeMMD.GetZ())) + + var curves []byte + if cf.Curves == nil { + curves = InitialCameraCurves + } else { + curves = make([]byte, len(cf.Curves.Values)) + for i, x := range cf.Curves.Merge() { + curves[i] = byte(math.Min(255, math.Max(0, float64(x)))) + } + } + binary.Write(fout, binary.LittleEndian, curves) + + binary.Write(fout, binary.LittleEndian, uint32(cf.ViewOfAngle)) + binary.Write(fout, binary.LittleEndian, byte(mmath.BoolToInt(cf.IsPerspectiveOff))) + + return nil +} + +func writeLightFrames(fout *os.File, motion *VmdMotion) error { + binary.Write(fout, binary.LittleEndian, uint32(motion.LightFrames.Len())) + + fs := motion.LightFrames + if fs.RegisteredIndexes.Len() > 0 { + // 普通のキーフレをそのまま出力する + for _, fno := range fs.RegisteredIndexes.List() { + cf := fs.Get(fno) + err := writeLightFrame(fout, cf) + if err != nil { + return err + } + } + } + + return nil +} + +func writeLightFrame(fout *os.File, cf *LightFrame) error { + if cf == nil { + return fmt.Errorf("LightFrame is nil") + } + + binary.Write(fout, binary.LittleEndian, uint32(cf.Index)) + + var colorMMD *mmath.MVec3 + if cf.Color != nil { + colorMMD = cf.Color + } else { + colorMMD = mmath.MVec3Zero + } + + binary.Write(fout, binary.LittleEndian, float32(colorMMD.GetX())) + binary.Write(fout, binary.LittleEndian, float32(colorMMD.GetY())) + binary.Write(fout, binary.LittleEndian, float32(colorMMD.GetZ())) + + var posMMD *mmath.MVec3 + if cf.Position != nil { + posMMD = cf.Position + } else { + posMMD = mmath.MVec3Zero + } + + binary.Write(fout, binary.LittleEndian, float32(posMMD.GetX())) + binary.Write(fout, binary.LittleEndian, float32(posMMD.GetY())) + binary.Write(fout, binary.LittleEndian, float32(posMMD.GetZ())) + + return nil +} + +func writeShadowFrames(fout *os.File, motion *VmdMotion) error { + binary.Write(fout, binary.LittleEndian, uint32(motion.ShadowFrames.Len())) + + fs := motion.ShadowFrames + if fs.RegisteredIndexes.Len() > 0 { + // 普通のキーフレをそのまま出力する + for _, fno := range fs.RegisteredIndexes.List() { + cf := fs.Get(fno) + err := writeShadowFrame(fout, cf) + if err != nil { + return err + } + } + } + + return nil +} + +func writeShadowFrame(fout *os.File, cf *ShadowFrame) error { + if cf == nil { + return fmt.Errorf("ShadowFrame is nil") + } + + binary.Write(fout, binary.LittleEndian, uint32(cf.Index)) + + binary.Write(fout, binary.LittleEndian, float32(cf.ShadowMode)) + binary.Write(fout, binary.LittleEndian, float32(cf.Distance)) + + return nil +} + +func writeIkFrames(fout *os.File, motion *VmdMotion) error { + binary.Write(fout, binary.LittleEndian, uint32(motion.IkFrames.Len())) + + fs := motion.IkFrames + if fs.RegisteredIndexes.Len() > 0 { + // 普通のキーフレをそのまま出力する + for _, fno := range fs.RegisteredIndexes.List() { + cf := fs.Get(fno) + err := writeIkFrame(fout, cf) + if err != nil { + return err + } + } + } + + return nil +} + +func writeIkFrame(fout *os.File, cf *IkFrame) error { + if cf == nil { + return fmt.Errorf("IkFrame is nil") + } + + binary.Write(fout, binary.LittleEndian, uint32(cf.Index)) + binary.Write(fout, binary.LittleEndian, byte(mmath.BoolToInt(cf.Visible))) + binary.Write(fout, binary.LittleEndian, uint32(len(cf.IkList))) + + fs := cf.IkList + if len(fs) > 0 { + // 普通のキーフレをそのまま出力する + for _, ik := range fs { + encodedName, err := encodeName(ik.BoneName, 20) + if err != nil { + mlog.W(mi18n.T("ボーン名エンコードエラー", map[string]interface{}{"Name": ik.BoneName})) + return err + } + + binary.Write(fout, binary.LittleEndian, encodedName) + binary.Write(fout, binary.LittleEndian, byte(mmath.BoolToInt(ik.Enabled))) + } + } + + return nil +} + +func encodeName(name string, limit int) ([]byte, error) { + // Encode to CP932 + cp932Encoder := japanese.ShiftJIS.NewEncoder() + cp932Encoded, err := cp932Encoder.String(name) + if err != nil { + return []byte(""), err + } + + // Decode to Shift_JIS + shiftJISDecoder := japanese.ShiftJIS.NewDecoder() + reader := transform.NewReader(bytes.NewReader([]byte(cp932Encoded)), shiftJISDecoder) + shiftJISDecoded, err := io.ReadAll(reader) + if err != nil { + return []byte(""), err + } + + // Encode to Shift_JIS + shiftJISEncoder := japanese.ShiftJIS.NewEncoder() + shiftJISEncoded, err := shiftJISEncoder.String(string(shiftJISDecoded)) + if err != nil { + return []byte(""), err + } + + encodedName := []byte(shiftJISEncoded) + if len(encodedName) <= limit { + // 指定バイト数に足りない場合は b"\x00" で埋める + encodedName = append(encodedName, make([]byte, limit-len(encodedName))...) + } + + // 指定バイト数に切り詰め + return encodedName[:limit], nil +} diff --git a/pkg/vmd/vmd_writer_test.go b/pkg/vmd/vmd_writer_test.go new file mode 100644 index 00000000..3cb14770 --- /dev/null +++ b/pkg/vmd/vmd_writer_test.go @@ -0,0 +1,152 @@ +package vmd + +import ( + "testing" + + "github.com/miu200521358/mlib_go/pkg/mmath" +) + +func TestVmdWriter_Write1(t *testing.T) { + path := "../../test_resources/test_output.vmd" + + // Create a VmdMotion instance for testing + motion := NewVmdMotion(path) + motion.SetName("Null_00") + + bf := NewBoneFrame(0) + bf.Position = &mmath.MVec3{1, 2, 3} + bf.Rotation = mmath.NewMQuaternionFromDegrees(10, 20, 30) + motion.AppendRegisteredBoneFrame("センター", bf) + + // Create a VmdWriter instance + err := motion.Save("", "") + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + r := &VmdMotionReader{} + reloadData, err := r.ReadByFilepath(path) + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + reloadMotion := reloadData.(*VmdMotion) + + if reloadMotion.GetName() != motion.GetName() { + t.Errorf("Expected model name to be '%s', got %q", motion.GetName(), reloadMotion.GetName()) + } + + if reloadMotion.BoneFrames.Contains("センター") == false { + t.Errorf("Expected センター to be contained in bone frames") + } + + if reloadMotion.BoneFrames.Data["センター"].Contains(0) == false { + t.Errorf("Expected センター to contain frame 0") + } + + reloadBf := reloadMotion.BoneFrames.Data["センター"].Get(0) + if reloadBf.Position.NearEquals(bf.Position, 1e-8) == false { + t.Errorf("Expected position to be %v, got %v", bf.Position, reloadBf.Position.MMD()) + } + // if reloadBf.Rotation.GetDegrees().NearEquals(bf.Rotation.GetDegrees(), 1e-5) == false { + // t.Errorf("Expected rotation to be %v, got %v", bf.Rotation.GetDegrees(), reloadBf.Rotation.GetDegrees()) + // } + +} + +func TestVmdWriter_Write2(t *testing.T) { + // Test case 1: Successful read + readPath := "../../test_resources/サンプルモーション.vmd" + + r := &VmdMotionReader{} + model, err := r.ReadByFilepath(readPath) + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + outputPath := "../../test_resources/test_output.vmd" + + motion := model.(*VmdMotion) + motion.Path = outputPath + + // Create a VmdWriter instance + err = motion.Save("", "") + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + reloadData, err := r.ReadByFilepath(outputPath) + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + reloadMotion := reloadData.(*VmdMotion) + + if reloadMotion.GetName() != motion.GetName() { + t.Errorf("Expected model name to be '%s', got %q", motion.GetName(), reloadMotion.GetName()) + } + +} + +func TestVmdWriter_Write3(t *testing.T) { + // Test case 1: Successful read + readPath := "../../test_resources/ドクヘビ_178cmカメラ.vmd" + + r := &VmdMotionReader{} + model, err := r.ReadByFilepath(readPath) + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + outputPath := "../../test_resources/test_output.vmd" + motion := model.(*VmdMotion) + + // Create a VmdWriter instance + err = motion.Save("", outputPath) + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + reloadData, err := r.ReadByFilepath(outputPath) + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + reloadMotion := reloadData.(*VmdMotion) + + if reloadMotion.GetName() != motion.GetName() { + t.Errorf("Expected model name to be '%s', got %q", motion.GetName(), reloadMotion.GetName()) + } + +} + +func TestVmdWriter_Write4(t *testing.T) { + // Test case 1: Successful read + readPath := "../../test_resources/モーフ_まばたき.vmd" + + r := &VmdMotionReader{} + model, err := r.ReadByFilepath(readPath) + + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + outputPath := "../../test_resources/test_output.vmd" + motion := model.(*VmdMotion) + + // Create a VmdWriter instance + err = motion.Save("", outputPath) + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + + reloadData, err := r.ReadByFilepath(outputPath) + if err != nil { + t.Errorf("Expected error to be nil, got %q", err) + } + reloadMotion := reloadData.(*VmdMotion) + + if reloadMotion.GetName() != motion.GetName() { + t.Errorf("Expected model name to be '%s', got %q", motion.GetName(), reloadMotion.GetName()) + } + +} diff --git a/pkg/vmd/vpd_reader.go b/pkg/vmd/vpd_reader.go new file mode 100644 index 00000000..77a0af50 --- /dev/null +++ b/pkg/vmd/vpd_reader.go @@ -0,0 +1,191 @@ +package vmd + +import ( + "bufio" + "regexp" + "strconv" + "strings" + + "github.com/miu200521358/mlib_go/pkg/mcore" + "github.com/miu200521358/mlib_go/pkg/mmath" + "github.com/miu200521358/mlib_go/pkg/mutils/mlog" + "golang.org/x/text/encoding/japanese" + "golang.org/x/text/transform" +) + +// VMDリーダー +type VpdMotionReader struct { + mcore.BaseReader[*VmdMotion] + lines []string +} + +func (r *VpdMotionReader) createModel(path string) *VmdMotion { + model := NewVmdMotion(path) + return model +} + +// 指定されたパスのファイルからデータを読み込む +func (r *VpdMotionReader) ReadByFilepath(path string) (mcore.IHashModel, error) { + // モデルを新規作成 + motion := r.createModel(path) + + hash, err := r.ReadHashByFilePath(path) + if err != nil { + mlog.E("ReadByFilepath.ReadHashByFilePath error: %v", err) + return motion, err + } + motion.Hash = hash + + // ファイルを開く + err = r.Open(path) + if err != nil { + mlog.E("ReadByFilepath.Open error: %v", err) + return motion, err + } + + err = r.readLines() + if err != nil { + mlog.E("ReadByFilepath.readLines error: %v", err) + return motion, err + } + + err = r.readHeader(motion) + if err != nil { + mlog.E("ReadByFilepath.readHeader error: %v", err) + return motion, err + } + + err = r.readData(motion) + if err != nil { + mlog.E("ReadByFilepath.readData error: %v", err) + return motion, err + } + + r.Close() + + return motion, nil +} + +func (r *VpdMotionReader) ReadNameByFilepath(path string) (string, error) { + // モデルを新規作成 + motion := r.createModel(path) + + // ファイルを開く + err := r.Open(path) + if err != nil { + mlog.E("ReadNameByFilepath.Open error: %v", err) + return "", err + } + + err = r.readLines() + if err != nil { + mlog.E("ReadByFilepath.readLines error: %v", err) + return "", err + } + + err = r.readHeader(motion) + if err != nil { + mlog.E("ReadNameByFilepath.readHeader error: %v", err) + return "", err + } + + r.Close() + + return motion.ModelName, nil +} + +func (r *VpdMotionReader) readLines() error { + var lines []string + + sjisReader := transform.NewReader(r.File, japanese.ShiftJIS.NewDecoder()) + scanner := bufio.NewScanner(sjisReader) + for scanner.Scan() { + txt := scanner.Text() + txt = strings.ReplaceAll(txt, "\t", " ") + lines = append(lines, txt) + } + r.lines = lines + return scanner.Err() +} + +func (r *VpdMotionReader) ReadText(line string, pattern *regexp.Regexp) ([]string, error) { + matches := pattern.FindStringSubmatch(line) + if len(matches) > 0 { + return matches, nil + } + return nil, nil +} + +func (r *VpdMotionReader) readHeader(motion *VmdMotion) error { + signaturePattern := regexp.MustCompile(`Vocaloid Pose Data file`) + modelNamePattern := regexp.MustCompile(`(.*)(\.osm;.*// 親ファイル名)`) + + // signature + { + matches, err := r.ReadText(r.lines[0], signaturePattern) + if err != nil || len(matches) == 0 { + mlog.E("readHeader.ReadText error: %v", err) + return err + } + } + + // モデル名 + matches, err := r.ReadText(r.lines[2], modelNamePattern) + if err != nil { + mlog.E("readHeader.ReadText error: %v", err) + return err + } + + if len(matches) > 0 { + motion.ModelName = matches[1] + } + + return nil +} + +func (r *VpdMotionReader) readData(motion *VmdMotion) error { + boneStartPattern := regexp.MustCompile(`(?:.*)(?:{)(.*)`) + bonePosPattern := regexp.MustCompile(`([+-]?\d+(?:\.\d+))(?:,)([+-]?\d+(?:\.\d+))(?:,)([+-]?\d+(?:\.\d+))(?:;)(?:.*trans.*)`) + boneRotPattern := regexp.MustCompile(`([+-]?\d+(?:\.\d+))(?:,)([+-]?\d+(?:\.\d+))(?:,)([+-]?\d+(?:\.\d+))(?:,)([+-]?\d+(?:\.\d+))(?:;)(?:.*Quaternion.*)`) + + var bf *BoneFrame + var boneName string + for _, line := range r.lines { + { + // 括弧開始: ボーン名 + matches, err := r.ReadText(line, boneStartPattern) + if err == nil && len(matches) > 0 { + boneName = matches[1] + bf = NewBoneFrame(0) + continue + } + } + { + // ボーン位置 + matches, err := r.ReadText(line, bonePosPattern) + if err == nil && len(matches) > 0 { + x, _ := strconv.ParseFloat(matches[1], 64) + y, _ := strconv.ParseFloat(matches[2], 64) + z, _ := strconv.ParseFloat(matches[3], 64) + bf.Position = &mmath.MVec3{x, y, z} + continue + } + } + { + // ボーン角度 + matches, err := r.ReadText(line, boneRotPattern) + if err == nil && len(matches) > 0 { + x, _ := strconv.ParseFloat(matches[1], 64) + y, _ := strconv.ParseFloat(matches[2], 64) + z, _ := strconv.ParseFloat(matches[3], 64) + w, _ := strconv.ParseFloat(matches[4], 64) + bf.Rotation = mmath.NewMQuaternionByValues(x, y, z, w) + + motion.AppendRegisteredBoneFrame(boneName, bf) + continue + } + } + } + + return nil +} diff --git a/test_resources/grid.png b/test_resources/grid.png new file mode 100644 index 00000000..6ba0e34d Binary files /dev/null and b/test_resources/grid.png differ diff --git a/test_resources/number/number.png b/test_resources/number/number.png new file mode 100644 index 00000000..91f98168 Binary files /dev/null and b/test_resources/number/number.png differ diff --git a/test_resources/number/number.psd b/test_resources/number/number.psd new file mode 100644 index 00000000..613e23dc Binary files /dev/null and b/test_resources/number/number.psd differ diff --git a/test_resources/sdef.png b/test_resources/sdef.png new file mode 100644 index 00000000..916405a4 Binary files /dev/null and b/test_resources/sdef.png differ diff --git "a/test_resources/\343\201\227\343\202\203\343\201\214\343\202\200.vmd" "b/test_resources/\343\201\227\343\202\203\343\201\214\343\202\200.vmd" new file mode 100644 index 00000000..992a096f Binary files /dev/null and "b/test_resources/\343\201\227\343\202\203\343\201\214\343\202\200.vmd" differ diff --git "a/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\207\343\203\253.pmx" "b/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\207\343\203\253.pmx" new file mode 100644 index 00000000..42ec2e9d Binary files /dev/null and "b/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\207\343\203\253.pmx" differ diff --git "a/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\207\343\203\253_PMX2.1_UTF-8.pmx" "b/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\207\343\203\253_PMX2.1_UTF-8.pmx" new file mode 100644 index 00000000..0c575d89 Binary files /dev/null and "b/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\207\343\203\253_PMX2.1_UTF-8.pmx" differ diff --git "a/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\274\343\202\267\343\203\247\343\203\263.vmd" "b/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\274\343\202\267\343\203\247\343\203\263.vmd" new file mode 100644 index 00000000..2d7c590f Binary files /dev/null and "b/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\274\343\202\267\343\203\247\343\203\263.vmd" differ diff --git "a/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\274\343\202\267\343\203\247\343\203\263_0046.vmd" "b/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\274\343\202\267\343\203\247\343\203\263_0046.vmd" new file mode 100644 index 00000000..9c058ad9 Binary files /dev/null and "b/test_resources/\343\202\265\343\203\263\343\203\227\343\203\253\343\203\242\343\203\274\343\202\267\343\203\247\343\203\263_0046.vmd" differ diff --git "a/test_resources/\345\271\263\351\235\242.pmx" "b/test_resources/\345\271\263\351\235\242.pmx" new file mode 100644 index 00000000..1e0ed0af Binary files /dev/null and "b/test_resources/\345\271\263\351\235\242.pmx" differ diff --git "a/test_resources/\345\271\263\351\235\2422\343\201\244.pmx" "b/test_resources/\345\271\263\351\235\2422\343\201\244.pmx" new file mode 100644 index 00000000..26a33672 Binary files /dev/null and "b/test_resources/\345\271\263\351\235\2422\343\201\244.pmx" differ diff --git "a/test_resources/\345\271\263\351\235\2423\343\201\244.pmx" "b/test_resources/\345\271\263\351\235\2423\343\201\244.pmx" new file mode 100644 index 00000000..f72a2f40 Binary files /dev/null and "b/test_resources/\345\271\263\351\235\2423\343\201\244.pmx" differ diff --git "a/test_resources/\346\233\262\343\201\222\346\237\261tex.pmx" "b/test_resources/\346\233\262\343\201\222\346\237\261tex.pmx" new file mode 100644 index 00000000..334251ff Binary files /dev/null and "b/test_resources/\346\233\262\343\201\222\346\237\261tex.pmx" differ diff --git a/utils/file_utils.go b/utils/file_utils.go deleted file mode 100644 index 6d437c0a..00000000 --- a/utils/file_utils.go +++ /dev/null @@ -1,99 +0,0 @@ -package utils - -import ( - "encoding/json" - "fmt" - "os" -) - -const configFilePath = "config.json" - -// 設定の保存 -func SaveConfig(key string, values []string, limit int) error { - // Unmarshal the JSON data into a map - println(configFilePath) - data, err := os.ReadFile(configFilePath) - if err != nil { - data = []byte("{}") - } - - // Unmarshal the JSON data into a map - config := make(map[string]interface{}) - err = json.Unmarshal(data, &config) - if err != nil { - return err - } - - // Check if the value is nil and initialize it as an empty slice of strings - if config[key] == nil { - config[key] = []string{} - } - - // Convert the interface{} type to []interface{} - existingValues, ok := config[key].([]interface{}) - if !ok { - existingValues = make([]interface{}, 0) - } - - // Convert each element to string - existingValuesStrList := make([]string, len(existingValues)) - for i, v := range existingValues { - existingValuesStrList[i] = fmt.Sprintf("%v", v) - } - - // Add key-value elements to the config map - config[key] = append(values, existingValuesStrList...)[:limit] - - // Create a JSON representation of the config map without newlines and indentation - updatedData, err := json.Marshal(config) - if err != nil { - return err - } - - // Overwrite the config.json file with the updated JSON data - err = os.WriteFile(configFilePath, updatedData, 0644) - if err != nil { - return err - } - - return nil -} - -// 設定の読み込み -func LoadConfig(key string) []string { - // Read the config.json file - data, err := os.ReadFile(configFilePath) - if err != nil { - data = []byte("{}") - } - - // Unmarshal the JSON data into a map - config := make(map[string]interface{}) - err = json.Unmarshal(data, &config) - if err != nil { - return []string{} - } - - // Check if the value is nil and initialize it as an empty slice of strings - if config[key] == nil { - return []string{} - } - - // Convert the interface{} type to []interface{} - values, ok := config[key].([]interface{}) - if !ok { - return []string{} - } - - // Convert each element to string - result := make([]string, len(values)) - for i, v := range values { - if str, ok := v.(string); ok { - result[i] = str - } else { - return []string{} - } - } - - return result -}